diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index e3dde89aefc..1980980b6d0 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 e3b27600c5e..224f5350e40 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 78246136f2a..aa69791b3b4 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 e6f4accfd7b..f78e0363f55 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 1624e2a6084..c8a8b79921e 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 5212f1430d8..38d22fef113 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 8a8f98a5eda..46b0a543802 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 00000000000..a62556f762b
--- /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 57436e8d7fe..23f303276aa 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 93be4d61a9a..77691815830 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 00000000000..4d113cbe9ed
--- /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 00000000000..72334985820
--- /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 00000000000..a0290361ed1
--- /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 00000000000..b6a78ce053a
--- /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 00000000000..61976f51273
--- /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 00000000000..200782f95c8
--- /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 00000000000..39c2d72bd35
--- /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 00000000000..dd44a0f1d77
--- /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 00000000000..368595c6a2a
--- /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 00000000000..a97f36d1987
--- /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 00000000000..ffd1a493e46
--- /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 00000000000..b0a129cac01
--- /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 00000000000..c8db848f2e1
--- /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 00000000000..73ff1007094
--- /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 00000000000..93de62d4139
--- /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 00000000000..240ff6c2704
--- /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 00000000000..752682fa605
--- /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 00000000000..f17f6f0781f
--- /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 00000000000..3a1a13df198
--- /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 00000000000..5ba17c2aa1a
--- /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 00000000000..6c4fb9f28c7
--- /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 00000000000..eef375b8924
--- /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 00000000000..fda2a96836f
--- /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 00000000000..fa72b28c228
--- /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 00000000000..5d363403b8a
--- /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 00000000000..d161575c657
--- /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 00000000000..86677f416fe
--- /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 00000000000..7163cbc3934
--- /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 00000000000..0e5afb4da61
--- /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 00000000000..a430c1b40d3
--- /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 00000000000..8642dbe8e71
--- /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 00000000000..09fd2beeba8
--- /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 00000000000..eca27febb96
--- /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 00000000000..e347327e738
--- /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 00000000000..9d90c153624
--- /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 00000000000..406371f12e4
--- /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 00000000000..c6e749867e8
--- /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 00000000000..79196ac9c65
--- /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 00000000000..cb96c80d79b
--- /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 00000000000..e1abbbcd4c1
--- /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 00000000000..0824a72be19
--- /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 00000000000..b87a478e6f2
--- /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 00000000000..34f0522369e
--- /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 00000000000..632ce8b9dee
--- /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 00000000000..95fdf63f893
--- /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 00000000000..1e85646cf83
--- /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 00000000000..d8b5f328545
--- /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 00000000000..dfca3917785
--- /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 00000000000..9c2a68d3a91
--- /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 00000000000..3f0dd2f9bf4
--- /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 00000000000..ecfd3148569
--- /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 00000000000..7544b5ec0fc
--- /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 00000000000..6fdfc689250
--- /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 00000000000..a346e84c78f
--- /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 00000000000..093c58e1c05
--- /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 00000000000..21ab15f9ffd
--- /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 00000000000..cde2cf35305
--- /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 00000000000..469b1e8e905
--- /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 00000000000..cd873703284
--- /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 00000000000..4382a7bcb63
--- /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 00000000000..4382a7bcb63
--- /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 00000000000..02e2cfd09e2
--- /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 00000000000..c8c10546d94
--- /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 00000000000..2e230f98d81
--- /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 00000000000..f655ea1cd34
--- /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 00000000000..5f681bb8da8
--- /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 00000000000..9cdc4417f5b
--- /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 00000000000..d7cba0f51c4
--- /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 00000000000..22746548e02
--- /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 00000000000..ed07c58e89f
--- /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 00000000000..9a41abe6920
--- /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 00000000000..ca79664d8b7
--- /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 00000000000..d51cd5f49a3
--- /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 00000000000..71becc04e16
--- /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 00000000000..01c4f43e8fd
--- /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 00000000000..9c4a3a50293
--- /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 00000000000..f18347a006c
--- /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 00000000000..6cbc2009c5f
--- /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 00000000000..28f1e3dfd94
--- /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 00000000000..aa1785eea84
--- /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 00000000000..1be51a8da16
--- /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 00000000000..0ce5e4df224
--- /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 00000000000..7e9166a50e5
--- /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 00000000000..45bc0bd457b
--- /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 00000000000..9bd2bf68142
--- /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 00000000000..5d16b06db23
--- /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 00000000000..65c6028e03e
--- /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 00000000000..2ebe91f02de
--- /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 00000000000..36397d4ec3c
--- /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 00000000000..6da6426a86d
--- /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 00000000000..2c6327a8808
--- /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 00000000000..cd7583a7faf
--- /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 00000000000..be5e0c0df57
--- /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 00000000000..ef7b16579dd
--- /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 00000000000..5d7ef6e8ce9
--- /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 00000000000..09bd343e0ba
--- /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 00000000000..a6373a58c42
--- /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 00000000000..000e7cb15eb
--- /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 00000000000..a08f3f06397
--- /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 00000000000..53eec829c5f
--- /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 00000000000..f0ce26c6f95
--- /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 00000000000..2a4638efcab
--- /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 00000000000..99cc8f79195
--- /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 00000000000..ddc4f37c96a
--- /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 00000000000..ec9ba82a68c
--- /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 00000000000..3c01a7f452c
--- /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 00000000000..d1b8c447bf7
--- /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 00000000000..6035c9d9b15
--- /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 00000000000..a5569ea19d3
--- /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 00000000000..cb80c081cff
--- /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 00000000000..7d5bae37f84
--- /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 00000000000..74b4649cc9d
--- /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 00000000000..74b4649cc9d
--- /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 00000000000..c2ee8716f53
--- /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 00000000000..4c1d0de5719
--- /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 00000000000..87d393a4532
--- /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 00000000000..232ce5d4413
--- /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 00000000000..29566941e22
--- /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 00000000000..ea0e843a10c
--- /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 00000000000..af0fc5bbd50
--- /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 00000000000..7dae276950e
--- /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 00000000000..d6c07be8318
--- /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 00000000000..16911fd522f
--- /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 00000000000..83b60444c2f
--- /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 00000000000..ec22b331ad9
--- /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 00000000000..9323c435851
--- /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 00000000000..0d5d93014c1
--- /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 00000000000..85ed91c2fa4
--- /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 00000000000..8b8bb35d56c
--- /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 00000000000..c9da1bc1879
--- /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 00000000000..90bba772b91
--- /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 00000000000..63a84bc8099
--- /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 00000000000..70ad7d3b65c
--- /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 00000000000..e086e330337
--- /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 00000000000..61c043db763
--- /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 00000000000..89e55baad98
--- /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 00000000000..74f961c2a33
--- /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 00000000000..99dfee7670e
--- /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 00000000000..d2c32ecd73e
--- /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 00000000000..510ae8adf35
--- /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 00000000000..d6cc55ba052
--- /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 00000000000..4105933c60f
--- /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 00000000000..88a2cf30ec5
--- /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 00000000000..2c87d7ee9e4
--- /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 00000000000..f70be4fba6d
--- /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 00000000000..0e2ddce1c5b
--- /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 00000000000..8f936994678
--- /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 00000000000..98b5f606336
--- /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 00000000000..b73864cce23
--- /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 00000000000..c632b72c147
--- /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 00000000000..999834f5bde
--- /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 00000000000..a27a1f42b7a
--- /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 00000000000..338550430e1
--- /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 00000000000..bc2ca2a7ba3
--- /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 00000000000..f2e77c03533
--- /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 00000000000..c903e79a2e3
--- /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 00000000000..9a3b26621d9
--- /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 00000000000..bcd88b1076f
--- /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 00000000000..637012f4585
--- /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 00000000000..51a83d8be16
--- /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 00000000000..57b34916029
--- /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 00000000000..dee11e2a3dd
--- /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. :)