Merge pull request #895 from Alexendoo/add

Add some ICEs

Author: Alexendoo

ices/86953.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+
+rustc - --crate-type=lib -C incremental=foo << 'EOF'
+#![feature(const_generics)]
+#![feature(const_evaluatable_checked)]
+
+use std::ops::Add;
+
+pub struct StackBitSet<const N: usize> where [(); 0]: Sized;
+
+impl<const N: usize, const M: usize> Add<&StackBitSet<M>> for StackBitSet<N>
+where
+    [(); 0+0]: Sized, // changing 0+0 to 0 makes this work
+    [(); 0]: Sized,
+    [(); 0]: Sized,
+{
+    type Output = StackBitSet<0>;
+    fn add(self, _: &StackBitSet<M>) -> Self::Output {
+        loop {}
+    }
+}
+
+#[test]
+fn bitset_create() {
+    let _a: StackBitSet<42> = StackBitSet;
+}
+EOF

ices/87142.sh

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+rustc - --crate-type lib -C debuginfo=2 << 'EOF'
+#![feature(type_alias_impl_trait, generator_trait, generators)]
+use std::ops::{Generator};
+
+pub trait GeneratorProviderAlt: Sized {
+    type Gen: Generator<(), Return=(), Yield=()>;
+
+    fn start(ctx: Context<Self>) -> Self::Gen;
+}
+
+pub struct Context<G: 'static + GeneratorProviderAlt> {
+    // back-link to our generator state
+    // In reality some other pointer type, but Box triggers the bug
+    // Also in reality, points to a wrapper struct that only indirectly holds
+    //   the generator state.
+    link: Box<G::Gen>,
+}
+
+impl GeneratorProviderAlt for () {
+    type Gen = impl Generator<(), Return=(), Yield=()>;
+    fn start(ctx: Context<Self>) -> Self::Gen {
+        move || {
+            match ctx { _ => () } // make sure to use the context
+            yield ();
+        }
+    }
+}
+EOF

ices/87219.sh

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+
+rustc - --emit=mir -Zpolymorphize=on << 'EOF'
+#![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));
+}
+EOF

ices/87258.rs

@@ -0,0 +1,36 @@
+#![feature(min_type_alias_impl_trait)]
+#![feature(generic_associated_types)]
+use std::future::Future;
+
+pub trait Trait1
+{
+    type Error: Clone;
+    type Assoc2<'a>
+    where
+        Self: 'a;
+}
+
+pub trait Trait2: Trait1 {
+    type FooFuture<'a, 'b>: Future<Output = Result<(), Self::Error>>;
+    fn foo<'a: 'b, 'b>(assoc2: &'b mut Self::Assoc2<'a>) -> Self::FooFuture<'a, 'b>
+    where
+        Self: 'a;
+}
+
+impl<'c, S : Trait1> Trait1 for &'c mut S {
+    type Error = S::Error;
+
+    type Assoc2<'a> where 'c: 'a = S::Assoc2<'a>;
+}
+
+impl<'c, S : Trait2> Trait2 for &'c mut S {
+    type FooFuture<'a, 'b> = impl Future<Output = Result<(), Self::Error>>;
+    fn foo<'a: 'b, 'b>(assoc2: &'b mut Self::Assoc2<'a>) -> Self::FooFuture<'a, 'b>
+    where
+        Self: 'a
+    {
+        async move {
+            unimplemented!();
+        }
+    }
+}

ices/87308.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+rustc - -Zunpretty=everybody_loops << 'EOF'
+macro_rules! foo {
+    () => { break 'x; } //~ ERROR use of undeclared label `'x`
+}
+
+pub fn main() {
+    'x: loop { foo!() }
+}
+EOF

ices/87340.rs

@@ -0,0 +1,2 @@
+type PartiallyDefined<T> = impl 'static;
+fn partially_defined() -> PartiallyDefined<_> {}

ices/87490.rs

@@ -0,0 +1,9 @@
+trait StreamOnce {
+    type Position;
+}
+impl StreamOnce for &str {
+    type Position = usize;
+}
+fn follow(_: &str) -> <&str as StreamOnce>::Position {
+    String::new
+}

ices/87496.rs

@@ -0,0 +1,7 @@
+#[repr(transparent)]
+struct TransparentCustomZst(());
+extern "C" {
+    fn good17(p: TransparentCustomZst);
+}
+
+fn main() {}

ices/87542.rs

@@ -0,0 +1,12 @@
+pub enum Foo<const A: usize> {
+    Bar,
+    Baz([(); A]),
+}
+
+
+fn main() {
+    // Cannot infer type for 9
+    // let x = Foo::Bar::<9>;
+    // Compiler error
+    let x = Foo::Bar::<9usize>;
+}

ices/87549.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+rustc - -C incremental=true << 'EOF'
+trait XTrait<A> {}
+
+struct X<T: XTrait<A>, A> (T, A);
+
+trait Y<'t> {
+    type M;
+    type N: 't;
+}
+
+impl<'t, T: XTrait<A>, A> Y<'t> for X<T, A> {
+    type M = X<T, Self::N>;
+    type N = &'t ();
+}
+
+fn main() {
+    println!("Hello, world!");
+}
+EOF

ices/87558.rs

@@ -0,0 +1,5 @@
+struct ErrorKind;
+struct Error(ErrorKind);
+impl Fn(&isize) for Error {
+    fn from() {}
+}

ices/87563.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+
+rustc - --emit=mir -Zsave-analysis << 'EOF'
+#![feature(generic_arg_infer)]
+
+struct All<'a, T, const N: usize> {
+  v: &'a T,
+}
+
+struct BadInfer<_>;
+//~^ ERROR expected identifier
+//~| ERROR parameter `_` is never used
+
+fn all_fn<'a, T, const N: usize>() {}
+
+fn bad_infer_fn<_>() {}
+//~^ ERROR expected identifier
+
+
+fn main() {
+  let a: All<_, _, _>;
+  all_fn();
+  let v: [u8; _];
+  //~^ ERROR in expressions
+  let v: [u8; 10] = [0; _];
+  //~^ ERROR in expressions
+}
+EOF

ices/87573.rs

@@ -0,0 +1,28 @@
+#![crate_type = "lib"]
+#![feature(no_core, lang_items)]
+#![no_core]
+
+static STATIC_BOOL: bool = true;
+
+#[lang = "sized"]
+trait Sized {}
+
+#[lang = "copy"]
+trait Copy {}
+
+// Uncommenting avoids the second ICE
+//impl Copy for bool {}
+
+#[lang = "sync"]
+trait Sync {}
+impl Sync for bool {}
+
+// Both errors occur here and are independent
+#[lang = "drop_in_place"]
+fn drop_fn() { // <- the drop fn expects a generic T, missing T causes index error
+    while false {} // <- this expects the bool condition to be Copy, and it isn't
+}
+
+// required to make the compiler happy
+#[lang = "start"]
+fn start(){}

ices/87577.rs

@@ -0,0 +1,2 @@
+#[derive(Debug)]
+struct S<#[cfg(feature = "alloc")] N: A<T>> {}

ices/87750.rs

@@ -0,0 +1,47 @@
+#![feature(generic_associated_types)]
+use std::rc::Rc;
+use std::ops::Deref;
+
+trait PointerFamily {
+    type Pointer<T>: Deref<Target=T> + Sized;
+
+    fn new<T>(obj: T) -> Self::Pointer<T>;
+}
+
+#[derive(Debug)]
+struct RcFamily;
+
+impl PointerFamily for RcFamily {
+    type Pointer<T> = Rc<T>;
+
+    fn new<T>(obj: T) -> Rc<T> {
+        Rc::new(obj)
+    }
+}
+
+#[derive(Debug)]
+enum Node<T, P: PointerFamily> where P::Pointer<Node<T, P>>: Sized {
+    Cons(T, P::Pointer<Node<T, P>>),
+    Nil
+}
+
+type List<T, P> = <P as PointerFamily>::Pointer<Node<T, P>>;
+type RcList<T> = List<T, RcFamily>;
+type RcNode<T> = Node<T, RcFamily>;
+
+impl<T, P: PointerFamily> Node<T, P> where P::Pointer<Node<T, P>>: Sized {
+    fn new() -> P::Pointer<Self> {
+        P::new(Self::Nil)
+    }
+
+    fn cons(head: T, tail: P::Pointer<Self>) -> P::Pointer<Self> {
+        P::new(Self::Cons(head, tail))
+    }
+}
+
+fn main() {
+    let mut list: RcList<i32> = RcNode::<i32>::new();
+    list = RcNode::<i32>::cons(1, list);
+    //println!("{:?}", list);
+
+}

ices/87762.rs

@@ -0,0 +1,17 @@
+#![feature(generic_associated_types)]
+
+trait Trait {
+    type Assoc<'a>;
+}
+
+fn f<T: Trait>(_: T, _: fn(T::Assoc<'_>)) {}
+
+struct Type;
+
+impl Trait for Type {
+    type Assoc<'a> = &'a ();
+}
+
+fn main() {
+    f(Type, |_| ());
+}

ices/87771.rs

@@ -0,0 +1,4 @@
+fn main() {
+    let mut arr = vec![vec![]];
+    arr[0][0] = arr[0][0] = true;
+}

ices/87793.rs

@@ -0,0 +1,3 @@
+fn m(){#[c=[r
+e
+e

ices/87802.rs

@@ -0,0 +1,13 @@
+#![feature(asm)]
+
+fn hmm() -> ! {
+    let x;
+    unsafe {
+        asm!("/* {0} */", out(reg) x);
+    }
+    x
+}
+
+fn main() {
+    hmm();
+}

ices/87877.rs

@@ -0,0 +1,10 @@
+macro_rules! two_items {() => (
+    extern {}
+    extern {}
+)}
+
+macro_rules! single_item_funneler {( $item:item ) => ( $item )}
+
+fn inside_some_function() {
+    single_item_funneler! { two_items! {} }
+}