diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index e3dde89aefc93..1980980b6d05c 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -1400,6 +1400,8 @@ impl Step for RunMakeSupport {
 
 default_test!(Ui { path: "tests/ui", mode: "ui", suite: "ui" });
 
+default_test!(Crashes { path: "tests/crashes", mode: "crashes", suite: "crashes" });
+
 default_test!(RunPassValgrind {
     path: "tests/run-pass-valgrind",
     mode: "run-pass-valgrind",
diff --git a/src/bootstrap/src/core/builder.rs b/src/bootstrap/src/core/builder.rs
index e3b27600c5e07..224f5350e40a7 100644
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@@ -745,6 +745,7 @@ impl<'a> Builder<'a> {
                 test::ExpandYamlAnchors,
                 test::Tidy,
                 test::Ui,
+                test::Crashes,
                 test::RunPassValgrind,
                 test::Coverage,
                 test::CoverageMap,
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 78246136f2a1b..aa69791b3b4b4 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -69,6 +69,7 @@ string_enum! {
         Assembly => "assembly",
         CoverageMap => "coverage-map",
         CoverageRun => "coverage-run",
+        Crashes => "crashes",
     }
 }
 
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index e6f4accfd7b98..f78e0363f55ba 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -581,6 +581,16 @@ impl TestProps {
             self.incremental = true;
         }
 
+        if config.mode == Mode::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
+            self.rustc_env = vec![
+                ("RUST_BACKTRACE".to_string(), "0".to_string()),
+                ("RUSTC_ICE".to_string(), "0".to_string()),
+            ];
+        }
+
         for key in &["RUST_TEST_NOCAPTURE", "RUST_TEST_THREADS"] {
             if let Ok(val) = env::var(key) {
                 if self.exec_env.iter().find(|&&(ref x, _)| x == key).is_none() {
@@ -596,7 +606,8 @@ impl TestProps {
 
     fn update_fail_mode(&mut self, ln: &str, config: &Config) {
         let check_ui = |mode: &str| {
-            if config.mode != Mode::Ui {
+            // Mode::Crashes may need build-fail in order to trigger llvm errors or stack overflows
+            if config.mode != Mode::Ui && config.mode != Mode::Crashes {
                 panic!("`{}-fail` header is only supported in UI tests", mode);
             }
         };
@@ -625,6 +636,7 @@ 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, _) => {
                 if revision.is_some() && !self.revisions.iter().all(|r| r.starts_with("cfail")) {
@@ -757,6 +769,7 @@ const KNOWN_DIRECTIVE_NAMES: &[&str] = &[
     "ignore-mode-codegen-units",
     "ignore-mode-coverage-map",
     "ignore-mode-coverage-run",
+    "ignore-mode-crashes",
     "ignore-mode-debuginfo",
     "ignore-mode-incremental",
     "ignore-mode-js-doc-test",
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 1624e2a60843a..c8a8b79921e21 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -65,7 +65,8 @@ pub fn parse_config(args: Vec<String>) -> Config {
             "mode",
             "which sort of compile tests to run",
             "run-pass-valgrind | pretty | debug-info | codegen | rustdoc \
-            | rustdoc-json | codegen-units | incremental | run-make | ui | js-doc-test | mir-opt | assembly",
+            | rustdoc-json | codegen-units | incremental | run-make | ui \
+            | js-doc-test | mir-opt | assembly | crashes",
         )
         .reqopt(
             "",
@@ -82,7 +83,12 @@ pub fn parse_config(args: Vec<String>) -> Config {
         .optopt("", "run", "whether to execute run-* tests", "auto | always | never")
         .optflag("", "ignored", "run tests marked as ignored")
         .optflag("", "with-debug-assertions", "whether to run tests with `ignore-debug` header")
-        .optmulti("", "skip", "skip tests matching SUBSTRING. Can be passed multiple times", "SUBSTRING")
+        .optmulti(
+            "",
+            "skip",
+            "skip tests matching SUBSTRING. Can be passed multiple times",
+            "SUBSTRING",
+        )
         .optflag("", "exact", "filters match exactly")
         .optopt(
             "",
@@ -145,7 +151,11 @@ pub fn parse_config(args: Vec<String>) -> Config {
         .optflag("", "profiler-support", "is the profiler runtime enabled for this target")
         .optflag("h", "help", "show this message")
         .reqopt("", "channel", "current Rust channel", "CHANNEL")
-        .optflag("", "git-hash", "run tests which rely on commit version being compiled into the binaries")
+        .optflag(
+            "",
+            "git-hash",
+            "run tests which rely on commit version being compiled into the binaries",
+        )
         .optopt("", "edition", "default Rust edition", "EDITION")
         .reqopt("", "git-repository", "name of the git repository", "ORG/REPO")
         .reqopt("", "nightly-branch", "name of the git branch for nightly", "BRANCH");
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 5212f1430d831..38d22fef11329 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -4,7 +4,7 @@ use crate::common::{
     expected_output_path, UI_EXTENSIONS, UI_FIXED, UI_STDERR, UI_STDOUT, UI_SVG, UI_WINDOWS_SVG,
 };
 use crate::common::{incremental_dir, output_base_dir, output_base_name, output_testname_unique};
-use crate::common::{Assembly, Incremental, JsDocTest, MirOpt, RunMake, RustdocJson, Ui};
+use crate::common::{Assembly, Crashes, Incremental, JsDocTest, MirOpt, RunMake, RustdocJson, Ui};
 use crate::common::{Codegen, CodegenUnits, DebugInfo, Debugger, Rustdoc};
 use crate::common::{CompareMode, FailMode, PassMode};
 use crate::common::{Config, TestPaths};
@@ -244,7 +244,7 @@ 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 {
+        if self.props.should_ice && self.config.mode != Incremental && self.config.mode != Crashes {
             self.fatal("cannot use should-ice in a test that is not cfail");
         }
         match self.config.mode {
@@ -263,6 +263,7 @@ impl<'test> TestCx<'test> {
             JsDocTest => self.run_js_doc_test(),
             CoverageMap => self.run_coverage_map_test(),
             CoverageRun => self.run_coverage_run_test(),
+            Crashes => self.run_crash_test(),
         }
     }
 
@@ -295,6 +296,7 @@ impl<'test> TestCx<'test> {
         match self.config.mode {
             JsDocTest => true,
             Ui => pm.is_some() || self.props.fail_mode > Some(FailMode::Build),
+            Crashes => false,
             Incremental => {
                 let revision =
                     self.revision.expect("incremental tests require a list of revisions");
@@ -359,6 +361,27 @@ impl<'test> TestCx<'test> {
         self.check_forbid_output(&output_to_check, &proc_res);
     }
 
+    fn run_crash_test(&self) {
+        let pm = self.pass_mode();
+        let proc_res = self.compile_test(WillExecute::No, self.should_emit_metadata(pm));
+
+        if std::env::var("COMPILETEST_VERBOSE_CRASHES").is_ok() {
+            eprintln!("{}", proc_res.status);
+            eprintln!("{}", proc_res.stdout);
+            eprintln!("{}", proc_res.stderr);
+            eprintln!("{}", proc_res.cmdline);
+        }
+
+        // if a test does not crash, consider it an error
+        if proc_res.status.success() || matches!(proc_res.status.code(), Some(1 | 0)) {
+            self.fatal(&format!(
+                "test no longer crashes/triggers ICE! Please give it a mearningful name, \
+            add a doc-comment to the start of the test explaining why it exists and \
+            move it to tests/ui or wherever you see fit."
+            ));
+        }
+    }
+
     fn run_rfail_test(&self) {
         let pm = self.pass_mode();
         let should_run = self.run_if_enabled();
@@ -2517,7 +2540,7 @@ impl<'test> TestCx<'test> {
                 rustc.arg("-Cdebug-assertions=no");
             }
             RunPassValgrind | Pretty | DebugInfo | Rustdoc | RustdocJson | RunMake
-            | CodegenUnits | JsDocTest => {
+            | CodegenUnits | JsDocTest | Crashes => {
                 // do not use JSON output
             }
         }
diff --git a/src/tools/opt-dist/src/tests.rs b/src/tools/opt-dist/src/tests.rs
index 8a8f98a5eda17..46b0a54380255 100644
--- a/src/tools/opt-dist/src/tests.rs
+++ b/src/tools/opt-dist/src/tests.rs
@@ -96,6 +96,7 @@ llvm-config = "{llvm_config}"
         "tests/pretty",
         "tests/run-pass-valgrind",
         "tests/ui",
+        "tests/crashes",
     ];
     for test_path in env.skipped_tests() {
         args.extend(["--skip", test_path]);
diff --git a/src/tools/tidy/src/known_bug.rs b/src/tools/tidy/src/known_bug.rs
new file mode 100644
index 0000000000000..a62556f762bc4
--- /dev/null
+++ b/src/tools/tidy/src/known_bug.rs
@@ -0,0 +1,17 @@
+//! Tidy check to ensure that tests inside 'tests/crashes' have a '@known-bug' directive.
+
+use crate::walk::*;
+use std::path::Path;
+
+pub fn check(filepath: &Path, bad: &mut bool) {
+    walk(filepath, |path, _is_dir| filter_not_rust(path), &mut |entry, contents| {
+        let file = entry.path();
+        if !contents.lines().any(|line| line.starts_with("//@ known-bug: ")) {
+            tidy_error!(
+                bad,
+                "{} crash/ice test does not have a \"//@ known-bug: \" directive",
+                file.display()
+            );
+        }
+    });
+}
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
index 57436e8d7fee9..23f303276aa2d 100644
--- a/src/tools/tidy/src/lib.rs
+++ b/src/tools/tidy/src/lib.rs
@@ -67,6 +67,7 @@ pub mod features;
 pub mod fluent_alphabetical;
 mod fluent_used;
 pub(crate) mod iter_header;
+pub mod known_bug;
 pub mod mir_opt_tests;
 pub mod pal;
 pub mod run_make_tests;
diff --git a/src/tools/tidy/src/main.rs b/src/tools/tidy/src/main.rs
index 93be4d61a9ab3..77691815830a6 100644
--- a/src/tools/tidy/src/main.rs
+++ b/src/tools/tidy/src/main.rs
@@ -35,6 +35,7 @@ fn main() {
     let library_path = root_path.join("library");
     let compiler_path = root_path.join("compiler");
     let librustdoc_path = src_path.join("librustdoc");
+    let crashes_path = tests_path.join("crashes");
 
     let args: Vec<String> = env::args().skip(1).collect();
     let (cfg_args, pos_args) = match args.iter().position(|arg| arg == "--") {
@@ -108,6 +109,7 @@ fn main() {
         check!(mir_opt_tests, &tests_path, bless);
         check!(rustdoc_gui_tests, &tests_path);
         check!(rustdoc_css_themes, &librustdoc_path);
+        check!(known_bug, &crashes_path);
 
         // Checks that only make sense for the compiler.
         check!(error_codes, &root_path, &[&compiler_path, &librustdoc_path], verbose);
diff --git a/tests/crashes/100041.rs b/tests/crashes/100041.rs
new file mode 100644
index 0000000000000..4d113cbe9ed4f
--- /dev/null
+++ b/tests/crashes/100041.rs
@@ -0,0 +1,17 @@
+//@ known-bug: #100041
+
+pub trait WellUnformed {
+    type RequestNormalize;
+}
+
+impl<T: ?Sized> WellUnformed for T {
+    type RequestNormalize = ();
+}
+
+pub fn latent(_: &[<[[()]] as WellUnformed>::RequestNormalize; 0]) {}
+
+pub fn bang() {
+    latent(&[]);
+}
+
+fn main() {}
diff --git a/tests/crashes/101036.rs b/tests/crashes/101036.rs
new file mode 100644
index 0000000000000..72334985820f8
--- /dev/null
+++ b/tests/crashes/101036.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #101036
+#![feature(generic_const_exprs)]
+
+const fn t<const N: usize>() -> u8 {
+    N as u8
+}
+
+#[repr(u8)]
+enum T<const N: u8 = { T::<0>::A as u8 + T::<0>::B as u8 }>
+where
+    [(); N as usize]:
+{
+    A = t::<N>() as u8, B
+}
diff --git a/tests/crashes/101557.rs b/tests/crashes/101557.rs
new file mode 100644
index 0000000000000..a0290361ed1fe
--- /dev/null
+++ b/tests/crashes/101557.rs
@@ -0,0 +1,42 @@
+//@ known-bug: #101557
+//@ compile-flags: -Copt-level=0
+#![feature(generic_const_exprs)]
+use std::marker::PhantomData;
+
+trait Trait {
+    const CONST: usize;
+}
+
+struct A<T: Trait> {
+    _marker: PhantomData<T>,
+}
+
+impl<const N: usize> Trait for [i8; N] {
+    const CONST: usize = N;
+}
+
+impl<const N: usize> From<usize> for A<[i8; N]> {
+    fn from(_: usize) -> Self {
+        todo!()
+    }
+}
+
+impl<T: Trait> From<A<[i8; T::CONST]>> for A<T> {
+    fn from(_: A<[i8; T::CONST]>) -> Self {
+        todo!()
+    }
+}
+
+fn f<T: Trait>() -> A<T>
+where
+    [(); T::CONST]:,
+{
+    // Usage of `0` is arbitrary
+    let a = A::<[i8; T::CONST]>::from(0);
+    A::<T>::from(a)
+}
+
+fn main() {
+    // Usage of `1` is arbitrary
+    f::<[i8; 1]>();
+}
diff --git a/tests/crashes/101962.rs b/tests/crashes/101962.rs
new file mode 100644
index 0000000000000..b6a78ce053af0
--- /dev/null
+++ b/tests/crashes/101962.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #101962
+
+#![feature(core_intrinsics)]
+
+pub fn wrapping<T: Copy>(a: T, b: T) {
+    let _z = core::intrinsics::wrapping_mul(a, b);
+}
+
+fn main() {
+    wrapping(1,2);
+}
diff --git a/tests/crashes/102047.rs b/tests/crashes/102047.rs
new file mode 100644
index 0000000000000..61976f51273fc
--- /dev/null
+++ b/tests/crashes/102047.rs
@@ -0,0 +1,45 @@
+//@ known-bug: #102047
+
+struct Ty1;
+struct Ty2;
+
+pub trait Trait<T> {}
+
+pub trait WithAssoc1<'a> {
+    type Assoc;
+}
+pub trait WithAssoc2<'a> {
+    type Assoc;
+}
+
+impl<T, U> Trait<for<'a> fn(<T as WithAssoc1<'a>>::Assoc, <U as WithAssoc2<'a>>::Assoc)> for (T, U)
+where
+    T: for<'a> WithAssoc1<'a> + for<'a> WithAssoc2<'a, Assoc = i32>,
+    U: for<'a> WithAssoc2<'a>,
+{
+}
+
+impl WithAssoc1<'_> for Ty1 {
+    type Assoc = ();
+}
+impl WithAssoc2<'_> for Ty1 {
+    type Assoc = i32;
+}
+impl WithAssoc1<'_> for Ty2 {
+    type Assoc = ();
+}
+impl WithAssoc2<'_> for Ty2 {
+    type Assoc = u32;
+}
+
+fn foo<T, U, V>()
+where
+    T: for<'a> WithAssoc1<'a>,
+    U: for<'a> WithAssoc2<'a>,
+    (T, U): Trait<V>,
+{
+}
+
+fn main() {
+    foo::<Ty1, Ty2, _>();
+}
diff --git a/tests/crashes/102252.rs b/tests/crashes/102252.rs
new file mode 100644
index 0000000000000..200782f95c861
--- /dev/null
+++ b/tests/crashes/102252.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #102252
+
+#![feature(min_specialization, rustc_attrs)]
+
+#[rustc_specialization_trait]
+pub trait Trait {}
+
+struct Struct
+where
+    Self: Iterator<Item = <Self as Iterator>::Item>, {}
+
+impl Trait for Struct {}
+
+fn main() {}
diff --git a/tests/crashes/103899.rs b/tests/crashes/103899.rs
new file mode 100644
index 0000000000000..39c2d72bd357c
--- /dev/null
+++ b/tests/crashes/103899.rs
@@ -0,0 +1,27 @@
+//@ known-bug: #103899
+
+trait BaseWithAssoc {
+    type Assoc;
+}
+
+trait WrapperWithAssoc {
+    type BaseAssoc: BaseWithAssoc;
+}
+
+struct Wrapper<B> {
+    inner: B,
+}
+
+struct ProjectToBase<T: BaseWithAssoc> {
+    data_type_h: T::Assoc,
+}
+
+struct DoubleProject<L: WrapperWithAssoc> {
+    buffer: Wrapper<ProjectToBase<L::BaseAssoc>>,
+}
+
+fn trigger<L: WrapperWithAssoc<BaseAssoc = ()>>() -> DoubleProject<L> {
+    loop {}
+}
+
+fn main() {}
diff --git a/tests/crashes/105238-1.rs b/tests/crashes/105238-1.rs
new file mode 100644
index 0000000000000..dd44a0f1d775c
--- /dev/null
+++ b/tests/crashes/105238-1.rs
@@ -0,0 +1,31 @@
+//@ known-bug: #105238
+
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs)]
+
+trait Ret {
+    type R;
+}
+
+struct Cond<const PRED: bool, U, V>(std::marker::PhantomData<U>, std::marker::PhantomData<V>);
+
+impl<U, V> Ret for Cond<true, U, V> {
+    type R = U;
+}
+
+impl<U, V> Ret for Cond<false, U, V> {
+    type R = V;
+}
+
+struct RobinHashTable<const MAX_LENGTH: usize, CellIdx = Cond<{ MAX_LENGTH < 65535 }, u16, u32>>
+where
+    CellIdx: Ret,
+{
+    _idx: CellIdx::R,
+}
+
+fn main() {
+    use std::mem::size_of;
+    println!("{}", size_of::<RobinHashTable<1024>>());
+    println!("{}", size_of::<RobinHashTable<65536>>());
+}
diff --git a/tests/crashes/105238-2.rs b/tests/crashes/105238-2.rs
new file mode 100644
index 0000000000000..368595c6a2acb
--- /dev/null
+++ b/tests/crashes/105238-2.rs
@@ -0,0 +1,31 @@
+//@ known-bug: #105238
+
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs)]
+
+trait Ret {
+    type R;
+}
+
+struct Cond<const PRED: bool, U, V>(std::marker::PhantomData<U>, std::marker::PhantomData<V>);
+
+impl<U, V> Ret for Cond<true, U, V> {
+    type R = U;
+}
+
+impl<U, V> Ret for Cond<false, U, V> {
+    type R = V;
+}
+
+struct RobinHashTable<
+    const MAX_LENGTH: usize,
+    CellIdx = <Cond<{ MAX_LENGTH < 65535 }, u16, u32> as Ret>::R,
+> {
+    _idx: CellIdx,
+}
+
+fn main() {
+    use std::mem::size_of;
+    println!("{}", size_of::<RobinHashTable<1024>>());
+    println!("{}", size_of::<RobinHashTable<65536>>());
+}
diff --git a/tests/crashes/105275.rs b/tests/crashes/105275.rs
new file mode 100644
index 0000000000000..a97f36d19872c
--- /dev/null
+++ b/tests/crashes/105275.rs
@@ -0,0 +1,27 @@
+//@ known-bug: #105275
+//@ compile-flags: -Copt-level=0
+
+pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
+    if n > 15 {
+        encode_num(n / 16, &mut writer)?;
+    }
+    Ok(())
+}
+
+pub trait ExampleWriter {
+    type Error;
+}
+
+impl<'a, T: ExampleWriter> ExampleWriter for &'a mut T {
+    type Error = T::Error;
+}
+
+struct Error;
+
+impl ExampleWriter for Error {
+    type Error = ();
+}
+
+fn main() {
+    encode_num(69, &mut Error).unwrap();
+}
diff --git a/tests/crashes/105937.rs b/tests/crashes/105937.rs
new file mode 100644
index 0000000000000..ffd1a493e46d5
--- /dev/null
+++ b/tests/crashes/105937.rs
@@ -0,0 +1,27 @@
+//@ known-bug: #105937
+//@ compile-flags: -Copt-level=0
+
+pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
+    if n > 15 {
+        encode_num(n / 16, &mut writer)?;
+    }
+    Ok(())
+}
+
+pub trait ExampleWriter {
+    type Error;
+}
+
+impl<'a, T: ExampleWriter> ExampleWriter for &'a mut T {
+    type Error = T::Error;
+}
+
+struct Error;
+
+impl ExampleWriter for Error {
+    type Error = ();
+}
+
+fn main() {
+    encode_num(69, &mut Error).unwrap();
+}
diff --git a/tests/crashes/106473.rs b/tests/crashes/106473.rs
new file mode 100644
index 0000000000000..b0a129cac010a
--- /dev/null
+++ b/tests/crashes/106473.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #106473
+#![feature(generic_const_exprs)]
+
+const DEFAULT: u32 = 1;
+
+struct V<const U: usize = DEFAULT>
+where
+    [(); U]:;
+
+trait Tr {}
+
+impl Tr for V {}
diff --git a/tests/crashes/108814.rs b/tests/crashes/108814.rs
new file mode 100644
index 0000000000000..c8db848f2e188
--- /dev/null
+++ b/tests/crashes/108814.rs
@@ -0,0 +1,9 @@
+//@ known-bug: #108814
+
+#![feature(non_lifetime_binders)]
+
+fn take(_: impl for<T> FnOnce(T) -> T) {}
+
+fn main() {
+    take(|x| x)
+}
diff --git a/tests/crashes/109681.rs b/tests/crashes/109681.rs
new file mode 100644
index 0000000000000..73ff10070943f
--- /dev/null
+++ b/tests/crashes/109681.rs
@@ -0,0 +1,9 @@
+//@ known-bug: #109681
+
+#![crate_type="lib"]
+#![feature(linkage)]
+
+#[linkage = "common"]
+pub static TEST3: bool = true;
+
+fn main() {}
diff --git a/tests/crashes/110378.rs b/tests/crashes/110378.rs
new file mode 100644
index 0000000000000..93de62d413909
--- /dev/null
+++ b/tests/crashes/110378.rs
@@ -0,0 +1,15 @@
+//@ known-bug: #110378
+// ignore-tidy-linelength
+
+#![feature(generic_const_exprs)]
+
+fn foo<const L: usize>(_a: [u8; L], _b: [u8; L]) -> [u8; L + 1] {
+    [0_u8; L + 1]
+}
+
+fn main() {
+    let baz = [[0_u8; 1]; 8];
+
+    let _: [u8; 4] = foo(foo(foo(baz[0], baz[1]), foo(baz[2], baz[3])), foo(foo(baz[4], baz[5]), foo(baz[6], baz[7])));
+    //let _: [u8; 3] = foo(foo(baz[0], baz[1]), foo(baz[2], baz[3]));
+}
diff --git a/tests/crashes/110534.rs b/tests/crashes/110534.rs
new file mode 100644
index 0000000000000..240ff6c270413
--- /dev/null
+++ b/tests/crashes/110534.rs
@@ -0,0 +1,44 @@
+//@ known-bug: #110534
+//@ edition:2021
+use core::cell::Ref;
+
+struct System;
+
+trait IntoSystem {
+    fn into_system(self) -> System;
+}
+
+impl IntoSystem for fn(Ref<'_, u32>) {
+    fn into_system(self) -> System { System }
+}
+
+impl<A> IntoSystem for fn(A)
+where
+    // n.b. No `Ref<'_, u32>` can satisfy this bound
+    A: 'static + for<'x> MaybeBorrowed<'x, Output = A>,
+{
+    fn into_system(self) -> System { System }
+}
+
+//---------------------------------------------------
+
+trait MaybeBorrowed<'a> {
+    type Output: 'a;
+}
+
+// If you comment this out you'll see the compiler chose to look at the
+// fn(A) implementation of IntoSystem above
+impl<'a, 'b> MaybeBorrowed<'a> for Ref<'b, u32> {
+    type Output = Ref<'a, u32>;
+}
+
+// ---------------------------------------------
+
+fn main() {
+    fn sys_ref(_age: Ref<u32>) {}
+    let _sys_c = (sys_ref as fn(_)).into_system();
+    // properly fails
+    // let _sys_c = (sys_ref as fn(Ref<'static, u32>)).into_system();
+    // properly succeeds
+    // let _sys_c = (sys_ref as fn(Ref<'_, u32>)).into_system();
+}
diff --git a/tests/crashes/110627.rs b/tests/crashes/110627.rs
new file mode 100644
index 0000000000000..752682fa6059e
--- /dev/null
+++ b/tests/crashes/110627.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #110627
+#![feature(non_lifetime_binders)]
+
+fn take(id: impl for<T> Fn(T) -> T) {}
+
+fn main() {
+    take(|x| x)
+}
diff --git a/tests/crashes/110630.rs b/tests/crashes/110630.rs
new file mode 100644
index 0000000000000..f17f6f0781f39
--- /dev/null
+++ b/tests/crashes/110630.rs
@@ -0,0 +1,28 @@
+//@ known-bug: #110630
+
+#![feature(generic_const_exprs)]
+
+use std::ops::Mul;
+
+pub trait Indices<const N: usize> {
+    const NUM_ELEMS: usize = I::NUM_ELEMS * N;
+}
+
+pub trait Concat<J> {
+    type Output;
+}
+
+pub struct Tensor<I: Indices<N>, const N: usize>
+where
+    [u8; I::NUM_ELEMS]: Sized, {}
+
+impl<I: Indices<N>, J: Indices<N>, const N: usize> Mul<Tensor<J, N>> for Tensor<I, N>
+where
+    I: Concat<T>,
+    <I as Concat<J>>::Output: Indices<N>,
+    [u8; I::NUM_ELEMS]: Sized,
+    [u8; J::NUM_ELEMS]: Sized,
+    [u8; <I as Concat<J>>::Output::NUM_ELEMS]: Sized,
+{
+    type Output = Tensor<<I as Concat<J>>::Output, N>;
+}
diff --git a/tests/crashes/111419.rs b/tests/crashes/111419.rs
new file mode 100644
index 0000000000000..3a1a13df1985a
--- /dev/null
+++ b/tests/crashes/111419.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #111419
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs, generic_arg_infer)]
+
+pub trait Example<const X: usize, const Y: usize, const Z: usize = { X + Y }>
+where
+    [(); X + Y]:,
+{}
+
+impl<const X: usize, const Y: usize> Example<X, Y> for Value {}
+
+pub struct Value;
+
+fn main() {}
diff --git a/tests/crashes/111699.rs b/tests/crashes/111699.rs
new file mode 100644
index 0000000000000..5ba17c2aa1afc
--- /dev/null
+++ b/tests/crashes/111699.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #111699
+//@ edition:2021
+//@ compile-flags: -Copt-level=0
+#![feature(core_intrinsics)]
+use std::intrinsics::offset;
+
+fn main() {
+    let a = [1u8, 2, 3];
+    let ptr: *const u8 = a.as_ptr();
+
+    unsafe {
+        assert_eq!(*offset(ptr, 0), 1);
+    }
+}
diff --git a/tests/crashes/111709-2.rs b/tests/crashes/111709-2.rs
new file mode 100644
index 0000000000000..6c4fb9f28c7de
--- /dev/null
+++ b/tests/crashes/111709-2.rs
@@ -0,0 +1,15 @@
+//@ known-bug: #111709
+//@ edition: 2021
+
+use core::arch::asm;
+
+extern "C" fn test<T>() {}
+
+fn uwu() {
+    unsafe {
+        asm!(
+            "/* {0} */",
+            sym test::<&mut ()>
+        );
+    }
+}
diff --git a/tests/crashes/111709.rs b/tests/crashes/111709.rs
new file mode 100644
index 0000000000000..eef375b8924b7
--- /dev/null
+++ b/tests/crashes/111709.rs
@@ -0,0 +1,25 @@
+//@ known-bug: #111709
+//@ edition:2021
+
+use core::arch::asm;
+
+struct TrapFrame;
+
+unsafe extern "C" fn _rust_abi_shim1<A, R>(arg: A, f: fn(A) -> R) -> R {
+    f(arg)
+}
+
+unsafe extern "C" fn _start_trap() {
+    extern "Rust" {
+        fn interrupt(tf: &mut TrapFrame);
+    }
+    asm!(
+        "
+        la   a1, {irq}
+        call {shim}
+        ",
+        shim = sym crate::_rust_abi_shim1::<&mut TrapFrame, ()>,
+        irq = sym interrupt,
+        options(noreturn)
+    )
+}
diff --git a/tests/crashes/111742.rs b/tests/crashes/111742.rs
new file mode 100644
index 0000000000000..fda2a96836f68
--- /dev/null
+++ b/tests/crashes/111742.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #111742
+// ignore-tidy-linelength
+
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs)]
+
+const CONST: u32 = 0;
+struct Test<const N: u32, const M: u32 = { CONST/* Must be a const and not a Literal */ }> where [(); N as usize]: , ([u32; N as usize]);
+
+fn main() {
+    let _: Test<1>;
+}
diff --git a/tests/crashes/111883.rs b/tests/crashes/111883.rs
new file mode 100644
index 0000000000000..fa72b28c22870
--- /dev/null
+++ b/tests/crashes/111883.rs
@@ -0,0 +1,40 @@
+//@ known-bug: #111883
+#![crate_type = "lib"]
+#![feature(arbitrary_self_types, no_core, lang_items)]
+#![no_core]
+
+#[lang = "sized"]
+trait Sized {}
+#[lang = "copy"]
+trait Copy {}
+#[lang = "receiver"]
+trait Receiver {}
+#[lang = "dispatch_from_dyn"]
+trait DispatchFromDyn<T> {}
+impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<&'a U> for &'a T {}
+#[lang = "unsize"]
+trait Unsize<T: ?Sized> {}
+#[lang = "coerce_unsized"]
+pub trait CoerceUnsized<T: ?Sized> {}
+impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
+
+#[lang = "drop_in_place"]
+fn drop_in_place_fn<T>(a: &dyn Trait2<T>) {}
+
+pub trait Trait1 {
+    fn foo(&self);
+}
+
+pub struct Type1;
+
+impl Trait1 for Type1 {
+    fn foo(&self) {}
+}
+
+pub trait Trait2<T> {}
+
+pub fn bar1() {
+    let a = Type1;
+    let b = &a as &dyn Trait1;
+    b.foo();
+}
diff --git a/tests/crashes/112201.rs b/tests/crashes/112201.rs
new file mode 100644
index 0000000000000..5d363403b8acb
--- /dev/null
+++ b/tests/crashes/112201.rs
@@ -0,0 +1,19 @@
+//@ known-bug: #112201
+
+pub fn compose(
+    f1: impl FnOnce(f64) -> f64 + Clone,
+    f2: impl FnOnce(f64) -> f64 + Clone,
+) -> impl FnOnce(f64) -> f64 + Clone {
+    move |x| f1(f2(x))
+}
+
+fn repeat_helper(
+    f: impl FnOnce(f64) -> f64 + Clone,
+    res: impl FnOnce(f64) -> f64 + Clone,
+    times: usize,
+) -> impl FnOnce(f64) -> f64 + Clone {
+    return res;
+    repeat_helper(f.clone(), compose(f, res), times - 1)
+}
+
+fn main() {}
diff --git a/tests/crashes/113272.rs b/tests/crashes/113272.rs
new file mode 100644
index 0000000000000..d161575c657ec
--- /dev/null
+++ b/tests/crashes/113272.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #113272
+trait Trait {
+    type RefTarget;
+}
+
+impl Trait for () where Missing: Trait {}
+
+struct Other {
+    data: <() as Trait>::RefTarget,
+}
+
+fn main() {
+    unsafe {
+        std::mem::transmute::<Option<()>, Option<&Other>>(None);
+    }
+}
diff --git a/tests/crashes/113280.rs b/tests/crashes/113280.rs
new file mode 100644
index 0000000000000..86677f416fe20
--- /dev/null
+++ b/tests/crashes/113280.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #113280
+//@ only-x86_64
+
+#![feature(dyn_star, pointer_like_trait)]
+#![allow(incomplete_features)]
+
+use std::fmt::Debug;
+use std::marker::PointerLike;
+
+fn make_dyn_star<'a>(t: impl PointerLike + Debug + 'a) -> dyn* Debug + 'a {
+    f32::from_bits(0x1) as f64
+}
+
+fn main() {
+    println!("{:?}", make_dyn_star(Box::new(1i32)));
+}
diff --git a/tests/crashes/113379.rs b/tests/crashes/113379.rs
new file mode 100644
index 0000000000000..7163cbc39342d
--- /dev/null
+++ b/tests/crashes/113379.rs
@@ -0,0 +1,7 @@
+//@ known-bug: #113379
+
+async fn f999() -> Vec<usize> {
+    'b: {
+        continue 'b;
+    }
+}
diff --git a/tests/crashes/113846.rs b/tests/crashes/113846.rs
new file mode 100644
index 0000000000000..0e5afb4da61b8
--- /dev/null
+++ b/tests/crashes/113846.rs
@@ -0,0 +1,32 @@
+//@ known-bug: #113846
+trait Www {
+    type W;
+}
+
+trait Xxx: Www<W = Self::X> {
+    type X;
+}
+
+trait Yyy: Xxx {}
+
+trait Zzz<'a>: Yyy + Xxx<X = Self::Z> {
+    type Z;
+}
+
+trait Aaa {
+    type Y: Yyy;
+}
+
+trait Bbb: Aaa<Y = Self::B> {
+    type B: for<'a> Zzz<'a>;
+}
+
+impl<T> Bbb for T
+where
+    T: Aaa,
+    T::Y: for<'a> Zzz<'a>,
+{
+    type B = T::Y;
+}
+
+pub fn main() {}
diff --git a/tests/crashes/114212-2.rs b/tests/crashes/114212-2.rs
new file mode 100644
index 0000000000000..a430c1b40d37a
--- /dev/null
+++ b/tests/crashes/114212-2.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #114212
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs)]
+
+const SOME_CONST: usize = 1;
+
+struct UwU<
+    // have a const generic with a default that's from another const item
+    // (associated consts work, a const declared in a block here, inline_const, etc)
+    const N: usize = SOME_CONST,
+    // use the previous const in a type generic
+    A = [(); N],
+> {
+    // here to suppress "unused generic" error if the code stops ICEing
+    _x: core::marker::PhantomData<A>,
+}
diff --git a/tests/crashes/114212.rs b/tests/crashes/114212.rs
new file mode 100644
index 0000000000000..8642dbe8e71f2
--- /dev/null
+++ b/tests/crashes/114212.rs
@@ -0,0 +1,34 @@
+//@ known-bug: #114212
+
+#![feature(generic_const_exprs)]
+
+use core::marker::PhantomData;
+
+pub const DEFAULT_MAX_INPUT_LEN: usize = 256;
+
+pub trait FooTrait {}
+
+pub struct Foo<const MAX_INPUT_LEN: usize>;
+
+impl<const MAX_INPUT_LEN: usize> FooTrait for Foo<MAX_INPUT_LEN> {}
+
+pub struct Bar<
+    const MAX_INPUT_LEN: usize = DEFAULT_MAX_INPUT_LEN,
+    PB = Foo<MAX_INPUT_LEN>,
+>
+where
+    PB: FooTrait,
+{
+    _pb: PhantomData<PB>,
+}
+
+impl<const MAX_INPUT_LEN: usize, PB> Bar<MAX_INPUT_LEN, PB>
+where
+    PB: FooTrait,
+{
+    pub fn new() -> Self {
+        Self {
+            _pb: PhantomData,
+        }
+    }
+}
diff --git a/tests/crashes/114317.rs b/tests/crashes/114317.rs
new file mode 100644
index 0000000000000..09fd2beeba8a5
--- /dev/null
+++ b/tests/crashes/114317.rs
@@ -0,0 +1,6 @@
+//@ known-bug: #114317
+#![feature(generic_const_exprs)]
+
+struct A<const B: str = 1, C>;
+
+fn main() {}
diff --git a/tests/crashes/114456-2.rs b/tests/crashes/114456-2.rs
new file mode 100644
index 0000000000000..eca27febb968a
--- /dev/null
+++ b/tests/crashes/114456-2.rs
@@ -0,0 +1,20 @@
+//@ known-bug: #114456
+#![feature(adt_const_params)]
+
+const EMPTY_MATRIX: <Type as Trait>::Matrix = [0; 1];
+
+pub struct Walk<const REMAINING: <Type as Trait>::Matrix> {}
+
+impl Walk<EMPTY_MATRIX> {
+    pub const fn new() -> Self {
+        Self {}
+    }
+}
+
+pub enum Type {}
+pub trait Trait { type Matrix; }
+impl Trait for Type { type Matrix = [usize; 1]; }
+
+fn main() {
+    let _ = Walk::new();
+}
diff --git a/tests/crashes/114456.rs b/tests/crashes/114456.rs
new file mode 100644
index 0000000000000..e347327e73863
--- /dev/null
+++ b/tests/crashes/114456.rs
@@ -0,0 +1,17 @@
+//@ known-bug: #114456
+#![feature(adt_const_params, lazy_type_alias)]
+
+pub type Matrix = [usize; 1];
+const EMPTY_MATRIX: Matrix = [0; 1];
+
+pub struct Walk<const REMAINING: Matrix> {}
+
+impl Walk<EMPTY_MATRIX> {
+    pub const fn new() -> Self {
+        Self {}
+    }
+}
+
+fn main() {
+    let _ = Walk::new();
+}
diff --git a/tests/crashes/114484.rs b/tests/crashes/114484.rs
new file mode 100644
index 0000000000000..9d90c153624cc
--- /dev/null
+++ b/tests/crashes/114484.rs
@@ -0,0 +1,67 @@
+//@ known-bug: #114484
+use std::marker::PhantomData;
+
+trait MyTrait {
+    fn virtualize(&self) -> &dyn MyTrait;
+}
+
+struct VirtualWrapper<T, const L: u8>(T);
+
+impl<T, const L: u8> VirtualWrapper<T, L> {
+    pub fn wrap(value: &T) -> &Self {
+        unsafe { &*(value as *const T as *const Self) }
+    }
+}
+
+impl<T: MyTrait + 'static, const L: u8> MyTrait for VirtualWrapper<T, L> {
+    fn virtualize(&self) -> &dyn MyTrait {
+        unsafe { virtualize_my_trait(L, self) }
+        // unsafe { virtualize_my_trait(L, &self.0) }    // <-- this code fixes the problem
+    }
+}
+
+const unsafe fn virtualize_my_trait<T>(level: u8, obj: &T) -> &dyn MyTrait
+where
+    T: MyTrait + 'static,
+{
+    const fn gen_vtable_ptr<T, const L: u8>() -> *const ()
+    where
+        T: MyTrait + 'static,
+    {
+        let [_, vtable] = unsafe {
+            std::mem::transmute::<*const dyn MyTrait, [*const (); 2]>(std::ptr::null::<
+                VirtualWrapper<T, L>,
+            >())
+        };
+        vtable
+    }
+
+    struct Vtable<T>(PhantomData<T>);
+
+    impl<T> Vtable<T>
+    where
+        T: MyTrait + 'static,
+    {
+        const LEVELS: [*const (); 2] = [gen_vtable_ptr::<T, 1>(), gen_vtable_ptr::<T, 2>()];
+    }
+
+    let vtable = Vtable::<T>::LEVELS[(level != 0) as usize];
+
+    let data = obj as *const T as *const ();
+    let ptr: *const dyn MyTrait = std::mem::transmute([data, vtable]);
+
+    &*ptr
+}
+
+struct SomeData<const N: usize>([u8; N]);
+
+impl<const N: usize> MyTrait for SomeData<N> {
+    fn virtualize(&self) -> &dyn MyTrait {
+        VirtualWrapper::<Self, 0>::wrap(self)
+    }
+}
+
+fn main() {
+    let test = SomeData([0; 256]);
+    test.virtualize();
+}
diff --git a/tests/crashes/114663.rs b/tests/crashes/114663.rs
new file mode 100644
index 0000000000000..406371f12e460
--- /dev/null
+++ b/tests/crashes/114663.rs
@@ -0,0 +1,17 @@
+//@ known-bug: #114663
+//@ edition:2021
+
+#![feature(generic_const_exprs)]
+
+use core::fmt::Debug;
+
+struct Inline<T>
+where
+    [u8; ::core::mem::size_of::<T>() + 1]:,
+{
+    _phantom: PhantomData<T>,
+}
+
+fn main() {
+    let dst = Inline::<dyn Debug>::new(0); // BANG!
+}
diff --git a/tests/crashes/115435.rs b/tests/crashes/115435.rs
new file mode 100644
index 0000000000000..c6e749867e881
--- /dev/null
+++ b/tests/crashes/115435.rs
@@ -0,0 +1,25 @@
+//@ known-bug: #115435
+//@ edition:2021
+//@ compile-flags: -Copt-level=0
+trait MyTrait {
+    type Target: ?Sized;
+}
+
+impl<A: ?Sized> MyTrait for A {
+    type Target = A;
+}
+
+fn main() {
+    bug_run::<dyn MyTrait<Target = u8>>();
+}
+
+fn bug_run<T: ?Sized>()
+where
+    <T as MyTrait>::Target: Sized,
+{
+    bug::<T>();
+}
+
+fn bug<T>() {
+    std::mem::size_of::<T>();
+}
diff --git a/tests/crashes/115808.rs b/tests/crashes/115808.rs
new file mode 100644
index 0000000000000..79196ac9c6544
--- /dev/null
+++ b/tests/crashes/115808.rs
@@ -0,0 +1,27 @@
+//@ known-bug: #115808
+#![feature(generic_const_exprs)]
+
+use std::ops::Mul;
+
+pub trait Indices<const N: usize> {
+    const NUM_ELEMS: usize;
+}
+
+pub trait Concat<J> {
+    type Output;
+}
+
+pub struct Tensor<I: Indices<N>, const N: usize>
+where
+    [u8; I::NUM_ELEMS]: Sized, {}
+
+impl<I: Indices<N>, J: Indices<N>, const N: usize> Mul<Tensor<J, N>> for Tensor<I, N>
+where
+    I: Concat<FN>,
+    <I as Concat<J>>::Output: Indices<N>,
+    [u8; I::NUM_ELEMS]: Sized,
+    [u8; J::NUM_ELEMS]: Sized,
+    [u8; <I as Concat<J>>::Output::NUM_ELEMS]: Sized,
+{
+    type Output = Tensor<<I as Concat<J>>::Output, N>;
+}
diff --git a/tests/crashes/116308.rs b/tests/crashes/116308.rs
new file mode 100644
index 0000000000000..cb96c80d79bdc
--- /dev/null
+++ b/tests/crashes/116308.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #116308
+#![feature(adt_const_params)]
+
+pub trait Identity {
+    type Identity;
+}
+
+impl<T> Identity for T {
+    type Identity = Self;
+}
+
+pub fn foo<const X: <i32 as Identity>::Identity>() {}
+
+fn main() {
+    foo::<12>();
+}
diff --git a/tests/crashes/116519-2.rs b/tests/crashes/116519-2.rs
new file mode 100644
index 0000000000000..e1abbbcd4c145
--- /dev/null
+++ b/tests/crashes/116519-2.rs
@@ -0,0 +1,15 @@
+//@ known-bug: #116519
+#![feature(generic_const_exprs)]
+
+trait Ret {
+    type R;
+}
+
+struct Cond<const PRED: bool, U, V>(std::marker::PhantomData<U>, );
+
+struct RobinHashTable<
+    const MAX_LENGTH: usize,
+    CellIdx = <Cond<{  }, u16, u32> as Ret>::R,
+> {}
+
+impl<CellIdx> HashMapBase<CellIdx> for RobinHashTable<MAX_LENGTH, CellIdx> {}
diff --git a/tests/crashes/116519.rs b/tests/crashes/116519.rs
new file mode 100644
index 0000000000000..0824a72be1977
--- /dev/null
+++ b/tests/crashes/116519.rs
@@ -0,0 +1,57 @@
+//@ known-bug: #116519
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs)]
+trait Ret {
+    type R;
+}
+struct Cond<const PRED: bool, U, V>(std::marker::PhantomData<U>, std::marker::PhantomData<V>);
+impl<U, V> Ret for Cond<true, U, V> {
+    type R = U;
+}
+impl<U, V> Ret for Cond<false, U, V> {
+    type R = V;
+}
+struct RobinHashTable<
+    const MAX_LENGTH: usize,
+    CellIdx = <Cond<{ MAX_LENGTH < 65535 }, u16, u32> as Ret>::R,
+> {
+    _idx: CellIdx,
+}
+impl<CellIdx> RobinHashTable<MAX_LENGTH, CellIdx> {
+    fn new() -> Self {
+        Self {
+            _idx: CellIdx { MAX_LENGTH },
+        }
+    }
+}
+impl<CellIdx> HashMapBase<CellIdx> {
+    fn new() -> Self {
+        Self {
+            _idx: CellIdx { 0 },
+        }
+    }
+}
+impl<CellIdx> HashMapBase<CellIdx> for RobinHashTable<MAX_LENGTH, CellIdx> {
+    fn hash<H: Hash + Hasher>(&self,
+
+    ) -> H {
+        self._idx.hash()
+    }
+    fn eq(&self, other: &Self) -> bool {
+        self._idx.eq(other._idx)
+    }
+}
+impl<CellIdx> HashMapBase<CellIdx> for RobinHashTable<MAX_LENGTH, CellIdx> {
+    fn hash<H: Hash + Hasher>(&self, other: &Self) -> H {
+        self._idx.hash(other._idx)
+    }
+    fn eq(&self, other: &Self) -> bool {
+        self._idx.eq(other._idx)
+    }
+}
+#[test]
+fn test_size_of_robin_hash_table() {
+    use std::mem::size_of;
+    println!("{}", size_of::<RobinHashTable<1024>>());
+    println!("{}", size_of::<RobinHashTable<65536>>());
+}
diff --git a/tests/crashes/116554.rs b/tests/crashes/116554.rs
new file mode 100644
index 0000000000000..b87a478e6f20c
--- /dev/null
+++ b/tests/crashes/116554.rs
@@ -0,0 +1,31 @@
+//@ known-bug: #116554
+#![feature(generic_const_exprs)]
+
+const fn t<const N: usize>() -> u8 {
+
+    N as u8
+
+}
+
+#[repr(u8)]
+
+enum T<const N: u8 = { T::<0>::A as u8 + T::<0>::B as u8 }>
+
+where
+
+    [(); N as usize]:,
+
+    T: ?Sized,
+
+{
+
+    A,
+
+}
+
+fn main() {
+    A = t::<N>() as u8,
+
+    B,
+
+}
diff --git a/tests/crashes/116947.rs b/tests/crashes/116947.rs
new file mode 100644
index 0000000000000..34f0522369e28
--- /dev/null
+++ b/tests/crashes/116947.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #116947
+#![feature(min_specialization)]
+
+trait MySpecTrait {
+    fn f();
+}
+
+impl<'a, T: ?Sized> MySpecTrait for T {
+    default fn f() {}
+}
+
+impl<'a, T: ?Sized> MySpecTrait for &'a T {
+    fn f() {}
+}
+
+fn main() {}
diff --git a/tests/crashes/117392-2.rs b/tests/crashes/117392-2.rs
new file mode 100644
index 0000000000000..632ce8b9deece
--- /dev/null
+++ b/tests/crashes/117392-2.rs
@@ -0,0 +1,27 @@
+//@ known-bug: #117392
+pub trait BorrowComposite {
+    type Ref<'a>: 'a;
+}
+
+impl BorrowComposite for () {
+    type Ref<'a> = ();
+}
+
+pub trait Component<Args> {
+    type Output;
+}
+
+impl<Args> Component<Args> for () {
+    type Output = ();
+}
+
+pub fn delay<Args: BorrowComposite, Make: for<'a> FnMut(Args::Ref<'a>) -> C, C: Component<Args>>(
+    make: Make,
+) -> impl Component<Args> {
+}
+
+pub fn crash() -> impl Component<()> {
+    delay(|()| delay(|()| ()))
+}
+
+pub fn main() {}
diff --git a/tests/crashes/117392.rs b/tests/crashes/117392.rs
new file mode 100644
index 0000000000000..95fdf63f893ec
--- /dev/null
+++ b/tests/crashes/117392.rs
@@ -0,0 +1,47 @@
+//@ known-bug: #117392
+pub trait BorrowComposite {
+    type Ref<'a>
+    where
+        Self: 'a;
+}
+
+impl BorrowComposite for () {
+    type Ref<'a> = ();
+}
+
+pub trait Component<Args: BorrowComposite> {
+    type Output;
+}
+
+impl<Args: BorrowComposite> Component<Args> for () {
+    type Output = ();
+}
+
+struct Delay<Make> {
+    _make: Make,
+}
+
+impl<
+        Args: BorrowComposite,
+        Make: for<'a> FnMut(Args::Ref<'a>) -> C,
+        C: Component<Args>,
+    > Component<Args> for Delay<Make>
+{
+    type Output = C::Output;
+}
+
+pub fn delay<
+    Args: BorrowComposite,
+    Make: for<'a> FnMut(Args::Ref<'a>) -> C,
+    C: Component<Args>,
+>(
+    make: Make,
+) -> impl Component<Args, Output = C::Output> {
+    Delay { _make: make }
+}
+
+pub fn crash() -> impl Component<(), Output = ()> {
+    delay(|()| delay(|()| ()))
+}
+
+pub fn main() {}
diff --git a/tests/crashes/117496.rs b/tests/crashes/117496.rs
new file mode 100644
index 0000000000000..1e85646cf8313
--- /dev/null
+++ b/tests/crashes/117496.rs
@@ -0,0 +1,22 @@
+//@ known-bug: #117496
+#![feature(adt_const_params)]
+#![feature(generic_const_exprs)]
+
+use core::marker::ConstParamTy;
+
+#[derive(PartialEq, Copy, Clone, Eq, ConstParamTy)]
+pub enum Foo {}
+impl Foo {
+    pub const fn size(self) -> usize {
+        1
+    }
+}
+
+pub struct Bar<const F: Foo, const SIZE: usize = { F.size() }>([u64; SIZE])
+where
+    [u64; SIZE]: Sized;
+
+pub struct Quux<const F: Foo> {}
+impl<const F: Foo> Quux<{ F }> {
+    pub unsafe fn nothing(&self, bar: &mut Bar<{ F }>) {}
+}
diff --git a/tests/crashes/117629.rs b/tests/crashes/117629.rs
new file mode 100644
index 0000000000000..d8b5f328545da
--- /dev/null
+++ b/tests/crashes/117629.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #117629
+//@ edition:2021
+
+#![feature(const_trait_impl)]
+
+#[const_trait]
+trait Tr {
+    async fn ft1() {}
+}
+
+fn main() {}
diff --git a/tests/crashes/117696-1.rs b/tests/crashes/117696-1.rs
new file mode 100644
index 0000000000000..dfca39177855d
--- /dev/null
+++ b/tests/crashes/117696-1.rs
@@ -0,0 +1,29 @@
+//@ known-bug: #117696
+fn main() {
+    let mut it = (Empty);
+    rec(&mut it);
+}
+
+struct Empty;
+
+impl Iterator for Empty {
+    type Item = ();
+    fn next<'a>(&'a mut self) -> core::option::Option<()> {
+        None
+    }
+}
+
+fn identity<T>(x: T) -> T {
+    x
+}
+
+fn rec<T>(mut it: T)
+where
+    T: Iterator,
+{
+    if () == () {
+        T::count(it);
+    } else {
+        rec(identity(&mut it))
+    }
+}
diff --git a/tests/crashes/117696-2.rs b/tests/crashes/117696-2.rs
new file mode 100644
index 0000000000000..9c2a68d3a915c
--- /dev/null
+++ b/tests/crashes/117696-2.rs
@@ -0,0 +1,13 @@
+//@ known-bug: #117696
+//@ compile-flags: -Copt-level=0
+fn main() {
+    rec(&mut None::<()>.into_iter());
+}
+
+fn rec<T: Iterator>(mut it: T) {
+    if true {
+        it.next();
+    } else {
+        rec(&mut it);
+    }
+}
diff --git a/tests/crashes/117795.rs b/tests/crashes/117795.rs
new file mode 100644
index 0000000000000..3f0dd2f9bf4f9
--- /dev/null
+++ b/tests/crashes/117795.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #117795
+const fn f() -> usize {
+    5
+}
+
+fn main() {
+    let _ = [0; FnMut::call_mut(&mut f, ())];
+}
diff --git a/tests/crashes/117829-2.rs b/tests/crashes/117829-2.rs
new file mode 100644
index 0000000000000..ecfd3148569df
--- /dev/null
+++ b/tests/crashes/117829-2.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #117829
+#![feature(auto_traits)]
+
+trait B {}
+
+auto trait Z<T>
+where
+    T: Z<u16>,
+    <T as Z<u16>>::W: B,
+{
+    type W;
+}
+
+fn main() {}
diff --git a/tests/crashes/117829.rs b/tests/crashes/117829.rs
new file mode 100644
index 0000000000000..7544b5ec0fceb
--- /dev/null
+++ b/tests/crashes/117829.rs
@@ -0,0 +1,9 @@
+//@ known-bug: #117829
+auto trait Z<'a, T: ?Sized>
+where
+    T: Z<'a, u16>,
+
+    for<'b> <T as Z<'b, u16>>::W: Clone,
+{
+    type W: ?Sized;
+}
diff --git a/tests/crashes/117942.rs b/tests/crashes/117942.rs
new file mode 100644
index 0000000000000..6fdfc6892506e
--- /dev/null
+++ b/tests/crashes/117942.rs
@@ -0,0 +1,7 @@
+//@ known-bug: #117942
+struct Foo {
+    _: union  {
+    #[rustfmt::skip]
+    f: String
+    },
+}
diff --git a/tests/crashes/118038.rs b/tests/crashes/118038.rs
new file mode 100644
index 0000000000000..a346e84c78f49
--- /dev/null
+++ b/tests/crashes/118038.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #118038
+#![feature(non_lifetime_binders)]
+
+fn trivial<A>()
+where
+    for<B> dyn Fn(A, *const A): Fn(A, *const B),
+{
+}
+
+fn main() {
+    trivial::<u8>();
+}
diff --git a/tests/crashes/118320.rs b/tests/crashes/118320.rs
new file mode 100644
index 0000000000000..093c58e1c05fb
--- /dev/null
+++ b/tests/crashes/118320.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #118320
+//@ edition:2021
+#![feature(const_trait_impl, effects, const_closures)]
+
+#[const_trait]
+trait Bar {
+    fn foo(&self);
+}
+
+impl Bar for () {}
+
+const FOO: () = {
+    (const || (()).foo())();
+};
diff --git a/tests/crashes/118403.rs b/tests/crashes/118403.rs
new file mode 100644
index 0000000000000..21ab15f9ffd0a
--- /dev/null
+++ b/tests/crashes/118403.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #118403
+#![feature(generic_const_exprs)]
+pub struct X<const N: usize> {}
+impl<const Z: usize> X<Z> {
+    pub fn y<'a, U: 'a>(&'a self) -> impl Iterator<Item = impl Iterator<Item = [u8; Z]> + '_> {
+        (0..1).map(move |_| (0..1).map(move |_| loop {}))
+    }
+}
diff --git a/tests/crashes/118603.rs b/tests/crashes/118603.rs
new file mode 100644
index 0000000000000..cde2cf3530571
--- /dev/null
+++ b/tests/crashes/118603.rs
@@ -0,0 +1,44 @@
+//@ known-bug: #118603
+//@ compile-flags: -Copt-level=0
+// ignore-tidy-linelength
+
+#![feature(generic_const_exprs)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+struct FlatTree;
+
+#[derive(Copy, Clone)]
+struct TreeLeaf;
+
+#[derive(Copy, Clone)]
+struct TreeNode<V, W>(V, W);
+
+const fn const_concat<const A: usize, const B: usize>(_: [FlatTree; A], _: [FlatTree; B]) -> [FlatTree; A + B] {
+    [FlatTree; A + B]
+}
+
+struct Builder<const N: usize, I> {
+    ops: [FlatTree; N],
+    builder: I,
+}
+
+fn create_node<const N: usize, const M: usize, A, B>(a: Builder<N, A>, b: Builder<M, B>) -> Builder<{ N + M + 1 }, TreeNode<A, B>> {
+    Builder {
+        ops: const_concat(const_concat::<N, M>(a.ops, b.ops), [FlatTree]),
+        builder: TreeNode(a.builder, b.builder),
+    }
+}
+
+const LEAF: Builder<1, TreeLeaf> = Builder {
+    ops: [FlatTree],
+    builder: TreeLeaf,
+};
+
+static INTERNAL_SIMPLE_BOOLEAN_TEMPLATES: &[fn()] = &[{
+    fn eval() {
+        create_node(LEAF, create_node(LEAF, LEAF));
+    }
+
+    eval
+}];
+
+pub fn main() {}
diff --git a/tests/crashes/118952-2.rs b/tests/crashes/118952-2.rs
new file mode 100644
index 0000000000000..469b1e8e90599
--- /dev/null
+++ b/tests/crashes/118952-2.rs
@@ -0,0 +1,10 @@
+//@ known-bug: #118952
+#![feature(generic_const_exprs)]
+
+pub struct TinyVec<T, const N: usize = { () }>
+where
+    [(); () - std::mem::size_of() - std::mem::size_of::<isize>()]:, {}
+
+pub fn main() {
+    let t = TinyVec::<u8>::new();
+}
diff --git a/tests/crashes/118952.rs b/tests/crashes/118952.rs
new file mode 100644
index 0000000000000..cd873703284dd
--- /dev/null
+++ b/tests/crashes/118952.rs
@@ -0,0 +1,25 @@
+//@ known-bug: #118952
+#![allow(non_camel_case_types)]
+#![feature(generic_const_exprs)]
+#![feature(specialization)]
+
+const DEFAULT_SMALL_VEC_INLINE_CAPACITY: usize = std::mem::size_of::<usize>() * 8;
+
+pub const fn tiny_vec_cap<T>() -> usize {
+    return (DEFAULT_SMALL_VEC_INLINE_CAPACITY - 1) / std::mem::size_of::<T>()
+}
+
+pub struct TinyVec<T, const N: usize = {tiny_vec_cap::<T>()}>
+    where [
+       ();
+       (N * std::mem::size_of::<T>())
+       - std::mem::size_of::<std::ptr::NonNull<T>>()
+       - std::mem::size_of::<isize>()
+    ]: ,
+{
+    data: isize //TinyVecData<T, N>,
+}
+
+pub fn main() {
+    let t = TinyVec::<u8>::new();
+}
diff --git a/tests/crashes/118987-2.rs b/tests/crashes/118987-2.rs
new file mode 100644
index 0000000000000..4382a7bcb6397
--- /dev/null
+++ b/tests/crashes/118987-2.rs
@@ -0,0 +1,17 @@
+//@ known-bug: #118987
+#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+
+trait Assoc {
+    type Output;
+}
+
+default impl<T: Clone> Assoc for T {
+    type Output = bool;
+}
+
+impl Assoc for u8 {}
+
+trait Foo {}
+
+impl Foo for <u8 as Assoc>::Output {}
+impl Foo for <u16 as Assoc>::Output {}
diff --git a/tests/crashes/118987.rs b/tests/crashes/118987.rs
new file mode 100644
index 0000000000000..4382a7bcb6397
--- /dev/null
+++ b/tests/crashes/118987.rs
@@ -0,0 +1,17 @@
+//@ known-bug: #118987
+#![feature(specialization)] //~ WARN the feature `specialization` is incomplete
+
+trait Assoc {
+    type Output;
+}
+
+default impl<T: Clone> Assoc for T {
+    type Output = bool;
+}
+
+impl Assoc for u8 {}
+
+trait Foo {}
+
+impl Foo for <u8 as Assoc>::Output {}
+impl Foo for <u16 as Assoc>::Output {}
diff --git a/tests/crashes/119272.rs b/tests/crashes/119272.rs
new file mode 100644
index 0000000000000..02e2cfd09e2f8
--- /dev/null
+++ b/tests/crashes/119272.rs
@@ -0,0 +1,27 @@
+//@ known-bug: #119272
+#![feature(type_alias_impl_trait)]
+mod defining_scope {
+    use super::*;
+    pub type Alias<T> = impl Sized;
+
+    pub fn cast<T>(x: Container<Alias<T>, T>) -> Container<T, T> {
+        x
+    }
+}
+
+struct Container<T: Trait<U>, U> {
+    x: <T as Trait<U>>::Assoc,
+}
+
+trait Trait<T> {
+    type Assoc;
+}
+
+impl<T> Trait<T> for T {
+    type Assoc = Box<u32>;
+}
+impl<T> Trait<T> for defining_scope::Alias<T> {
+    type Assoc = usize;
+}
+
+fn main() {}
diff --git a/tests/crashes/119299.rs b/tests/crashes/119299.rs
new file mode 100644
index 0000000000000..c8c10546d9409
--- /dev/null
+++ b/tests/crashes/119299.rs
@@ -0,0 +1,25 @@
+//@ known-bug: #119299
+#![feature(adt_const_params)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy;
+
+#[derive(Eq, PartialEq)]
+struct ConstStrU(*const u8, usize);
+
+impl ConstParamTy for &'static ConstStrU {}
+
+impl ConstStrU {
+  const fn from_bytes(bytes: &'static [u8]) -> Self {
+    Self(bytes.as_ptr(), bytes.len())
+  }
+}
+
+const fn chars_s<const S: &'static ConstStrU>() -> [char; 3] {
+  ['a','b','c']
+}
+
+fn main() {
+  const A: &'static ConstStrU = &ConstStrU::from_bytes(b"abc");
+  chars_s::<A>();
+}
diff --git a/tests/crashes/119692.rs b/tests/crashes/119692.rs
new file mode 100644
index 0000000000000..2e230f98d81d8
--- /dev/null
+++ b/tests/crashes/119692.rs
@@ -0,0 +1,48 @@
+//@ known-bug: #119692
+//@ compile-flags: -Copt-level=0
+#![allow(incomplete_features)]
+#![feature(adt_const_params)]
+#![feature(generic_const_exprs)]
+
+use std::ops::Add;
+
+#[derive(PartialEq, Eq, Clone, Debug, core::marker::ConstParamTy)]
+pub struct Dimension;
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Default)]
+pub struct Quantity<S, const D: Dimension>(pub(crate) S);
+
+impl<const D: Dimension, LHS, RHS> Add<Quantity<RHS, D>> for Quantity<LHS, D>
+where
+    LHS: Add<RHS>,
+{
+    type Output = Quantity<<LHS as Add<RHS>>::Output, D>;
+    fn add(self, rhs: Quantity<RHS, D>) -> Self::Output {
+        Quantity(self.0 + rhs.0)
+    }
+}
+
+impl<LHS, RHS> Add<RHS> for Quantity<LHS, { Dimension }>
+where
+    LHS: Add<RHS>,
+{
+    type Output = Quantity<<LHS as Add<RHS>>::Output, { Dimension }>;
+    fn add(self, rhs: RHS) -> Self::Output {
+        Quantity(self.0 + rhs)
+    }
+}
+
+impl Add<Quantity<f32, { Dimension }>> for f32 {
+    type Output = Quantity<f32, { Dimension }>;
+    fn add(self, rhs: Quantity<f32, { Dimension }>) -> Self::Output {
+        Quantity(self + rhs.0)
+    }
+}
+
+pub fn add<const U: Dimension>(x: Quantity<f32, U>, y: Quantity<f32, U>) -> Quantity<f32, U> {
+    x + y
+}
+
+fn main() {
+    add(Quantity::<f32, {Dimension}>(1.0), Quantity(2.0));
+}
diff --git a/tests/crashes/119694.rs b/tests/crashes/119694.rs
new file mode 100644
index 0000000000000..f655ea1cd343c
--- /dev/null
+++ b/tests/crashes/119694.rs
@@ -0,0 +1,18 @@
+//@ known-bug: #119694
+#![feature(dyn_star)]
+
+trait Trait {
+    fn foo(self);
+}
+
+impl Trait for usize {
+    fn foo(self) {}
+}
+
+fn bar(x: dyn* Trait) {
+    x.foo();
+}
+
+fn main() {
+    bar(0usize);
+}
diff --git a/tests/crashes/119701.rs b/tests/crashes/119701.rs
new file mode 100644
index 0000000000000..5f681bb8da88a
--- /dev/null
+++ b/tests/crashes/119701.rs
@@ -0,0 +1,21 @@
+//@ known-bug: #119701
+#![feature(const_trait_impl, effects, generic_const_exprs)]
+
+fn main() {
+    let _ = process::<()>([()]);
+}
+
+fn process<T: const Trait>() -> [(); T::make(2)] {
+    input
+}
+
+#[const_trait]
+trait Trait {
+    fn make(input: u8) -> usize;
+}
+
+impl const Trait for () {
+    fn make(input: usize) -> usize {
+        input / 2
+    }
+}
diff --git a/tests/crashes/119716-2.rs b/tests/crashes/119716-2.rs
new file mode 100644
index 0000000000000..9cdc4417f5ba9
--- /dev/null
+++ b/tests/crashes/119716-2.rs
@@ -0,0 +1,4 @@
+//@ known-bug: #119716
+#![feature(non_lifetime_binders)]
+trait Trait<T> {}
+fn f<T>() -> impl for<T> Trait<impl Trait<T>> {}
diff --git a/tests/crashes/119716.rs b/tests/crashes/119716.rs
new file mode 100644
index 0000000000000..d7cba0f51c4e0
--- /dev/null
+++ b/tests/crashes/119716.rs
@@ -0,0 +1,4 @@
+//@ known-bug: #119716
+#![feature(non_lifetime_binders)]
+trait v0<v1> {}
+fn kind  :(v3main impl for<v4> v0<'_, v2 = impl v0<v4> + '_>) {}
diff --git a/tests/crashes/119717.rs b/tests/crashes/119717.rs
new file mode 100644
index 0000000000000..22746548e02cb
--- /dev/null
+++ b/tests/crashes/119717.rs
@@ -0,0 +1,10 @@
+//@ known-bug: #119717
+#![feature(const_trait_impl, effects)]
+
+use std::ops::{FromResidual, Try};
+
+impl const FromResidual for T {
+    fn from_residual(t: T) -> _ {
+        t
+    }
+}
diff --git a/tests/crashes/119729.rs b/tests/crashes/119729.rs
new file mode 100644
index 0000000000000..ed07c58e89fdf
--- /dev/null
+++ b/tests/crashes/119729.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #119729
+#![feature(generic_const_exprs)]
+
+trait Size<const N: usize> {}
+
+impl<T: Sized> Size<{ std::mem::size_of::<T>() }> for T {}
+
+struct A<T: Size<8> + ?Sized> {
+    x: std::marker::PhantomData<T>,
+}
+
+fn foo(x: A<dyn Send>) {}
diff --git a/tests/crashes/119783.rs b/tests/crashes/119783.rs
new file mode 100644
index 0000000000000..9a41abe69206e
--- /dev/null
+++ b/tests/crashes/119783.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #119783
+#![feature(associated_const_equality)]
+
+trait Trait { const F: fn(); }
+
+fn take(_: impl Trait<F = { || {} }>) {}
+
+fn main() {}
diff --git a/tests/crashes/119786.rs b/tests/crashes/119786.rs
new file mode 100644
index 0000000000000..ca79664d8b74c
--- /dev/null
+++ b/tests/crashes/119786.rs
@@ -0,0 +1,15 @@
+//@ known-bug: #119786
+//@ edition:2021
+
+fn enum_upvar() {
+    type T = impl Copy;
+    let foo: T = Some((1u32, 2u32));
+    let x = move || {
+        match foo {
+            None => (),
+            Some(yield) => (),
+        }
+    };
+}
+
+pub fn main() {}
diff --git a/tests/crashes/119824.rs b/tests/crashes/119824.rs
new file mode 100644
index 0000000000000..d51cd5f49a395
--- /dev/null
+++ b/tests/crashes/119824.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #119824
+#![feature(generic_const_exprs)]
+
+const fn t<const N: usize>() -> u8 {
+    N as u8
+}
+
+#[repr(u8)]
+enum T<const N: u8 = { T::<0>::A as u8 + T::<0>::B as u8 }>
+where
+    [(); N as usize]:
+{
+    A = t::<N>() as u8, B
+}
diff --git a/tests/crashes/119830.rs b/tests/crashes/119830.rs
new file mode 100644
index 0000000000000..71becc04e1696
--- /dev/null
+++ b/tests/crashes/119830.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #119830
+#![feature(effects)]
+#![feature(min_specialization)]
+
+trait Specialize {}
+
+trait Foo {}
+
+impl<T> const Foo for T {}
+
+impl<T> const Foo for T where T: const Specialize {}
diff --git a/tests/crashes/119924-6.rs b/tests/crashes/119924-6.rs
new file mode 100644
index 0000000000000..01c4f43e8fd43
--- /dev/null
+++ b/tests/crashes/119924-6.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #119924
+#![feature(const_trait_impl, effects)]
+
+struct S;
+#[const_trait]
+trait Trait<const N: u32> {}
+
+const fn f<T: Trait<{
+    struct I<U: ~const Trait<0>>(U); // should've gotten rejected during AST validation
+    //~^ ICE no host param id for call in const yet no errors reported
+    0
+}>>() {}
+
+pub fn main() {}
diff --git a/tests/crashes/120241-2.rs b/tests/crashes/120241-2.rs
new file mode 100644
index 0000000000000..9c4a3a50293e3
--- /dev/null
+++ b/tests/crashes/120241-2.rs
@@ -0,0 +1,10 @@
+//@ known-bug: #120241
+//@ edition:2021
+#![feature(object_safe_for_dispatch)]
+#![feature(unsized_fn_params)]
+
+fn guard(_s: Copy) -> bool {
+    panic!()
+}
+
+fn main() {}
diff --git a/tests/crashes/120241.rs b/tests/crashes/120241.rs
new file mode 100644
index 0000000000000..f18347a006cb6
--- /dev/null
+++ b/tests/crashes/120241.rs
@@ -0,0 +1,13 @@
+//@ known-bug: #120241
+//@ edition:2021
+#![feature(object_safe_for_dispatch)]
+
+trait B {
+    fn f(a: A) -> A;
+}
+
+trait A {
+    fn g(b: B) -> B;
+}
+
+fn main() {}
diff --git a/tests/crashes/120482.rs b/tests/crashes/120482.rs
new file mode 100644
index 0000000000000..6cbc2009c5f63
--- /dev/null
+++ b/tests/crashes/120482.rs
@@ -0,0 +1,13 @@
+//@ known-bug: #120482
+//@ edition:2021
+#![feature(object_safe_for_dispatch)]
+
+trait B {
+    fn bar(&self, x: &Self);
+}
+
+trait A {
+    fn g(new: B) -> B;
+}
+
+fn main() {}
diff --git a/tests/crashes/120503.rs b/tests/crashes/120503.rs
new file mode 100644
index 0000000000000..28f1e3dfd94c4
--- /dev/null
+++ b/tests/crashes/120503.rs
@@ -0,0 +1,10 @@
+//@ known-bug: #120503
+#![feature(effects)]
+
+trait MyTrait {}
+
+impl MyTrait for i32 {
+    async const fn bar(&self) {
+        main8().await;
+    }
+}
diff --git a/tests/crashes/120600-2.rs b/tests/crashes/120600-2.rs
new file mode 100644
index 0000000000000..aa1785eea84c4
--- /dev/null
+++ b/tests/crashes/120600-2.rs
@@ -0,0 +1,13 @@
+//@ known-bug: #120600
+#![feature(never_type, never_type_fallback)]
+
+enum E { Bar(!) }
+
+fn f(a: &E, b: &E) {
+    match (a, b) {
+        (E::Bar(a), E::Bar(b)) => { *a == *b; }
+        _ => {}
+    }
+}
+
+pub fn main() {}
diff --git a/tests/crashes/120600.rs b/tests/crashes/120600.rs
new file mode 100644
index 0000000000000..1be51a8da1602
--- /dev/null
+++ b/tests/crashes/120600.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #120600
+#![feature(never_type)]
+#![feature(never_type_fallback)]
+
+#[derive(Ord, Eq, PartialOrd, PartialEq)]
+enum E {
+    Foo,
+    Bar(!, i32, i32),
+}
+
+fn main() {}
diff --git a/tests/crashes/120793-2.rs b/tests/crashes/120793-2.rs
new file mode 100644
index 0000000000000..0ce5e4df2247c
--- /dev/null
+++ b/tests/crashes/120793-2.rs
@@ -0,0 +1,22 @@
+//@ known-bug: #120793
+// can't use build-fail, because this also fails check-fail, but
+// the ICE from #120787 only reproduces on build-fail.
+//@ compile-flags: --emit=mir
+
+#![feature(effects)]
+
+trait Dim {
+    fn dim() -> usize;
+}
+
+enum Dim3 {}
+
+impl Dim for Dim3 {
+    fn dim(x: impl Sized) -> usize {
+        3
+    }
+}
+
+fn main() {
+    [0; Dim3::dim()];
+}
diff --git a/tests/crashes/120793.rs b/tests/crashes/120793.rs
new file mode 100644
index 0000000000000..7e9166a50e553
--- /dev/null
+++ b/tests/crashes/120793.rs
@@ -0,0 +1,21 @@
+//@ known-bug: #120793
+#![feature(effects)]
+
+trait Dim {
+    fn dim() -> usize;
+}
+
+enum Dim3 {}
+
+impl Dim for Dim3 {
+    fn dim(mut x: impl Iterator<Item = &'_ ()>) -> usize {
+        3
+    }
+}
+
+fn main() {
+    let array: [usize; Dim3::dim()]
+    //~^ ERROR E0015
+        = [0; Dim3::dim()];
+        //~^ ERROR E0015
+}
diff --git a/tests/crashes/120873.rs b/tests/crashes/120873.rs
new file mode 100644
index 0000000000000..45bc0bd457b10
--- /dev/null
+++ b/tests/crashes/120873.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #120873
+#[repr(packed)]
+
+struct Dealigned<T>(u8, T);
+
+#[derive(PartialEq)]
+#[repr(C)]
+struct Dealigned<T>(u8, T);
diff --git a/tests/crashes/120911.rs b/tests/crashes/120911.rs
new file mode 100644
index 0000000000000..9bd2bf681420e
--- /dev/null
+++ b/tests/crashes/120911.rs
@@ -0,0 +1,26 @@
+//@ known-bug: #120911
+trait Container {
+    type Item<'a>;
+}
+impl Container for () {
+    type Item<'a> = ();
+}
+struct Exchange<C, F> {
+    _marker: std::marker::PhantomData<(C, F)>,
+}
+fn exchange<C, F>(_: F) -> Exchange<C, F>
+where
+    C: Container,
+    for<'a> F: FnMut(&C::Item<'a>),
+{
+    unimplemented!()
+}
+trait Parallelization<C> {}
+impl<C, F> Parallelization<C> for Exchange<C, F> {}
+fn unary_frontier<P: Parallelization<()>>(_: P) {}
+fn main() {
+    let exchange = exchange(|_| ());
+    let _ = || {
+        unary_frontier(exchange);
+    };
+}
diff --git a/tests/crashes/121052.rs b/tests/crashes/121052.rs
new file mode 100644
index 0000000000000..5d16b06db237d
--- /dev/null
+++ b/tests/crashes/121052.rs
@@ -0,0 +1,32 @@
+//@ known-bug: #121052
+#![feature(generic_const_exprs, with_negative_coherence)]
+
+use std::ops::Mul;
+
+pub trait Indices<const N: usize> {
+    const NUM_ELEMS: usize;
+}
+
+impl<I: Indices<N>, J: Indices<N>, const N: usize> Mul for Tensor<I, N>
+where
+    I: Concat<J>,
+    <I as Concat<J>>::Output: Indices<N>,
+    [u8; I::NUM_ELEMS]: Sized,
+    [u8; J::NUM_ELEMS]: Sized,
+    [u8; <I as Concat<J>>::Output::NUM_ELEMS]: Sized,
+{
+}
+
+pub trait Concat<J> {}
+
+pub struct Tensor<I: Indices<N>, const N: usize> {}
+
+impl<I: Indices<N>, J: Indices<N>, const N: usize> Mul for Tensor<I, N>
+where
+    I: Concat<J>,
+    <I as Concat<J>>::Output: Indices<N>,
+    [u8; I::NUM_ELEMS]: Sized,
+    [u8; J::NUM_ELEMS]: Sized,
+    [u8; <I as Concat<J>>::Output::NUM_ELEMS]: Sized,
+{
+}
diff --git a/tests/crashes/121097.rs b/tests/crashes/121097.rs
new file mode 100644
index 0000000000000..65c6028e03e36
--- /dev/null
+++ b/tests/crashes/121097.rs
@@ -0,0 +1,10 @@
+//@ known-bug: #121097
+#[repr(simd)]
+enum Aligned {
+    Zero = 0,
+    One = 1,
+}
+
+fn tou8(al: Aligned) -> u8 {
+    al as u8
+}
diff --git a/tests/crashes/121126.rs b/tests/crashes/121126.rs
new file mode 100644
index 0000000000000..2ebe91f02ded9
--- /dev/null
+++ b/tests/crashes/121126.rs
@@ -0,0 +1,4 @@
+//@ known-bug: #121126
+fn main() {
+    let _n = 1i64 >> [64][4_294_967_295];
+}
diff --git a/tests/crashes/121134.rs b/tests/crashes/121134.rs
new file mode 100644
index 0000000000000..36397d4ec3c0d
--- /dev/null
+++ b/tests/crashes/121134.rs
@@ -0,0 +1,20 @@
+//@ known-bug: #121134
+trait Output<'a> {
+    type Type;
+}
+
+struct Wrapper;
+
+impl Wrapper {
+    fn do_something_wrapper<O, F>(&mut self, do_something_wrapper: F)
+    where
+        FnOnce:,
+        F: for<'a> FnOnce(<F as Output<i32, _>>::Type),
+    {
+    }
+}
+
+fn main() {
+    let mut wrapper = Wrapper;
+    wrapper.do_something_wrapper::<i32, _>(|value| ());
+}
diff --git a/tests/crashes/121161.rs b/tests/crashes/121161.rs
new file mode 100644
index 0000000000000..6da6426a86d92
--- /dev/null
+++ b/tests/crashes/121161.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #121161
+#![allow(incomplete_features)]
+#![feature(unnamed_fields)]
+
+
+#[derive(Eq)]
+#[repr(C)]
+struct Bar {
+    _: union {
+        a: u8,
+    },
+}
diff --git a/tests/crashes/121263-2.rs b/tests/crashes/121263-2.rs
new file mode 100644
index 0000000000000..2c6327a8808a5
--- /dev/null
+++ b/tests/crashes/121263-2.rs
@@ -0,0 +1,6 @@
+//@ known-bug: #121263
+#[repr(C)]
+#[derive(Debug)]
+struct L {
+    _: MyI32,
+}
diff --git a/tests/crashes/121263.rs b/tests/crashes/121263.rs
new file mode 100644
index 0000000000000..cd7583a7fafce
--- /dev/null
+++ b/tests/crashes/121263.rs
@@ -0,0 +1,9 @@
+//@ known-bug: #121263
+#[repr(C)]
+#[repr(C)]
+#[derive(Debug)]
+struct L {
+    _: i32,
+    _: MyI32,
+    _: BadEnum,
+}
diff --git a/tests/crashes/121299.rs b/tests/crashes/121299.rs
new file mode 100644
index 0000000000000..be5e0c0df573e
--- /dev/null
+++ b/tests/crashes/121299.rs
@@ -0,0 +1,6 @@
+//@ known-bug: #121299
+#[derive(Eq)]
+struct D {
+    _: union {
+    },
+}
diff --git a/tests/crashes/121411.rs b/tests/crashes/121411.rs
new file mode 100644
index 0000000000000..ef7b16579dd58
--- /dev/null
+++ b/tests/crashes/121411.rs
@@ -0,0 +1,13 @@
+//@ known-bug: #121411
+#![feature(const_trait_impl, effects)]
+
+#[const_trait]
+trait Foo {
+    fn into_iter(&self) {}
+}
+
+impl const Foo for () {
+    fn into_iter(a: u32, b: u32) {}
+}
+
+const _: () = Foo::into_iter(&());
diff --git a/tests/crashes/121422.rs b/tests/crashes/121422.rs
new file mode 100644
index 0000000000000..5d7ef6e8ce991
--- /dev/null
+++ b/tests/crashes/121422.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #121422
+#![feature(non_lifetime_binders)]
+
+trait Trait<T: ?Sized> {}
+
+fn produce() -> impl for<T> Trait<(), Assoc = impl Trait<T>> {
+    16
+}
diff --git a/tests/crashes/121429.rs b/tests/crashes/121429.rs
new file mode 100644
index 0000000000000..09bd343e0ba99
--- /dev/null
+++ b/tests/crashes/121429.rs
@@ -0,0 +1,17 @@
+//@ known-bug: #121429
+#![feature(generic_const_exprs)]
+
+pub trait True {}
+
+impl<const N: usize = { const { 3 } }> PartialEq<FixedI8<FRAC_RHS>> for FixedI8<FRAC_LHS> where
+    If<{}>: True
+{
+}
+#![feature(generic_const_exprs)]
+
+pub trait True {}
+
+impl<const N: usize = { const { 3 } }> PartialEq<FixedI8<FRAC_RHS>> for FixedI8<FRAC_LHS> where
+    If<{}>: True
+{
+}
diff --git a/tests/crashes/121444.rs b/tests/crashes/121444.rs
new file mode 100644
index 0000000000000..a6373a58c426e
--- /dev/null
+++ b/tests/crashes/121444.rs
@@ -0,0 +1,13 @@
+//@ known-bug: #121444
+//@ compile-flags: -Copt-level=0
+//@ edition:2021
+//@ only-x86_64
+//@ ignore-windows
+#[repr(align(536870912))]
+pub struct A(i64);
+
+pub extern "C" fn foo(x: A) {}
+
+fn main() {
+    foo(A(0));
+}
diff --git a/tests/crashes/121536.rs b/tests/crashes/121536.rs
new file mode 100644
index 0000000000000..000e7cb15eb2f
--- /dev/null
+++ b/tests/crashes/121536.rs
@@ -0,0 +1,20 @@
+//@ known-bug: #121536
+#![feature(effects)]
+
+#[derive(Debug, Clone, Copy)]
+pub struct Vec3 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+
+impl std::ops::Add<Vec3> for Vec3 {
+    type Output = Vec3;
+    const fn add(self, b: Vec3) -> Self::Output {
+        Vec3 {
+            x: self.x + b.x,
+            y: self.y + b.y,
+            z: self.z + b.z,
+        }
+    }
+}
diff --git a/tests/crashes/121574-2.rs b/tests/crashes/121574-2.rs
new file mode 100644
index 0000000000000..a08f3f063974b
--- /dev/null
+++ b/tests/crashes/121574-2.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #121574
+#![feature(generic_const_exprs)]
+pub struct DimName<const N: usize> {}
+impl<const Z: usize> X<Z> {
+    pub fn y<'a, U: 'a>(&'a self) -> impl Iterator<Item = impl Iterator<Item = [u8; Z]> + '_> {
+        "0".as_bytes(move |_| (0..1).map(move |_| loop {}))
+    }
+}
diff --git a/tests/crashes/121574.rs b/tests/crashes/121574.rs
new file mode 100644
index 0000000000000..53eec829c5f38
--- /dev/null
+++ b/tests/crashes/121574.rs
@@ -0,0 +1,6 @@
+//@ known-bug: #121574
+#![feature(generic_const_exprs)]
+
+impl<const Z: usize> X<Z> {
+    pub fn y<'a, U: 'a>(&'a self) -> impl Iterator<Item = impl Iterator<Item = [u8; Z]> + '_> {}
+}
diff --git a/tests/crashes/121575.rs b/tests/crashes/121575.rs
new file mode 100644
index 0000000000000..f0ce26c6f9564
--- /dev/null
+++ b/tests/crashes/121575.rs
@@ -0,0 +1,107 @@
+//@ known-bug: #121575
+// ignore-tidy-linelength
+#![feature(generic_const_exprs)]
+
+use std::array;
+
+trait PrimRec<const N: usize, const O: usize> {
+    fn eval(&self, x: [usize; N]) -> [usize; O];
+}
+
+struct Zero;
+
+impl<const N: usize> PrimRec<N, 1> for Zero {
+    fn eval(&self, _: [usize; N]) -> [usize; 1] {
+        [0]
+    }
+}
+
+struct Const(usize);
+
+impl<const N: usize> PrimRec<N, 1> for Const {
+    fn eval(&self, _: [usize; N]) -> [usize; 1] {
+        [self.0]
+    }
+}
+
+struct S;
+
+impl PrimRec<1, 1> for S {
+    fn eval(&self, x: [usize; 1]) -> [usize; 1] {
+        [x[0] + 1]
+    }
+}
+
+struct Proj<const I: usize>;
+
+impl<const N: usize, const I: usize> PrimRec<N, 1> for Proj<I> {
+    fn eval(&self, x: [usize; N]) -> [usize; 1] {
+        [x[I]]
+    }
+}
+
+struct Merge<const N: usize, const O1: usize, const O2: usize, A: PrimRec<N, O1>, B: PrimRec<N, O2>>(
+    A,
+    B,
+);
+
+fn concat<const M: usize, const N: usize>(a: [usize; M], b: [usize; N]) -> [usize; M + N] {
+    array::from_fn(|i| if i < M { a[i] } else { b[i - M] })
+}
+
+impl<const N: usize, const O1: usize, const O2: usize, A: PrimRec<N, O1>, B: PrimRec<N, O2>>
+    PrimRec<N, { O1 + O2 }> for Merge<N, O1, O2, A, B>
+{
+    fn eval(&self, x: [usize; N]) -> [usize; O1 + O2] {
+        concat(self.0.eval(x), self.1.eval(x))
+    }
+}
+
+struct Compose<const N: usize, const I: usize, const O: usize, A: PrimRec<N, I>, B: PrimRec<I, O>>(
+    A,
+    B,
+);
+
+impl<const N: usize, const I: usize, const O: usize, A: PrimRec<N, I>, B: PrimRec<I, O>>
+    PrimRec<N, O> for Compose<N, I, O, A, B>
+{
+    fn eval(&self, x: [usize; N]) -> [usize; O] {
+        self.1.eval(self.0.eval(x))
+    }
+}
+
+struct Rec<const N: usize, const O: usize, Base: PrimRec<N, O>, F: PrimRec<{ O + (N + 1) }, O>>(
+    Base,
+    F,
+);
+
+fn tail<const N: usize>(x: [usize; N + 1]) -> [usize; N] {
+    array::from_fn(|i| x[i + 1])
+}
+
+fn cons<const N: usize>(x: usize, xs: [usize; N]) -> [usize; N + 1] {
+    array::from_fn(|i| if i == 0 { x } else { xs[i - 1] })
+}
+
+impl<const N: usize, const O: usize, Base: PrimRec<N, O>, F: PrimRec<{ O + (N + 1) }, O>>
+    PrimRec<{ N + 1 }, O> for Rec<N, O, Base, F>
+{
+    fn eval(&self, x: [usize; N + 1]) -> [usize; O] {
+        match (x[0], tail(x)) {
+            (0, x) => self.0.eval(x),
+            (y, x) => {
+                let xy = cons(y - 1, x);
+                let input = concat(self.eval(xy), xy);
+                self.1.eval(input)
+            }
+        }
+    }
+}
+
+fn main() {
+    let one = Compose(Zero, S);
+    dbg!(one.eval([]));
+    let add: Rec<1, 1, Proj<0>, Compose<3, 1, 1, Proj<0>, S>> =
+        Rec(Proj::<0>, Compose(Proj::<0>, S));
+    dbg!(add.eval([3, 2]));
+}
diff --git a/tests/crashes/121585-1.rs b/tests/crashes/121585-1.rs
new file mode 100644
index 0000000000000..2a4638efcabdd
--- /dev/null
+++ b/tests/crashes/121585-1.rs
@@ -0,0 +1,13 @@
+//@ known-bug: #121585
+#![feature(generic_const_exprs)]
+
+trait Trait {}
+
+struct HasCastInTraitImpl<const N: usize, const M: u128>;
+impl<const O: f64> Trait for HasCastInTraitImpl<O, { O as u128 }> {}
+
+pub fn use_trait_impl() {
+    fn assert_impl<T: Trait>() {}
+
+    assert_impl::<HasCastInTraitImpl<13, 13>>();
+}
diff --git a/tests/crashes/121585-2.rs b/tests/crashes/121585-2.rs
new file mode 100644
index 0000000000000..99cc8f7919559
--- /dev/null
+++ b/tests/crashes/121585-2.rs
@@ -0,0 +1,30 @@
+//@ known-bug: #121585
+//@ check-pass
+#![feature(generic_const_exprs)]
+#![allow(incomplete_features)]
+
+trait Trait {}
+pub struct EvaluatableU128<const N: u128>;
+
+struct HasCastInTraitImpl<const N: usize, const M: u128>;
+impl<const O: f64> Trait for HasCastInTraitImpl<O, { O as u128 }> {}
+
+pub fn use_trait_impl<const N: usize>() where EvaluatableU128<{N as u128}>:, {
+    fn assert_impl<T: Trait>() {}
+
+    assert_impl::<HasCastInTraitImpl<N, { N as u128 }>>();
+    assert_impl::<HasCastInTraitImpl<N, { N as _ }>>();
+    assert_impl::<HasCastInTraitImpl<12, { 12 as u128 }>>();
+    assert_impl::<HasCastInTraitImpl<13, 13>>();
+}
+pub fn use_trait_impl_2<const N: usize>() where EvaluatableU128<{N as _}>:, {
+    fn assert_impl<T: Trait>() {}
+
+    assert_impl::<HasCastInTraitImpl<N, { N as u128 }>>();
+    assert_impl::<HasCastInTraitImpl<N, { N as _ }>>();
+    assert_impl::<HasCastInTraitImpl<12, { 12 as u128 }>>()const NUM: u8 = xyz();
+    assert_impl::<HasCastInTraitImpl<13, 13>>();
+}
+
+
+fn main() {}
diff --git a/tests/crashes/121613-2.rs b/tests/crashes/121613-2.rs
new file mode 100644
index 0000000000000..ddc4f37c96a2f
--- /dev/null
+++ b/tests/crashes/121613-2.rs
@@ -0,0 +1,28 @@
+//@ known-bug: #121613
+fn main() {
+    // destructure through a qualified path
+    let <Foo as A>::Assoc { br } = StructStruct { br: 2 };
+    //~^ ERROR usage of qualified paths in this context is experimental
+    let _ = <Foo as A>::Assoc { br: 2 };
+    //~^ ERROR usage of qualified paths in this context is experimental
+    let <E>::V(..) = E::V(|a, b| a.cmp(b));
+    //~^ ERROR usage of qualified paths in this context is experimental
+}
+
+struct StructStruct {
+    br: i8,
+}
+
+struct Foo;
+
+trait A {
+    type Assoc;
+}
+
+impl A for Foo {
+    type Assoc = StructStruct;
+}
+
+enum E {
+    V(u8)
+}
diff --git a/tests/crashes/121613.rs b/tests/crashes/121613.rs
new file mode 100644
index 0000000000000..ec9ba82a68c5f
--- /dev/null
+++ b/tests/crashes/121613.rs
@@ -0,0 +1,24 @@
+//@ known-bug: #121613
+fn main() {
+    let _ = <Foo as A>::Assoc { br: 2 };
+
+    let <E>::V(..) = E::V(|a, b| a.cmp(b));
+}
+
+struct StructStruct {
+    br: i8,
+}
+
+struct Foo;
+
+trait A {
+    type Assoc;
+}
+
+impl A for Foo {
+    type Assoc = StructStruct;
+}
+
+enum E {
+    V(u8),
+}
diff --git a/tests/crashes/121623.rs b/tests/crashes/121623.rs
new file mode 100644
index 0000000000000..3c01a7f452ca7
--- /dev/null
+++ b/tests/crashes/121623.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #121623
+fn main() {
+    match () {
+        _ => 'b: {
+            continue 'b;
+        }
+    }
+}
diff --git a/tests/crashes/121722.rs b/tests/crashes/121722.rs
new file mode 100644
index 0000000000000..d1b8c447bf727
--- /dev/null
+++ b/tests/crashes/121722.rs
@@ -0,0 +1,10 @@
+//@ known-bug: #121722
+#[repr(C)]
+struct Foo {
+    _: u8,
+}
+
+#[repr(C)]
+struct D {
+    _: Foo,
+}
diff --git a/tests/crashes/121799.rs b/tests/crashes/121799.rs
new file mode 100644
index 0000000000000..6035c9d9b150d
--- /dev/null
+++ b/tests/crashes/121799.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #121799
+struct S {
+    _: str
+}
+
+fn func(a: S)
+{
+    let _x = a.f;
+}
+
+fn main() {}
diff --git a/tests/crashes/121816.rs b/tests/crashes/121816.rs
new file mode 100644
index 0000000000000..a5569ea19d3ea
--- /dev/null
+++ b/tests/crashes/121816.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #121816
+fn f<'a, T>(_: &'static &'a (), x: &'a T) -> &'static T {
+    x
+}
+trait W<'a> {
+    fn g<T>(self, x: &'a T) -> &'static T;
+}
+impl<'a> W<'a> for &'static () {
+    fn g<T>(self, x: &'a T) -> &'static T {
+        f(&self, x)
+    }
+}
diff --git a/tests/crashes/121858-2.rs b/tests/crashes/121858-2.rs
new file mode 100644
index 0000000000000..cb80c081cffa3
--- /dev/null
+++ b/tests/crashes/121858-2.rs
@@ -0,0 +1,20 @@
+//@ known-bug: #121858
+#![allow(named_arguments_used_positionally)]
+#![feature(generic_const_exprs)]
+struct Inner<const N: usize, const M: usize>;
+impl<const N: usize, const M: usize> Inner<N, M> where [(); N + M]: {
+    fn i() -> Self {
+        Self
+    }
+}
+
+struct Outer<const A: i64, const B: usize>(Inner<A, { B * 2 }>) where [(); A + (B * 2)]:;
+impl<const A: usize, const B: usize> Outer<A, B> where [(); A + (B * 2)]: {
+    fn o() -> Union {
+        Self(Inner::i())
+    }
+}
+
+fn main() {
+    Outer::<1, 1>::o();
+}
diff --git a/tests/crashes/121858.rs b/tests/crashes/121858.rs
new file mode 100644
index 0000000000000..7d5bae37f846b
--- /dev/null
+++ b/tests/crashes/121858.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #121858
+#![feature(generic_const_exprs)]
+
+struct Outer<const A: i64, const B: usize>();
+impl<const A: usize, const B: usize> Outer<A, B>
+where
+    [(); A + (B * 2)]:,
+{
+    fn o() -> Union {}
+}
+
+fn main() {
+    Outer::<1, 1>::o();
+}
diff --git a/tests/crashes/121957-1.rs b/tests/crashes/121957-1.rs
new file mode 100644
index 0000000000000..74b4649cc9d95
--- /dev/null
+++ b/tests/crashes/121957-1.rs
@@ -0,0 +1,20 @@
+//@ known-bug: #121957
+#![feature(const_trait_impl, effects)]
+
+#[const_trait]
+trait Main {
+    fn compute<T: ~const Aux>() -> u32;
+}
+
+impl const Main for () {
+    fn compute<'x, 'y, 'z: 'x>() -> u32 {}
+}
+
+#[const_trait]
+trait Aux {}
+
+impl const Aux for () {}
+
+fn main() {
+    const _: u32 = <()>::compute::<()>();
+}
diff --git a/tests/crashes/121957-2.rs b/tests/crashes/121957-2.rs
new file mode 100644
index 0000000000000..74b4649cc9d95
--- /dev/null
+++ b/tests/crashes/121957-2.rs
@@ -0,0 +1,20 @@
+//@ known-bug: #121957
+#![feature(const_trait_impl, effects)]
+
+#[const_trait]
+trait Main {
+    fn compute<T: ~const Aux>() -> u32;
+}
+
+impl const Main for () {
+    fn compute<'x, 'y, 'z: 'x>() -> u32 {}
+}
+
+#[const_trait]
+trait Aux {}
+
+impl const Aux for () {}
+
+fn main() {
+    const _: u32 = <()>::compute::<()>();
+}
diff --git a/tests/crashes/121963.rs b/tests/crashes/121963.rs
new file mode 100644
index 0000000000000..c2ee8716f53a5
--- /dev/null
+++ b/tests/crashes/121963.rs
@@ -0,0 +1,26 @@
+//@ known-bug: #121963
+#![feature(generic_const_exprs)]
+use std::marker::PhantomData;
+
+trait Arch {
+    const CHANNEL_COUNT: usize = 2;
+}
+
+struct Channel<const N: usize> {
+    r: [u8; N],
+}
+
+struct Dram<A: Arch, S = Channel<{ A::CHANNEL_COUNT }>> {
+    a: PhantomData<A>,
+    s: PhantomData<S>,
+}
+
+struct C<A: Arch>
+where
+    Channel<{ A::CHANNEL_COUNT }, u8>: Sized,
+{
+    b: Dram<A>,
+    //  b: Dram<A, Channel<{ A::CHANNEL_COUNT }>>,  // When I specified generic here, it worked
+}
+
+fn main() {}
diff --git a/tests/crashes/122044.rs b/tests/crashes/122044.rs
new file mode 100644
index 0000000000000..4c1d0de5719e8
--- /dev/null
+++ b/tests/crashes/122044.rs
@@ -0,0 +1,38 @@
+//@ known-bug: #122044
+use std::hint::black_box;
+
+trait Func {
+    type Ret: Id;
+}
+
+trait Id {
+    type Assoc;
+}
+impl Id for u32 {}
+impl Id for u32 {}
+
+impl<F: FnOnce() -> R, R: Id> Func for F {
+    type Ret = R;
+}
+
+fn bar() -> impl Copy + Id {
+    0u32
+}
+
+struct Foo<T: Func> {
+    _func: T,
+    value: Option<<<T as Func>::Ret as Id>::Assoc>,
+}
+
+fn main() {
+    let mut fn_def = black_box(Foo {
+        _func: bar,
+        value: None,
+    });
+    let fn_ptr = black_box(Foo {
+        _func: bar as fn() -> _,
+        value: None,
+    });
+
+    fn_def.value = fn_ptr.value;
+}
diff --git a/tests/crashes/122529.rs b/tests/crashes/122529.rs
new file mode 100644
index 0000000000000..87d393a453243
--- /dev/null
+++ b/tests/crashes/122529.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #122529
+pub trait Archive {
+    type Archived;
+}
+
+impl<'a> Archive for <&'a [u8] as Archive>::Archived {
+    type Archived = ();
+}
diff --git a/tests/crashes/122548.rs b/tests/crashes/122548.rs
new file mode 100644
index 0000000000000..232ce5d441313
--- /dev/null
+++ b/tests/crashes/122548.rs
@@ -0,0 +1,17 @@
+//@ known-bug: #122548
+#![feature(const_mut_refs)]
+#![feature(const_refs_to_static)]
+
+use std::cell::UnsafeCell;
+
+struct Meh {
+    x: &'static UnsafeCell<i32>,
+}
+
+const MUH: Meh = Meh {
+    x: &mut *(&READONLY as *const _ as *mut _),
+};
+
+static READONLY: i32 = 0;
+
+pub fn main() {}
diff --git a/tests/crashes/122552.rs b/tests/crashes/122552.rs
new file mode 100644
index 0000000000000..29566941e22b2
--- /dev/null
+++ b/tests/crashes/122552.rs
@@ -0,0 +1,10 @@
+//@ known-bug: #122552
+//@ edition:2021
+
+trait X {
+    fn line_stream<'a, Repr>() -> Self::LineStreamFut<{ async {} }, Repr>;
+}
+
+struct Y;
+
+pub fn main() {}
diff --git a/tests/crashes/122587-1.rs b/tests/crashes/122587-1.rs
new file mode 100644
index 0000000000000..ea0e843a10cea
--- /dev/null
+++ b/tests/crashes/122587-1.rs
@@ -0,0 +1,5 @@
+//@ known-bug: #122587
+const b: f16 = 0.0f16;
+pub fn main() {
+   let b = 0.0f16;
+}
diff --git a/tests/crashes/122638.rs b/tests/crashes/122638.rs
new file mode 100644
index 0000000000000..af0fc5bbd5031
--- /dev/null
+++ b/tests/crashes/122638.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #122638
+#![feature(min_specialization)]
+
+impl<'a, T: std::fmt::Debug, const N: usize> Iterator for ConstChunksExact<'a, T, { N }> {
+    fn next(&mut self) -> Option<Self::Item> {}
+}
+
+struct ConstChunksExact<'a, T: '_, const assert: usize> {}
+
+impl<'a, T: std::fmt::Debug, const N: usize> Iterator for ConstChunksExact<'a, T, {}> {
+    type Item = &'a [T; N];
+}
diff --git a/tests/crashes/122681.rs b/tests/crashes/122681.rs
new file mode 100644
index 0000000000000..7dae276950e1d
--- /dev/null
+++ b/tests/crashes/122681.rs
@@ -0,0 +1,10 @@
+//@ known-bug: #122681
+#[rustc_layout_scalar_valid_range_start(1)]
+struct UnitStruct;
+
+#[derive(Default)]
+enum SomeEnum {
+    #[default]
+    Unit,
+    Tuple(UnitStruct),
+}
diff --git a/tests/crashes/122704.rs b/tests/crashes/122704.rs
new file mode 100644
index 0000000000000..d6c07be831885
--- /dev/null
+++ b/tests/crashes/122704.rs
@@ -0,0 +1,14 @@
+//@ known-bug: #122704
+use std::any::Any;
+
+pub struct Foo {
+    bar: Box<dyn for<'a> Fn(&'a usize) -> Box<dyn Any + 'a>>,
+}
+
+impl Foo {
+    pub fn ack<I>(&mut self, f: impl for<'a> Fn(&'a usize) -> Box<I>) {
+        self.bar = Box::new(|baz| Box::new(f(baz)));
+    }
+}
+
+fn main() {}
diff --git a/tests/crashes/122710.rs b/tests/crashes/122710.rs
new file mode 100644
index 0000000000000..16911fd522f8e
--- /dev/null
+++ b/tests/crashes/122710.rs
@@ -0,0 +1,24 @@
+//@ known-bug: #122710
+use std::marker::PhantomData;
+
+pub trait BarTrait<T> {
+  fn bar(self, _: T);
+}
+
+impl<T, F: Fn(T)> BarTrait<T> for F {
+  fn bar(self, _: T) { }
+}
+
+impl<T: for<'a> MyTrait<'a>> BarTrait<T> for () {
+  fn bar(self, _: T) { }
+}
+
+pub trait MyTrait<'a> { }
+
+impl<'a> MyTrait<'a> for PhantomData<&'a ()> { }
+
+fn foo() {
+  ().bar(PhantomData);
+}
+
+pub fn main() {}
diff --git a/tests/crashes/122736.rs b/tests/crashes/122736.rs
new file mode 100644
index 0000000000000..83b60444c2f4d
--- /dev/null
+++ b/tests/crashes/122736.rs
@@ -0,0 +1,15 @@
+//@ known-bug: #122736
+fn main_ref() {
+    let array = [(); {
+        let mut x = &0;
+        let mut n = 0;
+        while n < 5 {
+            x = &0;
+        }
+        0
+    }];
+
+    let mut ptrs: Vec<*const [u8]> = vec![&array[0..0], &array[0..1], &array, &array[1..]];
+}
+
+fn main() {}
diff --git a/tests/crashes/122823.rs b/tests/crashes/122823.rs
new file mode 100644
index 0000000000000..ec22b331ad929
--- /dev/null
+++ b/tests/crashes/122823.rs
@@ -0,0 +1,69 @@
+//@ known-bug: #122823
+//@ compile-flags: -Copt-level=0
+// ignore-tidy-linelength
+
+use std::vec::Vec;
+use std::iter::Peekable;
+
+pub fn main() {
+    let packet = decode(vec![1,0,1,0]);
+}
+
+pub fn decode(bitstream: Vec<u64>) -> Packet {
+    let mut bitstream_itr = bitstream.into_iter().peekable();
+    return match decode_packet(&mut bitstream_itr) {
+        Some(p) => p,
+        None    => panic!("expected outer packet"),
+    }
+}
+
+pub fn decode_packets<I: Iterator<Item = u64>>(itr: &mut Peekable<I>) -> Vec<Packet> {
+    let mut res = Vec::new();
+    loop {
+        match decode_packet(itr) {
+            Some(p) => { res.push(p); },
+            None    => break
+        }
+    }
+
+    return res;
+}
+
+pub fn decode_packet<I: Iterator<Item = u64>>(itr: &mut Peekable<I>) -> Option<Packet> {
+    // get version digits
+    let version = extend_number(0, itr, 3)?;
+    let type_id = extend_number(0, itr, 3)?;
+    return operator_packet(version, type_id, itr);
+}
+
+pub fn operator_packet<I: Iterator<Item = u64>>(version: u64, type_id: u64, itr: &mut Peekable<I>) -> Option<Packet> {
+    let p = OperatorPacket {
+        version: version,
+        type_id: type_id,
+        packets: decode_packets(&mut itr.take(0).peekable()),
+    };
+
+    return Some(Packet::Operator(p));
+}
+
+pub fn extend_number<I: Iterator<Item = u64>>(num: u64, itr: &mut Peekable<I>, take: u64) -> Option<u64> {
+    let mut value = num;
+    for _ in 0..take {
+        value *= 2;
+        value += itr.next()?;
+    }
+
+    return Some(value);
+}
+
+#[derive(Debug)]
+pub enum Packet {
+    Operator(OperatorPacket),
+}
+
+#[derive(Debug)]
+pub struct OperatorPacket {
+    version: u64,
+    type_id: u64,
+    packets: Vec<Packet>
+}
diff --git a/tests/crashes/122903-1.rs b/tests/crashes/122903-1.rs
new file mode 100644
index 0000000000000..9323c435851e6
--- /dev/null
+++ b/tests/crashes/122903-1.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #122903
+impl Struct {
+    async fn box_box_ref_Struct(
+        self: Box<Box<Self, impl FnMut(&mut Box<Box<Self, impl FnMut(&mut Self)>>)>>,
+    ) -> &u32 {
+        f
+    }
+}
diff --git a/tests/crashes/122903-2.rs b/tests/crashes/122903-2.rs
new file mode 100644
index 0000000000000..0d5d93014c187
--- /dev/null
+++ b/tests/crashes/122903-2.rs
@@ -0,0 +1,9 @@
+//@ known-bug: #122903
+
+impl Struct {
+    async fn box_box_ref_Struct(
+        self: Box<Box<Self, impl FnMut(&mut Box<Box<Self, impl FnMut(&mut Self)>>)>>
+    ) -> &u32 {
+        f
+    }
+}
diff --git a/tests/crashes/122904-2.rs b/tests/crashes/122904-2.rs
new file mode 100644
index 0000000000000..85ed91c2fa486
--- /dev/null
+++ b/tests/crashes/122904-2.rs
@@ -0,0 +1,15 @@
+//@ known-bug: #122904
+trait T {}
+
+type Alias<'a> = impl T;
+
+struct S;
+impl<'a> T for &'a S {}
+
+fn with_positive(fun: impl Fn(Alias<'_>)) {
+    with_positive(|&n| ());
+}
+
+fn main(Alias<'_>) {
+    with_positive(|&a| ());
+}
diff --git a/tests/crashes/122904.rs b/tests/crashes/122904.rs
new file mode 100644
index 0000000000000..8b8bb35d56c1e
--- /dev/null
+++ b/tests/crashes/122904.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #122904
+trait T {}
+
+type Alias<'a> = impl T;
+
+struct S;
+impl<'a> T for &'a S {}
+
+fn with_positive(fun: impl Fn(Alias<'_>)) {
+    with_positive(|&n| ());
+}
diff --git a/tests/crashes/122908.rs b/tests/crashes/122908.rs
new file mode 100644
index 0000000000000..c9da1bc187918
--- /dev/null
+++ b/tests/crashes/122908.rs
@@ -0,0 +1,4 @@
+//@ known-bug: #122908
+trait Trait<const module_path: Trait = bar> {
+    async fn handle<F>(slf: &F) {}
+}
diff --git a/tests/crashes/122909.rs b/tests/crashes/122909.rs
new file mode 100644
index 0000000000000..90bba772b915e
--- /dev/null
+++ b/tests/crashes/122909.rs
@@ -0,0 +1,15 @@
+//@ compile-flags: -Zpolymorphize=on -Zinline-mir=yes
+//@ known-bug: #122909
+
+
+use std::sync::{Arc, Context, Weak};
+
+pub struct WeakOnce<T>();
+impl<T> WeakOnce<T> {
+    extern "rust-call" fn try_get(&self) -> Option<Arc<T>> {}
+
+    pub fn get(&self) -> Arc<T> {
+        self.try_get()
+            .unwrap_or_else(|| panic!("Singleton {} not available", std::any::type_name::<T>()))
+    }
+}
diff --git a/tests/crashes/122914.rs b/tests/crashes/122914.rs
new file mode 100644
index 0000000000000..63a84bc8099bc
--- /dev/null
+++ b/tests/crashes/122914.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #122914
+use std::future::Future;
+use std::pin::Pin;
+
+impl<'a, F> Poll {
+    fn project<'_>(self: Pin<&'pin mut Future>) -> Projection<'pin, 'a, F> {
+        me.local_set.with(|| {
+            let _ = self.poll(cx);
+        })
+    }
+}
diff --git a/tests/crashes/122989.rs b/tests/crashes/122989.rs
new file mode 100644
index 0000000000000..70ad7d3b65c9b
--- /dev/null
+++ b/tests/crashes/122989.rs
@@ -0,0 +1,8 @@
+//@ known-bug: #122989
+trait Traitor<const N: N<2> = 1, const N: N<2> = N> {
+    fn N(&N) -> N<2> {
+        M
+    }
+}
+
+trait N<const N: Traitor<2> = 12> {}
diff --git a/tests/crashes/123077-2.rs b/tests/crashes/123077-2.rs
new file mode 100644
index 0000000000000..e086e330337ab
--- /dev/null
+++ b/tests/crashes/123077-2.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #123077
+//@ only-x86_64
+use std::arch::x86_64::{__m128, _mm_blend_ps};
+
+pub fn sse41_blend_noinline( ) -> __m128 {
+    let f = { |x, y| unsafe {
+        _mm_blend_ps(x, y, { |x, y| unsafe })
+    }};
+    f(x, y)
+}
+
+pub fn main() {}
diff --git a/tests/crashes/123134.rs b/tests/crashes/123134.rs
new file mode 100644
index 0000000000000..61c043db763f5
--- /dev/null
+++ b/tests/crashes/123134.rs
@@ -0,0 +1,39 @@
+//@ known-bug: #123134
+trait Api: Sized {
+    type Device: ?Sized;
+}
+
+struct OpenDevice<A: Api>
+where
+    A::Device: Sized,
+{
+    device: A::Device,
+    queue: (),
+}
+
+trait Adapter {
+    type A: Api;
+
+    fn open() -> OpenDevice<Self::A>
+    where
+        <Self::A as Api>::Device: Sized;
+}
+
+struct ApiS;
+
+impl Api for ApiS {
+    type Device = [u8];
+}
+
+impl<T> Adapter for T {
+    type A = ApiS;
+
+    fn open() -> OpenDevice<Self::A>
+    where
+        <Self::A as Api>::Device: Sized,
+    {
+        unreachable!()
+    }
+}
+
+pub fn main() {}
diff --git a/tests/crashes/123140.rs b/tests/crashes/123140.rs
new file mode 100644
index 0000000000000..89e55baad98f1
--- /dev/null
+++ b/tests/crashes/123140.rs
@@ -0,0 +1,6 @@
+//@ known-bug: #123140
+trait Project {
+    const SELF: Self;
+}
+
+fn take1(_: Project<SELF = { loop {} }>) {}
diff --git a/tests/crashes/123141-2.rs b/tests/crashes/123141-2.rs
new file mode 100644
index 0000000000000..74f961c2a3377
--- /dev/null
+++ b/tests/crashes/123141-2.rs
@@ -0,0 +1,23 @@
+//@ known-bug: #123141
+
+trait ConstChunksExactTrait<T> {
+    fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'_, T, {N}>;
+}
+
+impl <T> ConstChunksExactTrait<T> for [T] {}
+
+struct ConstChunksExact<'a, T: 'a, const N: usize> {}
+
+impl <'a, T: , const N: usize> Iterator for ConstChunksExact<'a, T, {rem}> {
+    type Item = &'a [T; N];
+}
+
+fn main() {
+    let slice = &[1i32, 2, 3, 4, 5, 6, 7, 7, 9, 1i32];
+
+    let mut iter = [[1, 2, 3], [4, 5, 6], [7, 8 ,9]].iter();
+
+    for a in slice.const_chunks_exact::<3>() {
+        assert_eq!(a, iter.next().unwrap());
+    }
+}
diff --git a/tests/crashes/123141.rs b/tests/crashes/123141.rs
new file mode 100644
index 0000000000000..99dfee7670ef9
--- /dev/null
+++ b/tests/crashes/123141.rs
@@ -0,0 +1,22 @@
+//@ known-bug: #123141
+trait ConstChunksExactTrait<T> {
+    fn const_chunks_exact<const N: usize>(&self) -> ConstChunksExact<'_, T, { N }>;
+}
+
+impl<T> ConstChunksExactTrait<T> for [T] {}
+
+struct ConstChunksExact<'a, T: 'a, const N: usize> {}
+
+impl<'a, T, const N: usize> Iterator for ConstChunksExact<'a, T, { rem }> {
+    type Item = &'a [T; N];
+}
+
+fn main() {
+    let slice = &[1i32, 2, 3, 4, 5, 6, 7, 7, 9, 1i32];
+
+    let mut iter = [[1, 2, 3], [4, 5, 6], [7, 8, 9]].iter();
+
+    for a in slice.const_chunks_exact::<3>() {
+        assert_eq!(a, iter.next().unwrap());
+    }
+}
diff --git a/tests/crashes/123153.rs b/tests/crashes/123153.rs
new file mode 100644
index 0000000000000..d2c32ecd73e74
--- /dev/null
+++ b/tests/crashes/123153.rs
@@ -0,0 +1,17 @@
+//@ known-bug: #123153
+pub struct wl_interface {
+    pub version: str,
+}
+
+pub struct Interface {
+    pub other_interfaces: &'static [&'static Interface],
+    pub c_ptr: Option<&'static wl_interface>,
+}
+
+pub static mut wl_callback_interface: wl_interface = wl_interface { version: 0 };
+
+pub static WL_CALLBACK_INTERFACE: Interface =
+    Interface { other_interfaces: &[], c_ptr: Some(unsafe { &wl_callback_interface }) };
+
+
+fn main() {}
diff --git a/tests/crashes/123154.rs b/tests/crashes/123154.rs
new file mode 100644
index 0000000000000..510ae8adf350d
--- /dev/null
+++ b/tests/crashes/123154.rs
@@ -0,0 +1,12 @@
+//@ known-bug: #123154
+struct AA {
+    pub data: [&usize]
+}
+
+impl AA {
+    const fn new() -> Self { }
+}
+
+static AA = AA::new();
+
+fn main() { }
diff --git a/tests/crashes/123157.rs b/tests/crashes/123157.rs
new file mode 100644
index 0000000000000..d6cc55ba0524e
--- /dev/null
+++ b/tests/crashes/123157.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #123157
+//@ edition:2021
+#![feature(type_alias_impl_trait)]
+
+#[derive(Copy, Clone)]
+struct Foo((u32, u32));
+
+fn main() {
+    type T = impl Copy;
+    let foo: T = Foo((1u32, 2u32));
+    let x = move || {
+        let x = move || {
+        let Foo((a, b)) = foo;
+    };
+    };
+}
diff --git a/tests/crashes/23707.rs b/tests/crashes/23707.rs
new file mode 100644
index 0000000000000..4105933c60f4b
--- /dev/null
+++ b/tests/crashes/23707.rs
@@ -0,0 +1,109 @@
+//@ known-bug: #23707
+//@ compile-flags: -Copt-level=0 --edition=2021
+//@ only-x86_64
+#![recursion_limit="2048"]
+
+use std::marker::PhantomData;
+use std::fmt;
+use std::fmt::Debug;
+
+pub struct Z( () );
+pub struct S<T> (PhantomData<T>);
+
+
+pub trait Nat {
+    fn sing() -> Self;
+    fn get(&self) -> usize;
+}
+
+impl Nat for Z {
+    fn sing() -> Z { Z( () ) }
+    #[inline(always)]
+    fn get(&self) -> usize {
+        0
+    }
+}
+
+impl<T : Nat> Nat for S<T> {
+    fn sing() -> S<T> { S::<T>( PhantomData::<T> ) }
+    #[inline(always)]
+    fn get(&self) -> usize {
+        let prd : T = Nat::sing();
+        1 + prd.get()
+    }
+}
+
+pub type N0 = Z;
+pub type N1 = S<N0>;
+pub type N2 = S<N1>;
+pub type N3 = S<N2>;
+pub type N4 = S<N3>;
+pub type N5 = S<N4>;
+
+
+pub struct Node<D : Nat>(usize,PhantomData<D>);
+
+impl<D:Nat> Node<D> {
+    pub fn push(&self, c : usize) -> Node<S<D>> {
+        let Node(i,_) = *self;
+        Node(10*i+c, PhantomData::<S<D>>)
+    }
+}
+
+impl<D:Nat> Node<S<D>> {
+    pub fn pop(&self) -> (Node<D>,usize) {
+        let Node(i,_) = *self;
+        (Node(i/10, PhantomData::<D>), i-10*(i/10))
+    }
+}
+
+impl<D:Nat> Debug for Node<D> {
+    fn fmt(&self, f : &mut fmt::Formatter) -> fmt::Result {
+        let s : D = Nat::sing();
+        write!(f, "Node<{}>: i= {}",
+               s.get(), self.0)
+    }
+}
+pub trait Step {
+    fn step(&self, usize) -> Self;
+}
+
+impl Step for Node<N0> {
+    #[inline(always)]
+    fn step(&self, n : usize) -> Node<N0> {
+        println!("base case");
+        Node(n,PhantomData::<N0>)
+    }
+}
+
+impl<D:Nat> Step for Node<S<D>>
+    where Node<D> : Step {
+        #[inline(always)]
+        fn step(&self, n : usize) -> Node<S<D>> {
+            println!("rec");
+            let (par,c) = self.pop();
+            let cnew = c+n;
+            par.step(c).push(cnew)
+        }
+
+}
+
+fn tst<D:Nat>(ref p : &Node<D>, c : usize) -> usize
+    where Node<D> : Step {
+        let Node(i,_) = p.step(c);
+        i
+}
+
+
+
+fn main() {
+    let nd : Node<N3> = Node(555,PhantomData::<N3>);
+
+    // overflow...core::marker::Size
+    let Node(g,_) = tst(nd,1);
+
+    // ok
+    //let Node(g,_) = nd.step(1);
+
+    println!("{:?}", g);
+}
diff --git a/tests/crashes/34127.rs b/tests/crashes/34127.rs
new file mode 100644
index 0000000000000..88a2cf30ec5d5
--- /dev/null
+++ b/tests/crashes/34127.rs
@@ -0,0 +1,7 @@
+//@ compile-flags: -g -Copt-level=0
+//@ known-bug: #34127
+//@ only-x86_64
+
+pub fn main() {
+let _a = [(); 1 << 63];
+}
diff --git a/tests/crashes/54888.rs b/tests/crashes/54888.rs
new file mode 100644
index 0000000000000..2c87d7ee9e4c8
--- /dev/null
+++ b/tests/crashes/54888.rs
@@ -0,0 +1,21 @@
+//@ known-bug: #54888
+
+#![feature(unsize, coerce_unsized)]
+
+use std::{
+    ops::CoerceUnsized,
+    marker::Unsize,
+};
+
+#[repr(C)]
+struct Ptr<T: ?Sized>(Box<T>);
+
+impl<T: ?Sized, U: ?Sized> CoerceUnsized<Ptr<U>> for Ptr<T>
+where
+    T: Unsize<U>,
+{}
+
+
+fn main() {
+    let foo = Ptr(Box::new(5)) as Ptr<dyn std::any::Any>;
+}
diff --git a/tests/crashes/57276.rs b/tests/crashes/57276.rs
new file mode 100644
index 0000000000000..f70be4fba6d8b
--- /dev/null
+++ b/tests/crashes/57276.rs
@@ -0,0 +1,11 @@
+//@ known-bug: #57276
+
+#![feature(arbitrary_self_types, dispatch_from_dyn)]
+
+use std::ops::{Deref, DispatchFromDyn};
+
+trait Trait<T: Deref<Target = Self> + DispatchFromDyn<T>> {
+    fn foo(self: T) -> dyn Trait<T>;
+}
+
+fn main() {}
diff --git a/tests/crashes/74299.rs b/tests/crashes/74299.rs
new file mode 100644
index 0000000000000..0e2ddce1c5b11
--- /dev/null
+++ b/tests/crashes/74299.rs
@@ -0,0 +1,24 @@
+//@ known-bug: #74299
+#![feature(specialization)]
+
+trait X {
+    type U;
+    fn f(&self) -> Self::U {
+        loop {}
+    }
+}
+
+impl<T> X for T {
+    default type U = ();
+}
+
+trait Y {
+    fn g(&self) {}
+}
+
+impl Y for <() as X>::U {}
+impl Y for <i32 as X>::U {}
+
+fn main() {
+    ().f().g();
+}
diff --git a/tests/crashes/74451.rs b/tests/crashes/74451.rs
new file mode 100644
index 0000000000000..8f93699467896
--- /dev/null
+++ b/tests/crashes/74451.rs
@@ -0,0 +1,42 @@
+//@ known-bug: #74451
+//@ compile-flags: -Copt-level=0
+
+#![feature(specialization)]
+#![feature(unsize, coerce_unsized)]
+#![allow(incomplete_features)]
+#![crate_type = "lib"]
+
+use std::ops::CoerceUnsized;
+
+pub struct SmartassPtr<A: Smartass+?Sized>(A::Data);
+
+pub trait Smartass {
+    type Data;
+    type Data2: CoerceUnsized<*const [u8]>;
+}
+
+pub trait MaybeObjectSafe {}
+
+impl MaybeObjectSafe for () {}
+
+impl<T> Smartass for T {
+    type Data = <Self as Smartass>::Data2;
+    default type Data2 = *const [u8; 0];
+}
+
+impl Smartass for () {
+    type Data2 = *const [u8; 1];
+}
+
+impl Smartass for dyn MaybeObjectSafe {
+    type Data = *const [u8];
+    type Data2 = *const [u8; 0];
+}
+
+impl<U: Smartass+?Sized, T: Smartass+?Sized> CoerceUnsized<SmartassPtr<T>> for SmartassPtr<U>
+    where <U as Smartass>::Data: std::ops::CoerceUnsized<<T as Smartass>::Data>
+{}
+
+pub fn conv(s: SmartassPtr<()>) -> SmartassPtr<dyn MaybeObjectSafe> {
+    s // This shouldn't coerce
+}
diff --git a/tests/crashes/79409.rs b/tests/crashes/79409.rs
new file mode 100644
index 0000000000000..98b5f60633627
--- /dev/null
+++ b/tests/crashes/79409.rs
@@ -0,0 +1,16 @@
+//@ known-bug: #79409
+
+#![feature(extern_types)]
+#![feature(unsized_locals)]
+
+extern {
+    type Device;
+}
+
+unsafe fn make_device() -> Box<Device> {
+    Box::from_raw(0 as *mut _)
+}
+
+fn main() {
+    let d: Device = unsafe { *make_device() };
+}
diff --git a/tests/crashes/79590.rs b/tests/crashes/79590.rs
new file mode 100644
index 0000000000000..b73864cce2349
--- /dev/null
+++ b/tests/crashes/79590.rs
@@ -0,0 +1,19 @@
+//@ known-bug: #79590
+
+trait Database: Restriction<Inner = u32> {}
+
+trait Restriction {
+    type Inner;
+}
+
+struct Test {}
+
+impl Database for Test {}
+impl Restriction for Test {
+    type Inner = u32;
+}
+
+fn main() {
+    let t = Test {};
+    let x: &dyn Database<Inner = _> = &t;
+}
diff --git a/tests/crashes/87577.rs b/tests/crashes/87577.rs
new file mode 100644
index 0000000000000..c632b72c1474a
--- /dev/null
+++ b/tests/crashes/87577.rs
@@ -0,0 +1,4 @@
+//@ known-bug: #87577
+
+#[derive(Debug)]
+struct S<#[cfg(feature = "alloc")] N: A<T>> {}
diff --git a/tests/crashes/88296.rs b/tests/crashes/88296.rs
new file mode 100644
index 0000000000000..999834f5bdecd
--- /dev/null
+++ b/tests/crashes/88296.rs
@@ -0,0 +1,27 @@
+//@ known-bug: #88296
+
+#![feature(specialization)]
+
+trait Foo {
+    type Bar;
+}
+
+impl<T> Foo for T {
+    default type Bar = u32;
+}
+
+impl Foo for i32 {
+    type Bar = i32;
+}
+
+extern "C" {
+    #[allow(unused)]
+    // OK as Foo::Bar is explicitly defined for i32
+    static OK: <i32 as Foo>::Bar;
+
+    #[allow(unused)]
+    // ICE in the improper_ctypes lint
+    //  as Foo::Bar is only default implemented for ()
+    static ICE: <() as Foo>::Bar;
+}
+pub fn main()  {}
diff --git a/tests/crashes/90110.rs b/tests/crashes/90110.rs
new file mode 100644
index 0000000000000..a27a1f42b7af3
--- /dev/null
+++ b/tests/crashes/90110.rs
@@ -0,0 +1,57 @@
+//@ known-bug: #90110
+
+use std::fs::File;
+use std::io::{BufReader, BufRead};
+use std::str::Split;
+use std::path::Path;
+
+pub trait Parser<D>
+where dyn Parser<D>: Sized
+{
+    fn new(split_header: Split<&str>) -> Self where Self: Sized;
+    fn parse_line(&self, split_line: &Split<&str>) -> D;
+}
+
+
+pub struct CsvReader<D> {
+    parser: Box<dyn Parser<D>>,
+
+    reader: BufReader<File>,
+    buf: String,    // Buffer we will read into. Avoids re-allocation on each line.
+    path: String,   // Record this so we can return more informative error messages.
+    line: usize,    // Same motivation for this.
+}
+
+impl<D> CsvReader<D>
+where dyn Parser<D>: Sized
+{
+    fn new<F>(path: &str, make_parser: F) -> CsvReader<D>
+    where F: Fn(Split<char>) -> dyn Parser<D> {
+        let file = match File::open(Path::new(path)) {
+            Err(err) => panic!("Couldn't read {}: {}", path, err),
+            Ok(file) => file,
+        };
+
+        let mut reader = BufReader::new(file);
+
+        let mut buf = String::new();
+
+        let parser = Box::new(match reader.read_line(&mut buf) {
+            Err(err) => panic!("Failed to read the header line from {}: {}", path, err),
+            Ok(_) => {
+                let split_header = buf.split(',');
+                make_parser(split_header)
+            },
+        });
+
+        CsvReader {
+            parser: parser,
+            reader,
+            buf,
+            path: path.to_string(),
+            line: 2,
+        }
+    }
+}
+
+pub fn main() {}
diff --git a/tests/crashes/91985.rs b/tests/crashes/91985.rs
new file mode 100644
index 0000000000000..338550430e1f8
--- /dev/null
+++ b/tests/crashes/91985.rs
@@ -0,0 +1,42 @@
+//@ known-bug: #91985
+
+#![feature(generic_associated_types)]
+
+pub trait Trait1 {
+    type Associated: Ord;
+}
+
+pub trait Trait2 {
+    type Associated: Clone;
+}
+
+pub trait GatTrait {
+    type Gat<T: Clone>;
+}
+
+pub struct GatStruct;
+
+impl GatTrait for GatStruct {
+    type Gat<T: Clone> = Box<T>;
+}
+
+pub struct OuterStruct<T1: Trait1, T2: Trait2> {
+    inner: InnerStruct<T2, GatStruct>,
+    t1:    T1,
+}
+
+pub struct InnerStruct<T: Trait2, G: GatTrait> {
+    pub gat: G::Gat<T::Associated>,
+}
+
+impl<T1, T2> OuterStruct<T1, T2>
+where
+    T1: Trait1,
+    T2: Trait2<Associated = T1::Associated>,
+{
+    pub fn new() -> Self {
+        todo!()
+    }
+}
+
+pub fn main() {}
diff --git a/tests/crashes/92004.rs b/tests/crashes/92004.rs
new file mode 100644
index 0000000000000..bc2ca2a7ba389
--- /dev/null
+++ b/tests/crashes/92004.rs
@@ -0,0 +1,70 @@
+//@ known-bug: #102310
+//@ compile-flags: -Copt-level=0
+//@ edition:2021
+// ignore-tidy-linelength
+
+use std::vec::Vec;
+use std::iter::Peekable;
+
+pub fn main() {
+    let packet = decode(vec![1,0,1,0]);
+}
+
+pub fn decode(bitstream: Vec<u64>) -> Packet {
+    let mut bitstream_itr = bitstream.into_iter().peekable();
+    return match decode_packet(&mut bitstream_itr) {
+        Some(p) => p,
+        None    => panic!("expected outer packet"),
+    }
+}
+
+pub fn decode_packets<I: Iterator<Item = u64>>(itr: &mut Peekable<I>) -> Vec<Packet> {
+    let mut res = Vec::new();
+    loop {
+        match decode_packet(itr) {
+            Some(p) => { res.push(p); },
+            None    => break
+        }
+    }
+
+    return res;
+}
+
+pub fn decode_packet<I: Iterator<Item = u64>>(itr: &mut Peekable<I>) -> Option<Packet> {
+    // get version digits
+    let version = extend_number(0, itr, 3)?;
+    let type_id = extend_number(0, itr, 3)?;
+    return operator_packet(version, type_id, itr);
+}
+
+pub fn operator_packet<I: Iterator<Item = u64>>(version: u64, type_id: u64, itr: &mut Peekable<I>) -> Option<Packet> {
+    let p = OperatorPacket {
+        version: version,
+        type_id: type_id,
+        packets: decode_packets(&mut itr.take(0).peekable()),
+    };
+
+    return Some(Packet::Operator(p));
+}
+
+pub fn extend_number<I: Iterator<Item = u64>>(num: u64, itr: &mut Peekable<I>, take: u64) -> Option<u64> {
+    let mut value = num;
+    for _ in 0..take {
+        value *= 2;
+        value += itr.next()?;
+    }
+
+    return Some(value);
+}
+
+#[derive(Debug)]
+pub enum Packet {
+    Operator(OperatorPacket),
+}
+
+#[derive(Debug)]
+pub struct OperatorPacket {
+    version: u64,
+    type_id: u64,
+    packets: Vec<Packet>
+}
diff --git a/tests/crashes/93182.rs b/tests/crashes/93182.rs
new file mode 100644
index 0000000000000..f2e77c03533fa
--- /dev/null
+++ b/tests/crashes/93182.rs
@@ -0,0 +1,29 @@
+//@ known-bug: #93182
+#![feature(generic_const_exprs)]
+
+// this causes an ICE!!!
+pub const CONST: usize = 64;
+pub trait Tr<const S: usize = CONST>: Foo<A<S>> {}
+
+// no ICE
+// pub trait Digest<const S: usize = 64>: FromH<[u8; S]> {}
+
+struct St ();
+
+struct A<const S: usize> ([u8; S]);
+
+pub trait Foo<T> {
+    fn foo(_: T);
+}
+
+impl<const S: usize> Foo<A<S>> for St {
+    fn foo(_: A<S>) {
+        todo!()
+    }
+}
+
+pub trait FooBar {
+    type Tr: Tr;
+}
+
+pub fn main() {}
diff --git a/tests/crashes/93237.rs b/tests/crashes/93237.rs
new file mode 100644
index 0000000000000..c903e79a2e300
--- /dev/null
+++ b/tests/crashes/93237.rs
@@ -0,0 +1,18 @@
+//@ known-bug: #93237
+trait Trait {
+    type Assoc;
+}
+impl Trait for () {
+    type Assoc = ();
+}
+
+macro_rules! m {
+    ([#$($t:tt)*] [$($open:tt)*] [$($close:tt)*]) => {
+        m!{[$($t)*][$($open)*$($open)*][$($close)*$($close)*]}
+    };
+    ([] [$($open:tt)*] [$($close:tt)*]) => {
+        fn _f() -> $($open)*()$($close)* {}
+    };
+}
+
+m! {[###########][impl Trait<Assoc =][>]}
diff --git a/tests/crashes/94846.rs b/tests/crashes/94846.rs
new file mode 100644
index 0000000000000..9a3b26621d988
--- /dev/null
+++ b/tests/crashes/94846.rs
@@ -0,0 +1,6 @@
+//@ known-bug: #94846
+#![feature(generic_const_exprs)]
+
+struct S<const C:() = {}>() where S<{}>:;
+
+pub fn main() {}
diff --git a/tests/crashes/95134.rs b/tests/crashes/95134.rs
new file mode 100644
index 0000000000000..bcd88b1076fd9
--- /dev/null
+++ b/tests/crashes/95134.rs
@@ -0,0 +1,27 @@
+//@ known-bug: #95134
+//@ compile-flags: -Copt-level=0
+
+pub fn encode_num<Writer: ExampleWriter>(n: u32, mut writer: Writer) -> Result<(), Writer::Error> {
+    if n > 15 {
+        encode_num(n / 16, &mut writer)?;
+    }
+    Ok(())
+}
+
+pub trait ExampleWriter {
+    type Error;
+}
+
+impl<'a, T: ExampleWriter> ExampleWriter for &'a mut T {
+    type Error = T::Error;
+}
+
+struct EmptyWriter;
+
+impl ExampleWriter for EmptyWriter {
+    type Error = ();
+}
+
+fn main() {
+    encode_num(69, &mut EmptyWriter).unwrap();
+}
diff --git a/tests/crashes/96304.rs b/tests/crashes/96304.rs
new file mode 100644
index 0000000000000..637012f45858f
--- /dev/null
+++ b/tests/crashes/96304.rs
@@ -0,0 +1,6 @@
+//@ known-bug: #96304
+
+#![feature(asm_sym)]
+core::arch::global_asm!("/* {} */", sym<&'static ()>::clone);
+
+pub fn main() {}
diff --git a/tests/crashes/97501.rs b/tests/crashes/97501.rs
new file mode 100644
index 0000000000000..51a83d8be169d
--- /dev/null
+++ b/tests/crashes/97501.rs
@@ -0,0 +1,22 @@
+//@ known-bug: #97501
+
+#![feature(core_intrinsics)]
+use std::intrinsics::wrapping_add;
+
+#[derive(Clone, Copy)]
+struct WrapInt8 {
+    value: u8
+}
+
+impl std::ops::Add for WrapInt8 {
+    type Output = WrapInt8;
+    fn add(self, other: WrapInt8) -> WrapInt8 {
+        wrapping_add(self, other)
+    }
+}
+
+fn main() {
+    let p = WrapInt8 { value: 123 };
+    let q = WrapInt8 { value: 234 };
+    println!("{}", (p + q).value);
+}
diff --git a/tests/crashes/98322.rs b/tests/crashes/98322.rs
new file mode 100644
index 0000000000000..57b349160294b
--- /dev/null
+++ b/tests/crashes/98322.rs
@@ -0,0 +1,37 @@
+//@ known-bug: #98322
+
+#![feature(generic_const_exprs)]
+
+// Main function seems irrelevant
+fn main() {}
+
+// Constant must be provided via an associated constant in a trait
+pub trait ConstTrait {
+    const ASSOC_CONST: usize;
+}
+
+// For some reason I find it's necessary to have an implementation of this trait that recurses
+pub trait OtherTrait
+{
+    fn comm(self);
+}
+
+// There must be a blanket impl here
+impl<T> OtherTrait for T where
+    T: ConstTrait,
+    [();T::ASSOC_CONST]: Sized,
+{
+    fn comm(self) {
+        todo!()
+    }
+}
+
+// The struct must be recursive
+pub struct RecursiveStruct(Box<RecursiveStruct>);
+
+// This implementation must exist, and it must recurse into its child
+impl OtherTrait for RecursiveStruct {
+    fn comm(self) {
+        (self.0).comm();
+    }
+}
diff --git a/tests/crashes/README.md b/tests/crashes/README.md
new file mode 100644
index 0000000000000..dee11e2a3dd0f
--- /dev/null
+++ b/tests/crashes/README.md
@@ -0,0 +1,16 @@
+This is serves as a collection of crashes so that accidental ICE fixes are tracked.
+This was formally done at https://github.com/rust-lang/glacier but doing it inside
+the rustc testsuite is more convenient.
+
+It is imperative that a test in the suite causes an internal compiler error/panic
+or makes rustc crash in some other way.
+A test will "pass" if rustc exits with something other than 1 or 0.
+
+When adding crashes from https://github.com/rust-lang/rust/issues, the
+issue number should be noted in the file name (12345.rs should suffice)
+and perhaps also inside the file via `//@ known-bug #4321`
+
+If you happen to fix one of the crashes, please move it to a fitting
+subdirectory in `tests/ui` and give it a meaningful name.
+Also please add a doc comment at the top of the file explaining why
+this test exists. :)