Merge pull request #160 from JohnTitor/add-10-ices

Add 10 ICEs

Author: Alexendoo

ices/61455.rs

@@ -0,0 +1,12 @@
+#![feature(const_generics)]
+
+use std::mem::transmute;
+
+struct Bug<const N: fn(usize)>;
+
+fn main() {
+    let x = Bug::<{
+        unsafe { transmute(|x: u8| {}) }
+        
+    }>;
+}

ices/61747.rs

@@ -0,0 +1,13 @@
+#![feature(const_generics)]
+
+struct Const<const N: usize>;
+
+impl<const C: usize> Const<{C}> {
+    fn successor() -> Const<{C + 1}> {
+        Const
+    }
+}
+
+fn main() {
+    Const::<1>::successor();
+}

ices/61774.rs

@@ -0,0 +1,3 @@
+fn main() {
+    let _: [_; unsafe { std::mem::transmute(|| {}) }];
+}

ices/61936.rs

@@ -0,0 +1,45 @@
+#![feature(const_generics)]
+
+trait SliceExt<T: Clone> {
+    fn array_windows<'a, const N: usize>(&'a self) -> ArrayWindows<'a, T, {N}>;
+}
+
+impl <T: Clone> SliceExt<T> for [T] {
+   fn array_windows<'a, const N: usize>(&'a self) -> ArrayWindows<'a, T, {N}> {
+       ArrayWindows{ idx: 0, slice: &self }
+   } 
+}
+
+struct ArrayWindows<'a, T, const N: usize> {
+    slice: &'a [T],
+    idx: usize,
+}
+
+impl <'a, T: Clone, const N: usize> Iterator for ArrayWindows<'a, T, {N}> {
+    type Item = [T; N];
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut res = unsafe{ std::mem::zeroed() };
+        let mut ptr = &mut res as *mut [T; N] as *mut T;
+        
+        for i in 0..N {
+            match self.slice[i..].get(i) {
+                None => return None,
+                Some(elem) => unsafe { std::ptr::write_volatile(ptr, elem.clone())}, 
+            };
+            ptr = ptr.wrapping_add(1);
+            self.idx += 1;
+        }
+        
+        Some(res)
+    }
+}
+
+const FOUR: usize = 4;
+
+fn main() {
+    let v = vec![100; 0usize];
+    
+    for array in v.as_slice().array_windows::<{FOUR}>() {
+       // println!("{:?}", array);
+    }
+}

ices/62046.rs

@@ -0,0 +1,21 @@
+#![feature(asm)]
+
+struct ThreadContext {
+    rsp: u64,
+    r15: u64,
+}
+
+fn gt_switch(new: *const ThreadContext) -> ! {
+    unsafe {
+        asm!("mov     $1, $0" : "+r"("r15") : "*m"(&(*new).r15));
+        asm!("mov     $1, $0" : "+r"("rsp") : "*m"(&(*new).rsp));
+        asm!("ret");
+        std::hint::unreachable_unchecked()
+    }
+}
+
+fn main() {
+    let ctx = ThreadContext{rsp: 0x80, r15: 0x88};
+
+    gt_switch(&ctx);
+}

ices/62200.rs

@@ -0,0 +1,14 @@
+pub trait SIterator {}
+
+pub trait Ty<'a> {
+    type V;
+}
+
+struct FilterMap<F>(F);
+
+impl<X, F> SIterator for FilterMap<F>
+where
+    F: FnOnce(<X as Ty<'_>>::V) -> Option<<X as Ty<'_>>::V>
+{}
+
+fn main() {}

ices/62222.rs

@@ -0,0 +1,37 @@
+#![feature(const_generics)]
+
+use std::mem::MaybeUninit;
+
+#[repr(transparent)]
+pub struct Vector<T, const N: usize>([T; N]);
+
+impl<T, const N: usize> Vector<T, {N}> {
+    pub fn x(self) -> T {
+        let mut head = MaybeUninit::<T>::uninit();
+        let mut tail = MaybeUninit::<[T; N - 1]>::uninit();
+        let mut from = MaybeUninit::new(self);
+        let tailp: *mut T = unsafe { mem::transmute(&mut tail) };
+        let fromp: *mut MaybeUninit<T> = unsafe { mem::transmute(&mut from) };
+        unsafe {
+            head.as_mut_ptr().write(
+                fromp
+                    .replace(MaybeUninit::uninit())
+                    .assume_init()
+            );
+        }
+        for i in 1..N {
+            unsafe {
+                tailp.add(i - 1).write(
+                    fromp
+                        .add(i)
+                        .replace(MaybeUninit::uninit())
+                        .assume_init()
+                );
+            }
+        }
+        unsafe { tail.assume_init(); } // Drop the tail
+        unsafe { head.assume_init() }
+    }
+}
+
+fn main() {}

ices/62456.rs

@@ -0,0 +1,45 @@
+#![feature(const_generics)]
+
+use std::fmt;
+
+struct Builder<const N: usize> {
+    items: [&'static str; N],
+}
+
+fn new_builder() -> Builder<{0}> {
+    return Builder{items: []};
+}
+
+impl<const N: usize> Builder<{ N }> {
+    fn append(self, value: &'static str) -> Builder<{ N + 1 }> {
+        let mut new_items = [""; N + 1];
+        new_items[..N].copy_from_slice(self.items);
+        new_items[N] = value;
+        return Builder { items: new_items };
+    }
+
+    fn build(self) -> Final<{ N }> {
+        return Final { items: self.items };
+    }
+}
+
+struct Final<const N: usize> {
+    items: [&'static str; N],
+}
+
+impl<const N: usize> fmt::Debug for Final<{ N }> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Final")
+            .field("items", &&self.items[..])
+            .finish()
+    }
+}
+
+fn main() {
+    let f = new_builder()
+        .append("abc")
+        .append("def")
+        .append("ghi")
+        .build();
+    println!("f={:?}", f);
+}

ices/62480.rs

@@ -0,0 +1,5 @@
+fn main() {
+    'a: {
+        || break 'a
+    }
+}

ices/62579.rs

@@ -0,0 +1,10 @@
+#![feature(const_generics)]
+struct NoMatch;
+
+fn foo<const T: NoMatch>() -> bool {
+    return true
+}
+
+fn main() {
+    foo::<{NoMatch}>();
+}