Add some ICEs

ices/106238.rs

@@ -0,0 +1,13 @@
+#![feature(trait_alias)]
+use core::ops::Add;
+
+pub trait DoSome<T> {}
+
+// Trait alias causes compiler panic
+pub trait Cell<T: Add<T, Output=T>> = DoSome<T>;
+
+struct _Container<T> {
+    pub cells: dyn Cell<T>,
+}
+
+fn main() {}

ices/107409.rs

@@ -0,0 +1,25 @@
+use std::marker::PhantomData as Boo;
+
+struct Gc<'gc, T: 'gc>(Boo<fn(&'gc T) -> &'gc T>);
+
+trait Rootable<'env> {
+    type AsRoot<'r>: Rootable<'r> + 'r
+    where
+        'env: 'r;
+}
+
+impl<'env, T: Rootable<'env>> Rootable<'env> for Gc<'env, T> {
+    type AsRoot<'r> = Gc<'r, T::AsRoot<'r>> where 'env: 'r;
+}
+
+impl<'env> Rootable<'env> for i32 {
+    type AsRoot<'r> = i32 where 'env: 'r;
+}
+
+fn reroot<'gc, T: Rootable<'gc>>(_t: T, _f: for<'a> fn(T::AsRoot<'a>)) {}
+
+fn test<'gc>(t: Gc<'gc, i32>) {
+    reroot(t, |_| ());
+}
+
+fn main() {}

ices/108399.rs

@@ -0,0 +1,22 @@
+#![feature(type_alias_impl_trait)]
+
+use std::future::Future;
+
+type FutNothing<'a> = impl 'a + Future<Output = ()>;
+
+async fn operation(x: &mut ()) -> () {
+    ()
+}
+
+async fn indirect() {
+    call(operation).await
+}
+
+async fn call<F>(mut f: F)
+where
+    for<'any> F: FnMut(&'any mut ()) -> FutNothing<'any>,
+{
+    f(&mut ()).await
+}
+
+fn main() {}

ices/108498.rs

@@ -0,0 +1,15 @@
+#![feature(type_alias_impl_trait)]
+type Opaque = impl Sized;
+
+fn get_rpit() -> impl Clone {}
+
+fn query(_: impl FnOnce() -> Opaque) {}
+
+fn test() -> Opaque {
+    query(get_rpit);
+    get_rpit()
+}
+
+fn main() {
+    test();
+}

ices/108683.rs

@@ -0,0 +1,7 @@
+fn example(var: i32) {
+    || {
+        let 0 = var;
+    };
+}
+
+fn main() {}

ices/108814.rs

@@ -0,0 +1,8 @@
+#![feature(non_lifetime_binders)]
+
+fn take(_: impl for<T> FnOnce(T) -> T) {}
+
+fn main() {
+    take(|x| x)
+}
+

ices/109020.rs

@@ -0,0 +1,37 @@
+#![feature(type_alias_impl_trait)]
+
+use core::marker::PhantomData;
+
+type WithEmplacableForFn<'a> = impl EmplacableFn + 'a;
+
+fn with_emplacable_for<'a, F, R>(mut f: F) -> R
+where
+    F: for<'b> FnMut(Emplacable<WithEmplacableForFn<'b>>) -> R,
+{
+    fn with_emplacable_for_inner<'a, R>(
+        _: &'a (),
+        _: &mut dyn FnMut(Emplacable<WithEmplacableForFn<'a>>) -> R,
+    ) -> R {
+        fn _constrain(_: &mut ()) -> WithEmplacableForFn<'_> {
+            ()
+        }
+        loop {}
+    }
+
+    with_emplacable_for_inner(&(), &mut f)
+}
+
+trait EmplacableFn {}
+
+impl EmplacableFn for () {}
+
+struct Emplacable<F>
+where
+    F: EmplacableFn,
+{
+    phantom: PhantomData<F>,
+}
+
+fn main() {
+    with_emplacable_for(|_| {});
+}