Merge pull request #168 from Alexendoo/added

Add some more ICEs

Author: JohnTitor

fixed/59353.rs

@@ -0,0 +1,5 @@
+pub struct Node<NodeRef = Box<Self>>(NodeRef);
+
+pub struct Foo(Node);
+
+fn main() {}

fixed/59956-1.rs

@@ -0,0 +1,15 @@
+use std::marker::PhantomData;
+
+struct Invariant<'id, I = Self> {
+    lifetime: PhantomData<*mut &'id I>,
+}
+
+trait Contract<'s> {
+    type Item: for<'r> Contract<'r>;
+}
+
+impl <'a, 'b> Contract<'b> for Invariant<'a> {
+    type Item = Invariant<'b>;
+}
+
+fn main() {}

fixed/59956-2.rs

@@ -0,0 +1,4 @@
+struct Bug<B = Self>;
+impl Bug {}
+
+fn main() {}

ices/41073.rs

@@ -0,0 +1,24 @@
+#![feature(untagged_unions)]
+
+union Test {
+    a: A,
+    b: B
+}
+
+#[derive(Debug)]
+struct A(i32);
+impl Drop for A {
+    fn drop(&mut self) { println!("A"); }
+}
+
+#[derive(Debug)]
+struct B(f32);
+impl Drop for B {
+    fn drop(&mut self) { println!("B"); }
+}
+
+fn main() {
+    let mut test = Test { a: A(3) };
+    println!("{:?}", unsafe { test.b });
+    unsafe { test.b = B(0.5); }
+}

ices/43037.rs

@@ -0,0 +1,14 @@
+#![crate_type = "lib"]
+#![feature(specialization)] // comment this line to get the expected behavior
+trait X {}
+trait Y: X {}
+trait Z { type Assoc: Y; }
+struct A<T>(T);
+
+impl<T> Y for T where T: X {}
+impl<T: X> Z for A<T> { type Assoc = T; }
+
+// this impl is invalid, but causes an ICE anyway
+impl<T> From<<A<T> as Z>::Assoc> for T {}
+
+fn main() {}

ices/43924.rs

@@ -0,0 +1,13 @@
+#![feature(associated_type_defaults)] 
+trait Foo < T : Default + ToString >
+{ 
+  type Out : Default + ToString = ToString; 
+}
+
+impl Foo < u32 > for () {} 
+impl Foo < u64 > for () {}
+
+fn main ()
+{ 
+  assert_eq ! (< () as Foo < u32 >> :: Out :: default().to_string(), "false"); 
+} 

ices/45814.rs

@@ -0,0 +1,9 @@
+#![feature(specialization)]
+
+pub trait Trait<T> { }
+
+default impl<T, U> Trait<T> for U { }
+
+impl<T> Trait<<T as Iterator>::Item> for T { }
+
+fn main() { }

ices/46511.rs

@@ -0,0 +1,4 @@
+struct Foo<'a>
+{
+    a: [u8; std::mem::size_of::<&'a mut u8>()]
+}

ices/47814.rs

@@ -0,0 +1,13 @@
+struct ArpIPv4<'a> {
+    s: &'a u8
+}
+
+impl<'a> ArpIPv4<'a> {
+    const LENGTH: usize = 20;
+
+    pub fn to_buffer() -> [u8; Self::LENGTH] {
+        unimplemented!()
+    }
+}
+
+fn main() {}

ices/49362.rs

@@ -0,0 +1,13 @@
+#![feature(generic_associated_types)]
+
+struct S;
+
+trait Trait {
+    type Associated<'a>;
+}
+
+impl Trait for S {
+    type Associated<'a> = &'a ();
+}
+
+fn main() {}

ices/51506.rs

@@ -0,0 +1,37 @@
+#![feature(never_type)]
+#![feature(specialization)]
+
+use std::iter::{self, Empty};
+
+trait Trait {
+    type Out: Iterator<Item = u32>;
+
+    fn f(&self) -> Option<Self::Out>;
+}
+
+impl<T> Trait for T {
+    default type Out = !;
+
+    default fn f(&self) -> Option<Self::Out> {
+        None
+    }
+}
+
+struct X;
+
+impl Trait for X {
+    type Out = Empty<u32>;
+
+    fn f(&self) -> Option<Self::Out> {
+        Some(iter::empty())
+    }
+}
+
+fn main() {
+    if let Some(iter) = 1.f() { // replacing 1 by X makes the code compiles and runs fine
+        println!("Some");
+        for x in iter {
+            println!("x = {}", x);
+        }
+    }
+}

ices/51892.rs

@@ -0,0 +1,13 @@
+#![feature(specialization)]
+
+pub trait Trait {
+  type Type;
+}
+
+impl<T: ?Sized> Trait for T {
+  default type Type = [u8; 1];
+}
+
+impl<T: Trait> Trait for *const T {
+  type Type = [u8; std::mem::size_of::<<T as Trait>::Type>()];
+}

ices/52808.rs

@@ -0,0 +1,10 @@
+struct Foo<'a> { x: &'a () }
+
+impl<'a> Foo<'a> {
+    const X: usize = 0;
+
+    fn foo(_: [u8; Self::X]) {}
+}
+
+
+fn main() {}

ices/52843.rs

@@ -0,0 +1,14 @@
+#![feature(type_alias_impl_trait)]
+
+type Foo<T> = impl Default;
+
+#[allow(unused)]
+fn foo<T: Default>(t: T) -> Foo<T> {
+    t
+}
+
+struct NotDefault;
+
+fn main() {
+    let _ = Foo::<NotDefault>::default();
+}

ices/53092.rs

@@ -0,0 +1,23 @@
+#![feature(const_fn)]
+#![feature(const_fn_union)]
+#![feature(type_alias_impl_trait)]
+#![feature(untagged_unions)]
+
+const fn transmute<T, U>(t: T) -> U {
+    union Transform<TT, UU> {
+        t: TT,
+        u: UU,
+    }
+    
+    unsafe { Transform { t }.u }
+}
+
+type Foo<F, U> = impl Fn(F) -> U + Copy;
+
+const BAZR: Foo<u8, ()> = transmute(|x: ()| { x });
+
+fn bar<T, U: From<T>>() -> Foo<T, U> { |x| x.into() }
+
+fn main() {
+    let x = BAZR(0);
+}

ices/53448.rs

@@ -0,0 +1,14 @@
+#![feature(unboxed_closures)]
+
+trait Lt<'a> {
+    type T;
+}
+impl<'a> Lt<'a> for () {
+    type T = ();
+}
+
+fn main() {
+    let v:<() as Lt<'_>>::T = ();
+    let f:&mut FnMut<(_,),Output=()> = &mut |_:<() as Lt<'_>>::T|{};
+    f(v);
+}

ices/53475.rs

@@ -0,0 +1,12 @@
+#![feature(coerce_unsized)]
+
+use std::ops::CoerceUnsized;
+use std::any::Any;
+
+struct Foo<T> {
+	data: Box<T>
+}
+
+impl<T> CoerceUnsized<Foo<dyn Any>> for Foo<T> {}
+
+fn main() {}

ices/54038.rs

@@ -0,0 +1,10 @@
+struct Foo<'a> {
+    data: &'a [u8],
+}
+
+impl<'a> Foo<'a> {
+    const LEN: usize = 4;
+    fn bar(buf: &mut [u8; Self::LEN]) {
+        unimplemented!()
+    }
+}

ices/54108.rs

@@ -0,0 +1,38 @@
+use std::ops::Add;
+
+pub trait Encoder {
+	type Size: Add<Output = Self::Size>;
+
+	fn foo(&self) -> Self::Size;
+}
+
+pub trait SubEncoder : Encoder {
+	type ActualSize;
+
+	fn bar(&self) -> Self::Size;
+}
+
+impl<T> Encoder for T where T: SubEncoder {
+	type Size = <Self as SubEncoder>::ActualSize;
+
+	fn foo(&self) -> Self::Size {
+		self.bar() + self.bar()
+	}
+}
+
+pub struct UnitEncoder;
+
+impl SubEncoder for UnitEncoder {
+	type ActualSize = ();
+
+	fn bar(&self) {}
+}
+
+
+fn main() {
+	fun(&UnitEncoder {});
+}
+
+pub fn fun<R: Encoder>(encoder: &R) {
+	encoder.foo();
+}

ices/54840.rs

@@ -0,0 +1,8 @@
+#![feature(impl_trait_in_bindings)]
+
+use std::ops::Add;
+
+fn main() {
+    let i: i32 = 0;
+    let j: &impl Add = &i;
+}

ices/54888.rs

@@ -0,0 +1,19 @@
+#![feature(unsize, coerce_unsized)]
+
+use std::{
+    ops::CoerceUnsized,
+    marker::Unsize,
+};
+
+#[repr(C)]
+struct Ptr<T: ?Sized>(Box<T>);
+
+impl<T: ?Sized, U: ?Sized> CoerceUnsized<Ptr<U>> for Ptr<T>
+where
+    T: Unsize<U>,
+{}
+
+
+fn main() {
+    let foo = Ptr(Box::new(5)) as Ptr<::std::any::Any>;
+}

ices/54895.rs

@@ -0,0 +1,9 @@
+trait Trait<'a> {
+    type Out;
+}
+impl<'a> Trait<'a> for () {
+    type Out = ();
+}
+fn main() -> impl for<'a> Trait<'a, Out = impl ?Sized + 'a> {
+    ()
+}

ices/55414.rs

@@ -0,0 +1,12 @@
+macro_rules! bug {
+    ($expr:expr) => {
+        #[rustc_dummy = $expr] // Any key-value attribute, not necessarily `doc`
+        struct S;
+    };
+}
+
+// Any expressions containing macro call `X` that's more complex than `X` itself.
+// Parentheses will work.
+bug!((line!()));
+
+fn main() {}

ices/56445-1.rs

@@ -0,0 +1,9 @@
+struct OnDiskDirEntry<'a> { _s: &'a usize }
+
+impl<'a> OnDiskDirEntry<'a> {
+    const LFN_FRAGMENT_LEN: usize = 2;
+
+    fn lfn_contents(&self) -> [char; Self::LFN_FRAGMENT_LEN] { loop { } }
+}
+
+fn main() {}

ices/56445-2.rs

@@ -0,0 +1,6 @@
+#![feature(const_generics)]
+use core::marker::PhantomData;
+
+struct Bug<'a, const S: &'a str>(PhantomData<&'a ()>);
+
+impl Bug<'_, {""}> {}

ices/56445-3.rs

@@ -0,0 +1,8 @@
+pub struct Memory<'rom> {
+    rom: &'rom [u8],
+    ram: [u8; Self::SIZE],
+}
+
+impl<'rom> Memory<'rom> {
+    pub const SIZE: usize = 0x8000;
+}

ices/57200.rs

@@ -0,0 +1,11 @@
+#![feature(impl_trait_in_bindings)]
+
+fn bug<'a, 'b, T>()
+where
+    'a: 'b,
+{
+    let f: impl Fn(&'a T) -> &'b T = |x| x;
+}
+
+
+fn main() {}