Merge pull request #1622 from albertlarsan68/add-ices

Add some ICEs

Author: Alexendoo

ices/100041.rs

@@ -0,0 +1,15 @@
+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() {}

ices/110106.rs

@@ -0,0 +1,19 @@
+#![feature(inherent_associated_types)]
+#![allow(incomplete_features)]
+
+struct D<T> {
+  a: T
+}
+
+impl<T: Default> D<T> {
+    type Item = T;
+
+    fn next() -> Self::Item {
+        Self::Item::default()
+    }
+}
+
+
+fn main() {
+}
+

ices/110378.rs

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

ices/110630.rs

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

ices/110696.rs

@@ -0,0 +1,48 @@
+#![feature(type_alias_impl_trait)]
+
+use std::marker::PhantomData;
+
+
+trait MyIndex<T> {
+    type O;
+    fn my_index(self) -> Self::O;
+}
+trait MyFrom<T>: Sized {
+    type Error;
+    fn my_from(value: T) -> Result<Self, Self::Error>;
+}
+
+
+trait F {}
+impl F for () {}
+type DummyT<T> = impl F;
+fn _dummy_t<T>() -> DummyT<T> {}
+
+struct Phantom1<T>(PhantomData<T>);
+struct Phantom2<T>(PhantomData<T>);
+struct Scope<T>(Phantom2<DummyT<T>>);
+
+impl<T> Scope<T> {
+    fn new() -> Self {
+        unimplemented!()
+    }
+}
+
+impl<T> MyFrom<Phantom2<T>> for Phantom1<T> {
+    type Error = ();
+    fn my_from(_: Phantom2<T>) -> Result<Self, Self::Error> {
+        unimplemented!()
+    }
+}
+
+impl<T: MyFrom<Phantom2<DummyT<U>>>, U> MyIndex<DummyT<T>> for Scope<U> {
+    type O = T;
+    fn my_index(self) -> Self::O {
+        MyFrom::my_from(self.0).ok().unwrap()
+    }
+}
+
+fn main() {
+    let _pos: Phantom1<DummyT<()>> = Scope::new().my_index();
+}
+

ices/110726.rs

@@ -0,0 +1,6 @@
+fn foo<'a>() -> impl Sized + 'a {
+    let i: i32 = foo();
+    i
+}
+
+fn main() {}

ices/111176.rs

@@ -0,0 +1,25 @@
+use std::mem;
+
+pub struct S<T: Tr> {
+    pub f: <T as Tr>::I,
+}
+
+pub trait Tr {
+   type I: Tr;
+}
+
+impl<T: Tr> Tr for S<T> {
+    type I = S<S<T>>;
+}
+
+impl Tr for () {
+    type I = ();
+}
+
+fn foo<T: Tr>() -> usize {
+    mem::size_of::<S<T>>()
+}
+
+fn main() {
+    println!("{}", foo::<S<()>>());
+}

ices/111353.rs

@@ -0,0 +1,6 @@
+#![feature(unsized_fn_params)]
+pub fn f(mut x: [i32]) {
+    x[0] = 1;
+}
+
+fn main() {}

ices/111433.rs

@@ -0,0 +1,15 @@
+#![feature(generic_const_exprs)]
+#![allow(incomplete_features)]
+
+const fn inner<'a>() -> usize where &'a (): Sized {
+    3
+}
+
+fn test<'a>() {
+    let _: [u8; inner::<'a>()];
+    let _ = [0; inner::<'a>()];
+}
+
+fn main() {
+    test();
+}

ices/112347.rs

@@ -0,0 +1,25 @@
+#![feature(unboxed_closures)]
+
+use std::future::Future;
+
+trait Trait {
+    fn func(&self, _: &str);
+}
+
+impl<T> Trait for T
+where
+    for<'a> T: Fn<(&'a str,)> + Send + Sync,
+    for<'a> <T as FnOnce<(&'a str,)>>::Output: Future<Output = usize> + Send,
+{
+    fn func(&self, _: &str) {
+        println!("hello!");
+    }
+}
+
+async fn strlen(x: &str) -> usize {
+    x.len()
+}
+
+fn main() {
+    strlen.func("hi");
+}

ices/112574.rs

@@ -0,0 +1,14 @@
+#![feature(non_lifetime_binders)]
+
+pub fn bar()
+where
+    for<const N: usize = {
+    (||1usize)()
+}> V: IntoIterator
+{
+}
+
+fn main() {
+    bar();
+}
+

ices/112623.rs

@@ -0,0 +1,22 @@
+#![feature(const_trait_impl)]
+
+#[const_trait]
+trait Func<T> {
+    type Output;
+
+    fn call_once(self, arg: T) -> Self::Output;
+}
+
+struct Closure;
+
+impl const Func<&usize> for Closure {
+    type Output = usize;
+
+    fn call_once(&'static self, arg: &usize) -> Self::Output {
+        *arg
+    }
+}
+
+enum Bug<T = [(); Closure.call_once(&0)]> {
+    V(T),
+}

ices/112631.rs

@@ -0,0 +1,12 @@
+#![feature(inherent_associated_types)]
+#![allow(incomplete_features)]
+
+struct Foo<T>(T);
+
+impl<'a> Foo<fn(&'a ())> {
+    type Assoc = &'a ();
+}
+
+fn bar(_: for<'a> fn(Foo<fn(Foo<fn(&'static ())>::Assoc)>::Assoc)) {}
+
+fn main() {}

ices/112832.rs

@@ -0,0 +1,22 @@
+pub trait QueryDb {
+    type Db;
+}
+
+pub struct QueryTable<Q, DB> {
+    db: DB,
+    storage: Q,
+}
+
+impl<Q> QueryTable<Q, <Q as QueryDb>::Db> where Q: for<'d> AsyncQueryFunction<'d> {}
+
+pub trait AsyncQueryFunction<'d>: QueryDb<Db = <Self as AsyncQueryFunction<'d>>::SendDb> {
+    type SendDb: 'd;
+}
+
+pub trait QueryStorageOpsAsync<Q>
+where
+    Q: for<'d> AsyncQueryFunction<'d>,
+{
+}
+
+fn main() {}

ices/113017.rs

@@ -0,0 +1,9 @@
+#![feature(generic_const_exprs)]
+
+pub fn String<V>(elem)
+where
+    V: 'a,
+    for<const N: usize = { || {}}> V: 'a, 
+    for<C2: , R2, R3: > <&str as IntoIterator>::Item: 'static,
+{}
+

ices/113021.rs

@@ -0,0 +1,10 @@
+#![feature(generic_const_exprs)]
+
+pub async fn something(path: &[[usize; N_ISLANDS]; PrivateStruct]) -> usize {
+    match path {
+        [] | _ => 0,
+    }
+}
+
+pub fn main() {}
+

ices/113133.rs

@@ -0,0 +1,9 @@
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs, non_lifetime_binders)]
+
+pub fn foo()
+where
+    for<const N: usize = { const fn bar() {} bar(); 1 }> ():, 
+{}
+
+fn main() {}

ices/113272.rs

@@ -0,0 +1,15 @@
+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);
+    }
+}

ices/113280.rs

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

ices/113326.rs

@@ -0,0 +1,21 @@
+#![allow(incomplete_features)]
+#![feature(const_trait_impl)]
+#![feature(const_closures)]
+#![feature(const_refs_to_cell)]
+#![feature(type_alias_impl_trait)]
+
+pub type Diff = impl ~const std::marker::Destruct + ~const Fn(usize) -> usize;
+
+pub const fn lift(n: usize) -> Diff {
+    const move |m: usize| m + n
+}
+
+pub const fn reify(n: Diff) -> usize {
+    n(0)
+}
+
+pub const fn add(n: Diff, m: Diff) -> Diff {
+    const move |x: usize| m(n(x))
+}
+
+fn main() {}

ices/113379.rs

@@ -0,0 +1,5 @@
+async fn f999() -> Vec<usize> {
+    'b: {
+        continue 'b;
+    }
+}

ices/113434.rs

@@ -0,0 +1,7 @@
+#![feature(return_position_impl_trait_in_trait)]
+
+struct Wrapper<G: Send>(T);
+
+trait Foo {
+    fn bar() -> Wrapper<impl Sized>;
+}

ices/113462.rs

@@ -0,0 +1,2 @@
+#[derive(Default)]
+struct NonGeneric<'a, const N: NonGeneric> {}

ices/113481.rs

@@ -0,0 +1,13 @@
+trait Foo {
+    type Bar<'x>
+    where
+        Self: 'x;
+}
+
+fn baz() -> impl for<'y> Foo<Bar<'y> = impl ToString> {
+    42
+}
+
+impl Foo for i32 {
+    type Bar<'x> = &'x str;
+}

ices/113610.rs

@@ -0,0 +1,3 @@
+fn test5() {
+    let t = (String::new(), Default::default());
+}