Merge pull request #1615 from JohnTitor/ices-20230625

Author: JohnTitor

ices/110453.rs

@@ -0,0 +1,14 @@
+pub struct B;
+pub fn a() -> B {
+    B
+}
+
+mod handlers {
+    pub struct C(B);
+    pub fn c() -> impl Fn() -> C {
+        let a1 = ();
+        || C((crate::a(), a1).into())
+    }
+}
+
+fn main() {}

ices/110534.rs

@@ -0,0 +1,48 @@
+#![allow(coherence_leak_check)]
+
+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();
+}

ices/111470.rs

@@ -0,0 +1,24 @@
+#![allow(dead_code)]
+#![allow(unused_variables)]
+#![feature(type_alias_impl_trait)]
+
+use std::fmt::Debug;
+use std::marker::PhantomData;
+
+struct Foo<T: Debug, F: FnOnce(T)> {
+    f: F,
+    _phantom: PhantomData<T>,
+}
+
+type ImplT = impl Debug;
+type FooImpl = Foo<ImplT, impl FnOnce(ImplT)>;
+
+fn bar() -> FooImpl {
+    let x = 5i32;
+    Foo::<i32, _> {
+        f: |_| (),
+        _phantom: PhantomData,
+    }
+}
+
+fn main() {}

ices/111742.rs

@@ -0,0 +1,9 @@
+#![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>;
+}

ices/112047.rs

@@ -0,0 +1,34 @@
+#![feature(async_fn_in_trait)]
+
+fn main() {
+    let _ = async {
+        A.first().await.second().await;
+    };
+}
+
+pub trait First {
+    type Second: Second;
+    async fn first(self) -> Self::Second;
+}
+
+struct A;
+
+impl First for A {
+    type Second = A;
+    async fn first(self) -> Self::Second {
+        A
+    }
+}
+
+pub trait Second {
+    async fn second(self);
+}
+
+impl<C> Second for C
+where
+    C: First,
+{
+    async fn second(self) {
+        self.first().await.second().await;
+    }
+}

ices/112630.rs

@@ -0,0 +1,7 @@
+enum Foo {
+    Bar(B),
+}
+
+fn main() {
+    let _ = [0u32; Foo::Bar as usize];
+}

ices/112822.rs

@@ -0,0 +1,16 @@
+#![feature(const_trait_impl)]
+
+const fn test() -> impl ~const Fn() {
+    const move || {
+        let sl: &[u8] = b"foo";
+
+        match sl {
+            [first, _remainder @ ..] => {
+                assert_eq!(first, &b'f');
+            }
+            [] => panic!(),
+        }
+    }
+}
+
+fn main() {}

ices/112824.rs

@@ -0,0 +1,15 @@
+pub struct Opcode(pub u8);
+
+pub struct Opcode2(&'a S);
+
+impl Opcode2 {
+    pub const OP2: Opcode2 = Opcode2(Opcode(0x1));
+}
+
+pub fn example2(msg_type: Opcode2) -> impl FnMut(&[u8]) {
+    move |i| match msg_type {
+        Opcode2::OP2 => unimplemented!(),
+    }
+}
+
+fn main() {}

ices/113016.rs

@@ -0,0 +1,5 @@
+#![feature(non_lifetime_binders)]
+
+trait Trait<Input> {}
+
+fn main(x: impl for<f> Trait<'_, Assoc = impl Trait<f> + '_>) {}