add .rs crashes from https://github.com/rust-lang/glacier

Author: matthiaskrgr

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() {}

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);
+}

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, _>();
+}

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() {}

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() {}

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>>());
+}

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>>());
+}

tests/crashes/105488.rs

@@ -0,0 +1,39 @@
+//@ known-bug: #105488
+
+pub trait MyFnOnce {
+    type Output;
+
+    fn call_my_fn_once(self) -> Self::Output;
+}
+
+pub struct WrapFnOnce<F>(F);
+
+impl<F: FnOnce() -> D, D: MyFnOnce> MyFnOnce for WrapFnOnce<F> {
+    type Output = D::Output;
+
+    fn call_my_fn_once(self) -> Self::Output {
+        D::call_my_fn_once(self.0())
+    }
+}
+
+impl<F: FnOnce() -> D, D: MyFnOnce> MyFnOnce for F {
+    type Output = D::Output;
+
+    fn call_my_fn_once(self) -> Self::Output {
+        D::call_my_fn_once(self())
+    }
+}
+
+pub fn my_fn_1() -> impl MyFnOnce {
+    my_fn_2
+}
+
+pub fn my_fn_2() -> impl MyFnOnce {
+    WrapFnOnce(my_fn_1)
+}
+
+fn main() {
+    let v = my_fn_1();
+
+    let _ = v.call_my_fn_once();
+}

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)
+}

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() {}