Add some ICEs

Author: fanninpm

ices/75229.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+cat > 75229.rs <<EOF
+enum TestEnum {
+    Field { test_field: String },
+}
+fn main(){
+	()
+}
+
+EOF
+
+RUST_BACKTRACE=1 RUST_SAVE_ANALYSIS_CONFIG='{"output_file":null,"full_docs":true,"pub_only":false,"reachable_only":false,"distro_crate":false,"signatures":true,"borrow_data":false}' rustc 75229.rs -Z save_analysis

ices/76375.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+cat > x.rs <<EOF
+#![crate_type = "lib"]
+
+#[inline(always)]
+pub fn f(s: bool) -> String {
+    let a = "Hello world!".to_string();
+    let b = a;
+    let c = b;
+    if s {
+        c
+    } else {
+        String::new()
+    }
+}
+
+EOF
+
+cat > y.rs <<EOF
+#![crate_type = "lib"]
+
+pub async fn g() {
+    x::f(true);
+    h().await;
+}
+
+pub async fn h() {}
+
+EOF
+
+rustc --edition=2018 -Zmir-opt-level=2 x.rs
+rustc --edition=2018 -Zmir-opt-level=2 y.rs --extern x -L.

ices/76510.rs

@@ -0,0 +1,12 @@
+struct Dummy;
+
+impl Dummy {
+    const fn func(&mut self) -> usize {
+        42
+    }
+}
+
+const _: &[usize] = &[0; {
+    const DUMMY: &Dummy = &Dummy;
+    DUMMY.func()
+}];

ices/76535.rs

@@ -0,0 +1,37 @@
+#![feature(generic_associated_types)]
+
+pub trait SubTrait {}
+
+pub trait SuperTrait {
+    type SubType<'a>: SubTrait;
+
+    fn get_sub<'a>(&'a mut self) -> Self::SubType<'a>;
+}
+
+pub struct SubStruct<'a> {
+    sup: &'a mut SuperStruct,
+}
+
+impl<'a> SubTrait for SubStruct<'a> {}
+
+pub struct SuperStruct {
+    value: u8,
+}
+
+impl SuperStruct {
+    pub fn new(value: u8) -> SuperStruct {
+        SuperStruct { value }
+    }
+}
+
+impl SuperTrait for SuperStruct {
+    type SubType<'a> = SubStruct<'a>;
+
+    fn get_sub<'a>(&'a mut self) -> Self::SubType<'a> {
+        SubStruct { sup: self }
+    }
+}
+
+fn main() {
+    let sub: Box<dyn SuperTrait<SubType = SubStruct>> = Box::new(SuperStruct::new(0));
+}

ices/76826.rs

@@ -0,0 +1,42 @@
+#![feature(generic_associated_types)]
+
+pub trait Iter {
+    type Item<'a> where Self: 'a;
+
+    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>;
+
+    fn for_each<F>(mut self, mut f: F)
+        where Self: Sized, F: for<'a> FnMut(Self::Item<'a>)
+    {
+        while let Some(item) = self.next() {
+            f(item);
+        }
+    }
+}
+
+pub struct Windows<T> {
+    items: Vec<T>,
+    start: usize,
+    len: usize,
+}
+
+impl<T> Windows<T> {
+    pub fn new(items: Vec<T>, len: usize) -> Self {
+        Self { items, start: 0, len }
+    }
+}
+
+impl<T> Iter for Windows<T> {
+    type Item<'a> where T: 'a = &'a mut [T];
+
+    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>> {
+        let slice = self.items.get_mut(self.start..self.start + self.len)?;
+        self.start += 1;
+        Some(slice)
+    }
+}
+
+fn main() {
+    Windows::new(vec![1, 2, 3, 4, 5], 3)
+        .for_each(|slice| println!("{:?}", slice));
+}