Merge pull request #455 from JohnTitor/add-ices-aug

Add 5 ICEs

Author: Alexendoo

ices/74702.rs renamed to fixed/74702.rs

@@ -0,0 +1,14 @@
+#![feature(member_constraints)]
+#![feature(type_alias_impl_trait)]
+
+pub trait A {
+    type B;
+    fn f(&self) -> Self::B;
+}
+impl<'a, 'b> A for () {
+    type B = impl core::fmt::Debug;
+
+    fn f(&self) -> Self::B {}
+}
+
+fn main() {}

ices/74761.rs

@@ -0,0 +1,21 @@
+#![feature(associated_type_defaults)]
+#![feature(generic_associated_types)]
+#![allow(incomplete_features)]
+
+trait Trait1 {
+    fn foo();
+}
+
+trait Trait2 {
+    type Associated: Trait1 = Self;
+}
+
+impl Trait2 for () {}
+
+fn call_foo<T: Trait2>() {
+    T::Associated::foo()
+}
+
+fn main() {
+    call_foo::<()>()
+}

ices/74816.rs

@@ -0,0 +1,11 @@
+#![feature(const_generics)]
+#![allow(incomplete_features)]
+#![crate_type = "lib"]
+
+pub async fn baz<const H: usize>() {
+    biz(&Vec::new()).await;
+}
+
+const SIZE: usize = 16;
+
+pub async fn biz(_: &[[u8; SIZE]]) {}

ices/74906.rs

@@ -0,0 +1,25 @@
+struct ChunkingIterator<T, S: 'static + Iterator<Item = T>> {
+    source: S,
+}
+
+impl<T, S: Iterator<Item = T>> Iterator for ChunkingIterator<T, S> {
+    type Item = IteratorChunk<T, S>;
+
+    fn next(&mut self) -> Option<IteratorChunk<T, S>> {
+        todo!()
+    }
+}
+
+struct IteratorChunk<'a, T, S: Iterator<Item = T>> {
+    source: &'a mut S,
+}
+
+impl<T, S: Iterator<Item = T>> Iterator for IteratorChunk<'_, T, S> {
+    type Item = T;
+
+    fn next(&mut self) -> Option<T> {
+        todo!()
+    }
+}
+
+fn main() {}

ices/74918.rs

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+rustc -Zmir-opt-level=2 - << EOF
+#![feature(type_alias_impl_trait)]
+
+use std::marker::PhantomData;
+
+/* copied Index and TryFrom for convinience (and simplicity) */
+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>;
+}
+
+/* MCVE starts here */
+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<Phantom1<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();
+}
+
+EOF