add 5 ices

rust-lang/rust#100689
rust-lang/rust#100672
rust-lang/rust#100612
rust-lang/rust#100550
rust-lang/rust#100463

ices/100463.rs

@@ -0,0 +1,14 @@
+struct Foo<T> {
+    inner: Vec<T>,
+}
+
+impl<T> Foo<T> {
+    fn get(&self) -> impl Iterator<Item = &T> {
+        self.inner.iter()
+    }
+}
+
+fn main() {
+    let foo: Foo<()> = Foo { inner: Vec::new() };
+    let vals: Vec<_> = foo.get();
+}

ices/100550.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+rustc -Copt-level=2 --crate-type lib  - <<'EOF'
+
+pub trait Trait {
+    type Associated;
+}
+impl<T> Trait for T {
+    type Associated = T;
+}
+
+pub struct Struct<T>(<T as Trait>::Associated);
+
+pub fn foo<T>() -> Struct<T>
+where
+    T: Trait,
+{
+    bar()
+}
+
+#[inline]
+fn bar<T>() -> Struct<T> {
+    Struct(baz())
+}
+
+fn baz<T>() -> T {
+    unimplemented!()
+}
+
+EOF
+

ices/100612.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+rustc "-Cdebuginfo=2" - <<'EOF'
+
+// run-pass
+#![feature(repr128, arbitrary_enum_discriminant)]
+//~^ WARN the feature `repr128` is incomplete
+
+#[derive(PartialEq, Debug)]
+#[repr(i128)]
+enum Test {
+    A(Box<u64>) = 0,
+    B(usize) = u64::MAX as i128 + 1,
+}
+
+fn main() {
+    assert_ne!(Test::A(Box::new(2)), Test::B(0));
+    // This previously caused a segfault.
+    //
+    // See https://github.com/rust-lang/rust/issues/70509#issuecomment-620654186
+    // for a detailed explanation.
+}
+
+EOF
+

ices/100672.rs

@@ -0,0 +1,15 @@
+#![feature(generic_associated_types)]
+
+trait Bar<'a> {
+    type Ref<'b>
+    where
+        'a: 'b;
+    fn uwu(f: impl Fn(Self::Ref<'_>));
+}
+
+impl<'a> Bar<'a> for () {
+    type Ref<'b> = () where 'a: 'b;
+    fn uwu(f: impl Fn(())) {}
+}
+
+pub fn main() {}

ices/100689.rs

@@ -0,0 +1,35 @@
+#![feature(generic_associated_types)]
+
+struct Foo<'a> {
+    foo: &'a mut usize,
+}
+
+trait Bar<'a> {
+    type FooRef<'b>
+    where
+        'a : 'b,
+    ;
+    fn uwu (
+        foo: Foo<'a>,
+        f: impl for<'b> FnMut(Self::FooRef<'b>),
+    )
+    ;
+}
+impl<'a> Bar<'a> for () {
+    type FooRef<'b>
+    =
+        &'b Foo<'a>
+    where
+        'a : 'b,
+    ;
+
+    fn uwu (
+        foo: Foo<'a>,
+        mut f: impl for<'b> FnMut(&'b Foo<'a>), //relevant part
+    )
+    {
+        f(&foo);
+    }
+}
+
+fn main() {}