From 5824ab178b0b28c948798576de78625ba8209adc Mon Sep 17 00:00:00 2001
From: Alex Macleod <alex@macleod.io>
Date: Wed, 26 Jun 2024 14:02:52 +0000
Subject: [PATCH 01/12] Support lists and stylings in more places for `rustc
 --explain`

---
 .../src/error_codes/E0373.md                  |  2 +-
 .../src/error_codes/E0378.md                  |  2 +-
 compiler/rustc_errors/src/lib.rs              |  1 +
 compiler/rustc_errors/src/markdown/parse.rs   | 62 ++++++++++--------
 .../rustc_errors/src/markdown/tests/parse.rs  | 65 +++++++++++++++++--
 5 files changed, 96 insertions(+), 36 deletions(-)

diff --git a/compiler/rustc_error_codes/src/error_codes/E0373.md b/compiler/rustc_error_codes/src/error_codes/E0373.md
index effa597aad918..d4d26007aa50e 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0373.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0373.md
@@ -70,4 +70,4 @@ fn spawn<F: Future + Send + 'static>(future: F) {
 
 Similarly to closures, `async` blocks are not executed immediately and may
 capture closed-over data by reference. For more information, see
-https://rust-lang.github.io/async-book/03_async_await/01_chapter.html.
+<https://rust-lang.github.io/async-book/03_async_await/01_chapter.html>.
diff --git a/compiler/rustc_error_codes/src/error_codes/E0378.md b/compiler/rustc_error_codes/src/error_codes/E0378.md
index c6fe997f3dcfc..7d939b99b04eb 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0378.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0378.md
@@ -20,7 +20,7 @@ where
 
 The `DispatchFromDyn` trait currently can only be implemented for
 builtin pointer types and structs that are newtype wrappers around them
-— that is, the struct must have only one field (except for`PhantomData`),
+— that is, the struct must have only one field (except for `PhantomData`),
 and that field must itself implement `DispatchFromDyn`.
 
 ```
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index 91112a572770e..76045c69cc1c6 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -15,6 +15,7 @@
 #![feature(box_patterns)]
 #![feature(error_reporter)]
 #![feature(extract_if)]
+#![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(negative_impls)]
 #![feature(never_type)]
diff --git a/compiler/rustc_errors/src/markdown/parse.rs b/compiler/rustc_errors/src/markdown/parse.rs
index 67e4963fddf7f..69e7120e7149b 100644
--- a/compiler/rustc_errors/src/markdown/parse.rs
+++ b/compiler/rustc_errors/src/markdown/parse.rs
@@ -10,15 +10,15 @@ const CBK: &[u8] = b"```";
 const CIL: &[u8] = b"`";
 const CMT_E: &[u8] = b"-->";
 const CMT_S: &[u8] = b"<!--";
-const EMP: &[u8] = b"_";
+const EMP_U: &[u8] = b"_";
+const EMP_A: &[u8] = b"*";
 const HDG: &[u8] = b"#";
 const LNK_CHARS: &str = "$-_.+!*'()/&?=:%";
 const LNK_E: &[u8] = b"]";
 const LNK_S: &[u8] = b"[";
-const STG: &[u8] = b"**";
+const STG_U: &[u8] = b"__";
+const STG_A: &[u8] = b"**";
 const STK: &[u8] = b"~~";
-const UL1: &[u8] = b"* ";
-const UL2: &[u8] = b"- ";
 
 /// Pattern replacements
 const REPLACEMENTS: &[(&str, &str)] = &[
@@ -100,22 +100,29 @@ fn parse_recursive<'a>(buf: &'a [u8], ctx: Context) -> MdStream<'_> {
         };
 
         let res: ParseResult<'_> = match (top_blk, prev) {
-            (_, Newline | Whitespace) if loop_buf.starts_with(CMT_S) => {
+            _ if loop_buf.starts_with(CMT_S) => {
                 parse_simple_pat(loop_buf, CMT_S, CMT_E, Po::TrimNoEsc, MdTree::Comment)
             }
             (true, Newline) if loop_buf.starts_with(CBK) => Some(parse_codeblock(loop_buf)),
-            (_, Newline | Whitespace) if loop_buf.starts_with(CIL) => parse_codeinline(loop_buf),
+            _ if loop_buf.starts_with(CIL) => parse_codeinline(loop_buf),
             (true, Newline | Whitespace) if loop_buf.starts_with(HDG) => parse_heading(loop_buf),
             (true, Newline) if loop_buf.starts_with(BRK) => {
                 Some((MdTree::HorizontalRule, parse_to_newline(loop_buf).1))
             }
-            (_, Newline | Whitespace) if loop_buf.starts_with(EMP) => {
-                parse_simple_pat(loop_buf, EMP, EMP, Po::None, MdTree::Emphasis)
+            (_, Newline) if unordered_list_start(loop_buf) => Some(parse_unordered_li(loop_buf)),
+            (_, Newline | Whitespace) if loop_buf.starts_with(STG_U) => {
+                parse_simple_pat(loop_buf, STG_U, STG_U, Po::None, MdTree::Strong)
             }
-            (_, Newline | Whitespace) if loop_buf.starts_with(STG) => {
-                parse_simple_pat(loop_buf, STG, STG, Po::None, MdTree::Strong)
+            _ if loop_buf.starts_with(STG_A) => {
+                parse_simple_pat(loop_buf, STG_A, STG_A, Po::None, MdTree::Strong)
             }
-            (_, Newline | Whitespace) if loop_buf.starts_with(STK) => {
+            (_, Newline | Whitespace) if loop_buf.starts_with(EMP_U) => {
+                parse_simple_pat(loop_buf, EMP_U, EMP_U, Po::None, MdTree::Emphasis)
+            }
+            _ if loop_buf.starts_with(EMP_A) => {
+                parse_simple_pat(loop_buf, EMP_A, EMP_A, Po::None, MdTree::Emphasis)
+            }
+            _ if loop_buf.starts_with(STK) => {
                 parse_simple_pat(loop_buf, STK, STK, Po::None, MdTree::Strikethrough)
             }
             (_, Newline | Whitespace) if loop_buf.starts_with(ANC_S) => {
@@ -130,11 +137,8 @@ fn parse_recursive<'a>(buf: &'a [u8], ctx: Context) -> MdStream<'_> {
                     _ => None,
                 }
             }
-            (_, Newline) if (loop_buf.starts_with(UL1) || loop_buf.starts_with(UL2)) => {
-                Some(parse_unordered_li(loop_buf))
-            }
             (_, Newline) if ord_list_start(loop_buf).is_some() => Some(parse_ordered_li(loop_buf)),
-            (_, Newline | Whitespace) if loop_buf.starts_with(LNK_S) => {
+            _ if loop_buf.starts_with(LNK_S) => {
                 parse_any_link(loop_buf, top_blk && prev == Prev::Newline)
             }
             (_, Escape | _) => None,
@@ -251,7 +255,6 @@ fn parse_heading(buf: &[u8]) -> ParseResult<'_> {
 
 /// Bulleted list
 fn parse_unordered_li(buf: &[u8]) -> Parsed<'_> {
-    debug_assert!(buf.starts_with(b"* ") || buf.starts_with(b"- "));
     let (txt, rest) = get_indented_section(&buf[2..]);
     let ctx = Context { top_block: false, prev: Prev::Whitespace };
     let stream = parse_recursive(trim_ascii_start(txt), ctx);
@@ -267,25 +270,28 @@ fn parse_ordered_li(buf: &[u8]) -> Parsed<'_> {
     (MdTree::OrderedListItem(num, stream), rest)
 }
 
-/// Find first line that isn't empty or doesn't start with whitespace, that will
-/// be our contents
 fn get_indented_section(buf: &[u8]) -> (&[u8], &[u8]) {
-    let mut end = buf.len();
-    for (idx, window) in buf.windows(2).enumerate() {
-        let &[ch, next_ch] = window else { unreachable!("always 2 elements") };
-        if idx >= buf.len().saturating_sub(2) && next_ch == b'\n' {
-            // End of stream
-            end = buf.len().saturating_sub(1);
-            break;
-        } else if ch == b'\n' && (!next_ch.is_ascii_whitespace() || next_ch == b'\n') {
-            end = idx;
-            break;
+    let mut lines = buf.split(|&byte| byte == b'\n');
+    let mut end = lines.next().map_or(0, |line| line.len());
+    for line in lines {
+        if let Some(first) = line.first() {
+            if unordered_list_start(line) || !first.is_ascii_whitespace() {
+                break;
+            }
         }
+        end += line.len() + 1;
     }
 
     (&buf[..end], &buf[end..])
 }
 
+fn unordered_list_start(mut buf: &[u8]) -> bool {
+    while let [b' ', rest @ ..] = buf {
+        buf = rest;
+    }
+    matches!(buf, [b'*' | b'-', b' ', ..])
+}
+
 /// Verify a valid ordered list start (e.g. `1.`) and parse it. Returns the
 /// parsed number and offset of character after the dot.
 fn ord_list_start(buf: &[u8]) -> Option<(u16, usize)> {
diff --git a/compiler/rustc_errors/src/markdown/tests/parse.rs b/compiler/rustc_errors/src/markdown/tests/parse.rs
index e39e8c89b350b..e2e3f354ff6cb 100644
--- a/compiler/rustc_errors/src/markdown/tests/parse.rs
+++ b/compiler/rustc_errors/src/markdown/tests/parse.rs
@@ -4,13 +4,13 @@ use ParseOpt as PO;
 #[test]
 fn test_parse_simple() {
     let buf = "**abcd** rest";
-    let (t, r) = parse_simple_pat(buf.as_bytes(), STG, STG, PO::None, MdTree::Strong).unwrap();
+    let (t, r) = parse_simple_pat(buf.as_bytes(), b"**", b"**", PO::None, MdTree::Strong).unwrap();
     assert_eq!(t, MdTree::Strong("abcd"));
     assert_eq!(r, b" rest");
 
     // Escaping should fail
     let buf = r"**abcd\** rest";
-    let res = parse_simple_pat(buf.as_bytes(), STG, STG, PO::None, MdTree::Strong);
+    let res = parse_simple_pat(buf.as_bytes(), b"**", b"**", PO::None, MdTree::Strong);
     assert!(res.is_none());
 }
 
@@ -141,12 +141,12 @@ fn test_indented_section() {
     assert_eq!(str::from_utf8(r).unwrap(), "\nnot ind");
 
     let (txt, rest) = get_indented_section(IND2.as_bytes());
-    assert_eq!(str::from_utf8(txt).unwrap(), "test end of stream\n  1\n  2");
-    assert_eq!(str::from_utf8(rest).unwrap(), "\n");
+    assert_eq!(str::from_utf8(txt).unwrap(), "test end of stream\n  1\n  2\n");
+    assert_eq!(str::from_utf8(rest).unwrap(), "");
 
     let (txt, rest) = get_indented_section(IND3.as_bytes());
-    assert_eq!(str::from_utf8(txt).unwrap(), "test empty lines\n  1\n  2");
-    assert_eq!(str::from_utf8(rest).unwrap(), "\n\nnot ind");
+    assert_eq!(str::from_utf8(txt).unwrap(), "test empty lines\n  1\n  2\n");
+    assert_eq!(str::from_utf8(rest).unwrap(), "\nnot ind");
 }
 
 const HBT: &str = r"# Heading
@@ -310,3 +310,56 @@ fn test_code_at_start() {
     let res = entrypoint(CODE_STARTLINE);
     assert_eq!(res, expected);
 }
+
+#[test]
+fn test_code_in_parens() {
+    let expected =
+        vec![MdTree::PlainText("("), MdTree::CodeInline("Foo"), MdTree::PlainText(")")].into();
+    let res = entrypoint("(`Foo`)");
+    assert_eq!(res, expected);
+}
+
+const LIST_WITH_SPACE: &str = "
+para
+ * l1
+ * l2
+";
+
+#[test]
+fn test_list_with_space() {
+    let expected = vec![
+        MdTree::PlainText("para"),
+        MdTree::ParagraphBreak,
+        MdTree::UnorderedListItem(vec![MdTree::PlainText("l1")].into()),
+        MdTree::LineBreak,
+        MdTree::UnorderedListItem(vec![MdTree::PlainText("l2")].into()),
+    ]
+    .into();
+    let res = entrypoint(LIST_WITH_SPACE);
+    assert_eq!(res, expected);
+}
+
+const SNAKE_CASE: &str = "
+foo*bar*
+foo**bar**
+foo_bar_
+foo__bar__
+";
+
+#[test]
+fn test_snake_case() {
+    let expected = vec![
+        MdTree::PlainText("foo"),
+        MdTree::Emphasis("bar"),
+        MdTree::PlainText(" "),
+        MdTree::PlainText("foo"),
+        MdTree::Strong("bar"),
+        MdTree::PlainText(" "),
+        MdTree::PlainText("foo_bar_"),
+        MdTree::PlainText(" "),
+        MdTree::PlainText("foo__bar__"),
+    ]
+    .into();
+    let res = entrypoint(SNAKE_CASE);
+    assert_eq!(res, expected);
+}

From 632f01306b2a5b7f47e554cf1280f5ef8fc9f710 Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Fri, 19 Jul 2024 16:23:29 -0400
Subject: [PATCH 02/12] rewrite lto-linkage-used-attr to rmake

---
 src/tools/tidy/src/allowed_run_make_makefiles.txt |  1 -
 tests/run-make/lto-linkage-used-attr/Makefile     |  8 --------
 tests/run-make/lto-linkage-used-attr/rmake.rs     | 14 ++++++++++++++
 3 files changed, 14 insertions(+), 9 deletions(-)
 delete mode 100644 tests/run-make/lto-linkage-used-attr/Makefile
 create mode 100644 tests/run-make/lto-linkage-used-attr/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 6b3533c25785f..5cb580e9f799d 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -47,7 +47,6 @@ run-make/link-cfg/Makefile
 run-make/link-framework/Makefile
 run-make/long-linker-command-lines-cmd-exe/Makefile
 run-make/long-linker-command-lines/Makefile
-run-make/lto-linkage-used-attr/Makefile
 run-make/macos-deployment-target/Makefile
 run-make/min-global-align/Makefile
 run-make/native-link-modifier-bundle/Makefile
diff --git a/tests/run-make/lto-linkage-used-attr/Makefile b/tests/run-make/lto-linkage-used-attr/Makefile
deleted file mode 100644
index fed41a00f84b3..0000000000000
--- a/tests/run-make/lto-linkage-used-attr/Makefile
+++ /dev/null
@@ -1,8 +0,0 @@
-include ../tools.mk
-
-# Verify that the impl_* symbols are preserved. #108030
-# only-x86_64-unknown-linux-gnu
-
-all:
-	$(RUSTC) -Cdebuginfo=0 -Copt-level=3 lib.rs
-	$(RUSTC) -Clto=fat -Cdebuginfo=0 -Copt-level=3 main.rs
diff --git a/tests/run-make/lto-linkage-used-attr/rmake.rs b/tests/run-make/lto-linkage-used-attr/rmake.rs
new file mode 100644
index 0000000000000..114c5dcf5212d
--- /dev/null
+++ b/tests/run-make/lto-linkage-used-attr/rmake.rs
@@ -0,0 +1,14 @@
+// Link time optimizations (LTO) used to snip away some important symbols
+// when setting optimization level to 3 or higher.
+// This is an LLVM, not a rustc bug, fixed here: https://reviews.llvm.org/D145293
+// This test checks that the impl_* symbols are preserved as they should.
+// See https://github.com/rust-lang/rust/issues/108030
+
+//FIXME(Oneirical): try it on more than only-x86_64-unknown-linux-gnu
+
+use run_make_support::rustc;
+
+fn main() {
+    rustc().arg("-Cdebuginfo=0").opt_level("3").input("lib.rs").run();
+    rustc().arg("-Clto=fat").arg("-Cdebuginfo=0").opt_level("3").input("main.rs").run();
+}

From f307287659b8492d6baec07bb2a5902a6b487052 Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Fri, 19 Jul 2024 16:35:37 -0400
Subject: [PATCH 03/12] rewrite no-duplicate-libs to rmake

---
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 tests/run-make/no-duplicate-libs/Makefile     | 11 ----------
 tests/run-make/no-duplicate-libs/rmake.rs     | 21 +++++++++++++++++++
 3 files changed, 21 insertions(+), 12 deletions(-)
 delete mode 100644 tests/run-make/no-duplicate-libs/Makefile
 create mode 100644 tests/run-make/no-duplicate-libs/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 5cb580e9f799d..bc3da81fa5224 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -53,7 +53,6 @@ run-make/native-link-modifier-bundle/Makefile
 run-make/native-link-modifier-whole-archive/Makefile
 run-make/no-alloc-shim/Makefile
 run-make/no-builtins-attribute/Makefile
-run-make/no-duplicate-libs/Makefile
 run-make/panic-abort-eh_frame/Makefile
 run-make/pdb-buildinfo-cl-cmd/Makefile
 run-make/pgo-gen-lto/Makefile
diff --git a/tests/run-make/no-duplicate-libs/Makefile b/tests/run-make/no-duplicate-libs/Makefile
deleted file mode 100644
index 4be8c0262941a..0000000000000
--- a/tests/run-make/no-duplicate-libs/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-ifdef IS_MSVC
-# FIXME(#27979)
-all:
-else
-all: $(call STATICLIB,foo) $(call STATICLIB,bar)
-	$(RUSTC) main.rs
-	$(call RUN,main)
-endif
diff --git a/tests/run-make/no-duplicate-libs/rmake.rs b/tests/run-make/no-duplicate-libs/rmake.rs
new file mode 100644
index 0000000000000..35b1234ef3484
--- /dev/null
+++ b/tests/run-make/no-duplicate-libs/rmake.rs
@@ -0,0 +1,21 @@
+// The rust compiler used to try to detect duplicated libraries in
+// the linking order and remove the duplicates... but certain edge cases,
+// such as the one presented in `foo` and `bar` in this test, demand precise
+// control over the link order, including duplicates. As the anti-duplication
+// filter was removed, this test should now successfully see main be compiled
+// and executed.
+// See https://github.com/rust-lang/rust/pull/12688
+
+//@ ignore-cross-compile
+// Reason: the compiled binary is executed
+
+// FIXME(Oneirical): try on msvc because of #27979
+
+use run_make_support::{build_native_static_lib, run, rustc};
+
+fn main() {
+    build_native_static_lib("foo");
+    build_native_static_lib("bar");
+    rustc().input("main.rs").run();
+    run("main");
+}

From c3d3d6fe0295c2521801fc4d0c6afe73e4d1328c Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 22 Jul 2024 07:57:53 -0700
Subject: [PATCH 04/12] Fix inclusion of `wasm-component-ld` in dist artifacts

This is another accidental omission from #126967 (in addition
to #127867) which fixes an issue where `wasm-component-ld` isn't
distributed via rustup just yet because while it's present in the
sysroot it's not present in the tarballs.
---
 src/bootstrap/src/core/build_steps/dist.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/bootstrap/src/core/build_steps/dist.rs b/src/bootstrap/src/core/build_steps/dist.rs
index 1e9d2025bc78d..9f0579e7f1cc3 100644
--- a/src/bootstrap/src/core/build_steps/dist.rs
+++ b/src/bootstrap/src/core/build_steps/dist.rs
@@ -472,6 +472,11 @@ impl Step for Rustc {
                     );
                 }
             }
+            if builder.build_wasm_component_ld() {
+                let src_dir = builder.sysroot_libdir(compiler, host).parent().unwrap().join("bin");
+                let ld = exe("wasm-component-ld", compiler.host);
+                builder.copy_link(&src_dir.join(&ld), &dst_dir.join(&ld));
+            }
 
             // Man pages
             t!(fs::create_dir_all(image.join("share/man/man1")));

From 6d9d605fcac79ad8180f2368c69fd2eb3c18988d Mon Sep 17 00:00:00 2001
From: Oneirical <manchot@videotron.ca>
Date: Fri, 19 Jul 2024 16:43:06 -0400
Subject: [PATCH 05/12] rewrite pgo-gen-no-imp-symbols to rmake

---
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 tests/run-make/lto-linkage-used-attr/rmake.rs |  3 ++-
 tests/run-make/no-duplicate-libs/rmake.rs     |  3 ++-
 .../run-make/pgo-gen-no-imp-symbols/Makefile  | 11 --------
 .../run-make/pgo-gen-no-imp-symbols/rmake.rs  | 27 +++++++++++++++++++
 5 files changed, 31 insertions(+), 14 deletions(-)
 delete mode 100644 tests/run-make/pgo-gen-no-imp-symbols/Makefile
 create mode 100644 tests/run-make/pgo-gen-no-imp-symbols/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index bc3da81fa5224..5f0a953bc2bbd 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -56,7 +56,6 @@ run-make/no-builtins-attribute/Makefile
 run-make/panic-abort-eh_frame/Makefile
 run-make/pdb-buildinfo-cl-cmd/Makefile
 run-make/pgo-gen-lto/Makefile
-run-make/pgo-gen-no-imp-symbols/Makefile
 run-make/pgo-indirect-call-promotion/Makefile
 run-make/pointer-auth-link-with-c/Makefile
 run-make/print-calling-conventions/Makefile
diff --git a/tests/run-make/lto-linkage-used-attr/rmake.rs b/tests/run-make/lto-linkage-used-attr/rmake.rs
index 114c5dcf5212d..12463b79a754b 100644
--- a/tests/run-make/lto-linkage-used-attr/rmake.rs
+++ b/tests/run-make/lto-linkage-used-attr/rmake.rs
@@ -4,7 +4,8 @@
 // This test checks that the impl_* symbols are preserved as they should.
 // See https://github.com/rust-lang/rust/issues/108030
 
-//FIXME(Oneirical): try it on more than only-x86_64-unknown-linux-gnu
+//@ only-x86_64-unknown-linux-gnu
+// Reason: some of the inline assembly directives are architecture-specific.
 
 use run_make_support::rustc;
 
diff --git a/tests/run-make/no-duplicate-libs/rmake.rs b/tests/run-make/no-duplicate-libs/rmake.rs
index 35b1234ef3484..469348e266cb8 100644
--- a/tests/run-make/no-duplicate-libs/rmake.rs
+++ b/tests/run-make/no-duplicate-libs/rmake.rs
@@ -9,7 +9,8 @@
 //@ ignore-cross-compile
 // Reason: the compiled binary is executed
 
-// FIXME(Oneirical): try on msvc because of #27979
+//@ ignore-msvc
+// Reason: native compilation results in an unresolved external symbol
 
 use run_make_support::{build_native_static_lib, run, rustc};
 
diff --git a/tests/run-make/pgo-gen-no-imp-symbols/Makefile b/tests/run-make/pgo-gen-no-imp-symbols/Makefile
deleted file mode 100644
index d2baa145ba506..0000000000000
--- a/tests/run-make/pgo-gen-no-imp-symbols/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-include ../tools.mk
-
-COMPILE_FLAGS=-O -Ccodegen-units=1 -Cprofile-generate="$(TMPDIR)" -Zno-profiler-runtime
-
-all:
-	$(RUSTC) $(COMPILE_FLAGS) --emit=llvm-ir test.rs
-	# We expect symbols starting with "__llvm_profile_".
-	$(CGREP) "__llvm_profile_" < $(TMPDIR)/test.ll
-	# We do NOT expect the "__imp_" version of these symbols.
-	$(CGREP) -v "__imp___llvm_profile_" < $(TMPDIR)/test.ll # 64 bit
-	$(CGREP) -v "__imp____llvm_profile_" < $(TMPDIR)/test.ll # 32 bit
diff --git a/tests/run-make/pgo-gen-no-imp-symbols/rmake.rs b/tests/run-make/pgo-gen-no-imp-symbols/rmake.rs
new file mode 100644
index 0000000000000..85ade7885ce7e
--- /dev/null
+++ b/tests/run-make/pgo-gen-no-imp-symbols/rmake.rs
@@ -0,0 +1,27 @@
+// LLVM's profiling instrumentation adds a few symbols that are used by the profiler runtime.
+// Since these show up as globals in the LLVM IR, the compiler generates dllimport-related
+// __imp_ stubs for them. This can lead to linker errors because the instrumentation
+// symbols have weak linkage or are in a comdat section, but the __imp_ stubs aren't.
+// Since profiler-related symbols were excluded from stub-generation in #59812, this has
+// been fixed, and this test checks that the llvm profile symbol appear, but without the
+// anomalous __imp_ stubs.
+// See https://github.com/rust-lang/rust/pull/59812
+
+use run_make_support::{cwd, rfs, rustc};
+
+fn main() {
+    rustc()
+        .input("test.rs")
+        .emit("llvm-ir")
+        .opt()
+        .codegen_units(1)
+        .profile_generate(cwd())
+        .arg("-Zno-profiler-runtime")
+        .run();
+    let out = rfs::read_to_string("test.ll");
+    // We expect symbols starting with "__llvm_profile_".
+    assert!(out.contains("__llvm_profile_"));
+    // We do NOT expect the "__imp_" version of these symbols.
+    assert!(!out.contains("__imp___llvm_profile_")); // 64 bit
+    assert!(!out.contains("__imp____llvm_profile_")); // 32 bit
+}

From e8e6111f869e834bf224c9c01fdf430cbd7da924 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Mon, 24 Jun 2024 11:57:52 +0200
Subject: [PATCH 06/12] Migrate `run-make/link-framework` to `rmake.rs`

---
 .../tidy/src/allowed_run_make_makefiles.txt   |  1 -
 tests/run-make/link-framework/Makefile        | 23 -----------
 tests/run-make/link-framework/rmake.rs        | 38 +++++++++++++++++++
 3 files changed, 38 insertions(+), 24 deletions(-)
 delete mode 100644 tests/run-make/link-framework/Makefile
 create mode 100644 tests/run-make/link-framework/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 1cb52ea91f9c2..acda41a0cdf17 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -46,7 +46,6 @@ run-make/libtest-json/Makefile
 run-make/libtest-junit/Makefile
 run-make/libtest-thread-limit/Makefile
 run-make/link-cfg/Makefile
-run-make/link-framework/Makefile
 run-make/long-linker-command-lines-cmd-exe/Makefile
 run-make/long-linker-command-lines/Makefile
 run-make/lto-linkage-used-attr/Makefile
diff --git a/tests/run-make/link-framework/Makefile b/tests/run-make/link-framework/Makefile
deleted file mode 100644
index 96d832ad4a832..0000000000000
--- a/tests/run-make/link-framework/Makefile
+++ /dev/null
@@ -1,23 +0,0 @@
-# only-apple
-#
-# Check that linking to a framework actually makes it to the linker.
-
-include ../tools.mk
-
-all:
-	$(RUSTC) dep-link-framework.rs
-	$(RUSTC) dep-link-weak-framework.rs
-
-	$(RUSTC) empty.rs
-	otool -L $(TMPDIR)/no-link | $(CGREP) -v CoreFoundation
-
-	$(RUSTC) link-framework.rs
-	otool -L $(TMPDIR)/link-framework | $(CGREP) CoreFoundation | $(CGREP) -v weak
-
-	$(RUSTC) link-weak-framework.rs
-	otool -L $(TMPDIR)/link-weak-framework | $(CGREP) CoreFoundation | $(CGREP) weak
-
-# When linking the framework both normally, and weakly, the weak linking takes preference
-
-	$(RUSTC) link-both.rs
-	otool -L $(TMPDIR)/link-both | $(CGREP) CoreFoundation | $(CGREP) weak
diff --git a/tests/run-make/link-framework/rmake.rs b/tests/run-make/link-framework/rmake.rs
new file mode 100644
index 0000000000000..e5df93b181a09
--- /dev/null
+++ b/tests/run-make/link-framework/rmake.rs
@@ -0,0 +1,38 @@
+// Check that linking to a framework actually makes it to the linker.
+
+//@ only-apple
+
+use run_make_support::{cmd, rustc};
+
+fn main() {
+    rustc().input("dep-link-framework.rs").run();
+    rustc().input("dep-link-weak-framework.rs").run();
+
+    rustc().input("empty.rs").run();
+    cmd("otool").arg("-L").arg("no-link").run_fail().assert_stdout_not_contains("CoreFoundation");
+
+    rustc().input("link-framework.rs").run();
+    cmd("otool")
+        .arg("-L")
+        .arg("link-framework")
+        .run()
+        .assert_stdout_contains("CoreFoundation")
+        .assert_stdout_not_contains("weak");
+
+    rustc().input("link-weak-framework.rs").run();
+    cmd("otool")
+        .arg("-L")
+        .arg("link-weak-framework")
+        .run()
+        .assert_stdout_contains("CoreFoundation")
+        .assert_stdout_contains("weak");
+
+    // When linking the framework both normally, and weakly, the weak linking takes preference.
+    rustc().input("link-both.rs").run();
+    cmd("otool")
+        .arg("-L")
+        .arg("link-both")
+        .run()
+        .assert_stdout_contains("CoreFoundation")
+        .assert_stdout_contains("weak");
+}

From 7e0c203f2d4320ad2299a78f6d1dc8ae00cf5bc8 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 2 Jun 2024 11:51:08 +0200
Subject: [PATCH 07/12] Add new `MSVC_LIB_PATH` runtest environment variable to
 know location of the `msvc_lib` binary

---
 src/tools/compiletest/src/runtest.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 5398820313648..7e7f98a13548f 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -3382,6 +3382,7 @@ impl<'test> TestCx<'test> {
             cmd.env("IS_MSVC", "1")
                 .env("IS_WINDOWS", "1")
                 .env("MSVC_LIB", format!("'{}' -nologo", lib.display()))
+                .env("MSVC_LIB_PATH", format!("{}", lib.display()))
                 .env("CC", format!("'{}' {}", self.config.cc, cflags))
                 .env("CXX", format!("'{}' {}", &self.config.cxx, cxxflags));
         } else {
@@ -3752,6 +3753,7 @@ impl<'test> TestCx<'test> {
             cmd.env("IS_MSVC", "1")
                 .env("IS_WINDOWS", "1")
                 .env("MSVC_LIB", format!("'{}' -nologo", lib.display()))
+                .env("MSVC_LIB_PATH", format!("{}", lib.display()))
                 // Note: we diverge from legacy run_make and don't lump `CC` the compiler and
                 // default flags together.
                 .env("CC_DEFAULT_FLAGS", &cflags)

From b7495b401caa7379a19191c491088dc4de95b4c9 Mon Sep 17 00:00:00 2001
From: Michael Goulet <michael@errs.io>
Date: Mon, 22 Jul 2024 21:51:39 -0400
Subject: [PATCH 08/12] Note closure captures when reporting deferred cast to
 fn ptr failed

---
 compiler/rustc_hir_typeck/src/cast.rs    | 1 +
 tests/ui/closures/closure-no-fn-3.stderr | 6 ++++++
 2 files changed, 7 insertions(+)

diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index 341d533492d19..6522972277183 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -495,6 +495,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                     err.span_label(self.span, "invalid cast");
                 }
 
+                fcx.suggest_no_capture_closure(&mut err, self.cast_ty, self.expr_ty);
                 self.try_suggest_collection_to_bool(fcx, &mut err);
 
                 err.emit();
diff --git a/tests/ui/closures/closure-no-fn-3.stderr b/tests/ui/closures/closure-no-fn-3.stderr
index bbf3677fb7235..7711347c5683e 100644
--- a/tests/ui/closures/closure-no-fn-3.stderr
+++ b/tests/ui/closures/closure-no-fn-3.stderr
@@ -3,6 +3,12 @@ error[E0605]: non-primitive cast: `{closure@$DIR/closure-no-fn-3.rs:6:28: 6:30}`
    |
 LL |     let baz: fn() -> u8 = (|| { b }) as fn() -> u8;
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^ invalid cast
+   |
+note: closures can only be coerced to `fn` types if they do not capture any variables
+  --> $DIR/closure-no-fn-3.rs:6:33
+   |
+LL |     let baz: fn() -> u8 = (|| { b }) as fn() -> u8;
+   |                                 ^ `b` captured here
 
 error: aborting due to 1 previous error
 

From 84eee6890d49e067a86f2e844e2d3db2d3b395f2 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 2 Jun 2024 11:51:30 +0200
Subject: [PATCH 09/12] Add `run_make_support::build_native_static_lib`
 function


From 5257ca7f4fcfe55d021d6d30a429b89aaf52a07a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 2 Jun 2024 11:53:00 +0200
Subject: [PATCH 10/12] Migrate `run-make/issue-15460` to `rmake.rs`

---
 src/tools/tidy/src/allowed_run_make_makefiles.txt |  1 -
 tests/run-make/issue-15460/Makefile               |  7 -------
 tests/run-make/issue-15460/rmake.rs               | 12 ++++++++++++
 3 files changed, 12 insertions(+), 8 deletions(-)
 delete mode 100644 tests/run-make/issue-15460/Makefile
 create mode 100644 tests/run-make/issue-15460/rmake.rs

diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index d6da40d3d78f0..3224fdb6933b3 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -27,7 +27,6 @@ run-make/foreign-rust-exceptions/Makefile
 run-make/incr-add-rust-src-component/Makefile
 run-make/incr-foreign-head-span/Makefile
 run-make/interdependent-c-libraries/Makefile
-run-make/issue-15460/Makefile
 run-make/issue-35164/Makefile
 run-make/issue-36710/Makefile
 run-make/issue-47551/Makefile
diff --git a/tests/run-make/issue-15460/Makefile b/tests/run-make/issue-15460/Makefile
deleted file mode 100644
index a36a085fa6f18..0000000000000
--- a/tests/run-make/issue-15460/Makefile
+++ /dev/null
@@ -1,7 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-all: $(call NATIVE_STATICLIB,foo)
-	$(RUSTC) foo.rs -C extra-filename=-383hf8 -C prefer-dynamic
-	$(RUSTC) bar.rs
-	$(call RUN,bar)
diff --git a/tests/run-make/issue-15460/rmake.rs b/tests/run-make/issue-15460/rmake.rs
new file mode 100644
index 0000000000000..6f2c0d4e59536
--- /dev/null
+++ b/tests/run-make/issue-15460/rmake.rs
@@ -0,0 +1,12 @@
+//@ ignore-cross-compile
+
+use run_make_support::{build_native_static_lib, run, rustc};
+
+fn main() {
+    build_native_static_lib("foo");
+
+    rustc().input("foo.rs").extra_filename("-383hf8").arg("-Cprefer-dynamic").run();
+    rustc().input("bar.rs").run();
+
+    run("bar");
+}

From 3de52521aea47df85394c69559008f555fb3ed40 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume.gomez@huawei.com>
Date: Sun, 2 Jun 2024 14:20:39 +0200
Subject: [PATCH 11/12] Rename `tests/run-make/issue-15460` into
 `tests/run-make/link-native-static-lib-to-dylib`

---
 .../{issue-15460 => link-native-static-lib-to-dylib}/bar.rs     | 0
 .../{issue-15460 => link-native-static-lib-to-dylib}/foo.c      | 0
 .../{issue-15460 => link-native-static-lib-to-dylib}/foo.rs     | 0
 .../{issue-15460 => link-native-static-lib-to-dylib}/rmake.rs   | 2 ++
 4 files changed, 2 insertions(+)
 rename tests/run-make/{issue-15460 => link-native-static-lib-to-dylib}/bar.rs (100%)
 rename tests/run-make/{issue-15460 => link-native-static-lib-to-dylib}/foo.c (100%)
 rename tests/run-make/{issue-15460 => link-native-static-lib-to-dylib}/foo.rs (100%)
 rename tests/run-make/{issue-15460 => link-native-static-lib-to-dylib}/rmake.rs (78%)

diff --git a/tests/run-make/issue-15460/bar.rs b/tests/run-make/link-native-static-lib-to-dylib/bar.rs
similarity index 100%
rename from tests/run-make/issue-15460/bar.rs
rename to tests/run-make/link-native-static-lib-to-dylib/bar.rs
diff --git a/tests/run-make/issue-15460/foo.c b/tests/run-make/link-native-static-lib-to-dylib/foo.c
similarity index 100%
rename from tests/run-make/issue-15460/foo.c
rename to tests/run-make/link-native-static-lib-to-dylib/foo.c
diff --git a/tests/run-make/issue-15460/foo.rs b/tests/run-make/link-native-static-lib-to-dylib/foo.rs
similarity index 100%
rename from tests/run-make/issue-15460/foo.rs
rename to tests/run-make/link-native-static-lib-to-dylib/foo.rs
diff --git a/tests/run-make/issue-15460/rmake.rs b/tests/run-make/link-native-static-lib-to-dylib/rmake.rs
similarity index 78%
rename from tests/run-make/issue-15460/rmake.rs
rename to tests/run-make/link-native-static-lib-to-dylib/rmake.rs
index 6f2c0d4e59536..0746c3963143b 100644
--- a/tests/run-make/issue-15460/rmake.rs
+++ b/tests/run-make/link-native-static-lib-to-dylib/rmake.rs
@@ -1,3 +1,5 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/15460>.
+
 //@ ignore-cross-compile
 
 use run_make_support::{build_native_static_lib, run, rustc};

From d4f3673a54fecf005920ef2fffd5e1f78cc87b85 Mon Sep 17 00:00:00 2001
From: onur-ozkan <work@onurozkan.dev>
Date: Tue, 23 Jul 2024 18:02:01 +0300
Subject: [PATCH 12/12] make it possible to disable download-rustc if it's
 incompatible

Primarily needed by CI runners to avoid handling download-rustc incompatible
options one by one on shell scripts.

Signed-off-by: onur-ozkan <work@onurozkan.dev>
---
 src/bootstrap/src/core/config/config.rs | 36 +++++++++++++++++--------
 1 file changed, 25 insertions(+), 11 deletions(-)

diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index f96633b059a17..a78a213f53082 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -1570,11 +1570,22 @@ impl Config {
         let mut is_user_configured_rust_channel = false;
 
         if let Some(rust) = toml.rust {
-            config.download_rustc_commit =
-                config.download_ci_rustc_commit(rust.download_rustc.clone());
-
-            if config.download_rustc_commit.is_some() {
-                check_incompatible_options_for_ci_rustc(&rust);
+            if let Some(commit) = config.download_ci_rustc_commit(rust.download_rustc.clone()) {
+                // Primarily used by CI runners to avoid handling download-rustc incompatible
+                // options one by one on shell scripts.
+                let disable_ci_rustc_if_incompatible =
+                    env::var_os("DISABLE_CI_RUSTC_IF_INCOMPATIBLE")
+                        .is_some_and(|s| s == "1" || s == "true");
+
+                if let Err(e) = check_incompatible_options_for_ci_rustc(&rust) {
+                    if disable_ci_rustc_if_incompatible {
+                        config.download_rustc_commit = None;
+                    } else {
+                        panic!("{}", e);
+                    }
+                } else {
+                    config.download_rustc_commit = Some(commit);
+                }
             }
 
             let Rust {
@@ -2614,14 +2625,15 @@ impl Config {
 
 /// Checks the CI rustc incompatible options by destructuring the `Rust` instance
 /// and makes sure that no rust options from config.toml are missed.
-fn check_incompatible_options_for_ci_rustc(rust: &Rust) {
+fn check_incompatible_options_for_ci_rustc(rust: &Rust) -> Result<(), String> {
     macro_rules! err {
         ($name:expr) => {
-            assert!(
-                $name.is_none(),
-                "ERROR: Setting `rust.{}` is incompatible with `rust.download-rustc`.",
-                stringify!($name).replace("_", "-")
-            );
+            if $name.is_some() {
+                return Err(format!(
+                    "ERROR: Setting `rust.{}` is incompatible with `rust.download-rustc`.",
+                    stringify!($name).replace("_", "-")
+                ));
+            }
         };
     }
 
@@ -2717,6 +2729,8 @@ fn check_incompatible_options_for_ci_rustc(rust: &Rust) {
     warn!(channel);
     warn!(description);
     warn!(incremental);
+
+    Ok(())
 }
 
 fn set<T>(field: &mut T, val: Option<T>) {