Add some ICEs

ices/80561.rs

@@ -0,0 +1,21 @@
+#![feature(const_generics)]
+#![feature(const_evaluatable_checked)]
+pub struct SimpleStruct<const N: usize>([u8; N]);
+
+impl<const N: usize> SimpleStruct<N> {
+    pub fn new() -> Self {
+        loop {}
+    }
+}
+
+pub trait TraitA {
+    const SIZE: usize;
+    fn zero()
+    where
+        [(); Self::SIZE]: ,
+    {
+        let _ = SimpleStruct::<{ Self::SIZE }>::new();
+    }
+}
+
+fn main() {}

ices/81193.rs

@@ -0,0 +1,8 @@
+#![feature(associated_type_bounds)]
+trait A<'a, 'b> {}
+trait B<'a, 'b, 'c> {}
+fn err<'u, 'a, F>()
+where
+    for<'b> F: Iterator<Item: for<'c> B<'a, 'b, 'c> + for<'c> A<'a, 'c>>,
+{
+}

ices/81246.rs

@@ -0,0 +1,9 @@
+#![feature(allocator_api)]
+
+fn ice() -> Box<(), &'static std::alloc::Global> {
+    todo!()
+}
+
+fn main() {
+    ice();
+}

ices/81270.rs

@@ -0,0 +1,18 @@
+#![feature(allocator_api)]
+use std::alloc::{Layout, Allocator, Global, AllocError};
+use std::ptr::NonNull;
+use std::marker::PhantomData;
+
+struct S<A>{ a: PhantomData<A>, b: [u8; 1] }
+unsafe impl<A> Allocator for S<A> {
+    fn allocate(&self, _: Layout) -> Result<NonNull<[u8]>, AllocError> {
+        todo!();
+    }
+    unsafe fn deallocate(&self, _: NonNull<u8>, _: Layout) {
+        todo!();
+    }
+}
+
+fn main() {
+    let x: Box<u8, S<u8>> = Box::new_in(0, S { a: PhantomData, b: [0; 1] });
+}

ices/81403.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+rustc --emit=mir -Zmir-opt-level=2 - <<'EOF'
+// build-pass
+pub trait Foo<'a> {
+    type Bar;
+    fn foo(&'a self) -> Self::Bar;
+}
+
+impl<'a, 'b, T: 'a> Foo<'a> for &'b T {
+    type Bar = &'a T;
+    fn foo(&'a self) -> &'a T {
+        self
+    }
+}
+
+pub fn uncallable<T, F>(x: T, f: F)
+    where T: for<'a> Foo<'a>,
+          F: for<'a> Fn(<T as Foo<'a>>::Bar)
+{
+    f(x.foo());
+}
+
+pub fn broken<F: Fn(&i32)>(x: &i32, f: F) {
+    uncallable(x, |y| f(y));
+}
+
+fn main() { }
+EOF