Merge pull request #1520 from JohnTitor/add-ices-20230303

Author: JohnTitor

ices/103507.rs

@@ -0,0 +1,33 @@
+#![feature(type_alias_impl_trait)]
+#![feature(const_trait_impl)]
+#![feature(const_refs_to_cell)]
+#![feature(inline_const)]
+
+use std::marker::Destruct;
+
+trait T {
+    type Item;
+}
+
+type Alias<'a> = impl T<Item = &'a ()>;
+
+struct S;
+impl<'a> T for &'a S {
+    type Item = &'a ();
+}
+
+const fn filter_positive<'a>() -> &'a Alias<'a> {
+    &&S
+}
+
+const fn with_positive<F: ~const for<'a> Fn(&'a Alias<'a>) + ~const Destruct>(fun: F) {
+    fun(filter_positive());
+}
+
+const fn foo(_: &Alias<'_>) {}
+
+const BAR: () = {
+    with_positive(foo);
+};
+
+fn main() {}

ices/106874.rs

@@ -0,0 +1,35 @@
+use std::marker::PhantomData;
+use std::rc::Rc;
+
+pub fn func<V, F: Fn(&mut V)>(f: F) -> A<impl X> {
+    A(B(C::new(D::new(move |st| f(st)))))
+}
+
+trait X {}
+trait Y {
+    type V;
+}
+
+struct A<T>(T);
+
+struct B<T>(Rc<T>);
+impl<T> X for B<T> {}
+
+struct C<T: Y>(T::V);
+impl<T: Y> C<T> {
+    fn new(_: T) -> Rc<Self> {
+        todo!()
+    }
+}
+struct D<V, F>(F, PhantomData<fn(&mut V)>);
+
+impl<V, F> D<V, F> {
+    fn new(_: F) -> Self {
+        todo!()
+    }
+}
+impl<V, F: Fn(&mut V)> Y for D<V, F> {
+    type V = V;
+}
+
+fn main() {}

ices/107228.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+rustc -Zvalidate-mir --crate-type=lib - <<'EOF'
+
+#![feature(specialization)]
+
+pub(crate) trait SpecTrait {
+    type Assoc;
+}
+
+impl<C> SpecTrait for C {
+    default type Assoc = Vec<Self>;
+}
+
+pub(crate) struct AssocWrap<C: SpecTrait> {
+    _assoc: C::Assoc,
+}
+
+fn instantiate<C: SpecTrait>() -> AssocWrap<C> {
+    loop {}
+}
+
+pub fn trigger() {
+    instantiate::<()>();
+}
+EOF

ices/108271-1.rs

@@ -0,0 +1,7 @@
+pub trait TraitWAssocConst<T> {
+    const A: T;
+}
+
+fn foo<T, B: TraitWAssocConst<T, A = { 1 }>>() {}
+
+fn main() {}

ices/108271-2.rs

@@ -0,0 +1,10 @@
+#![feature(generic_const_exprs)]
+#![allow(incomplete_features)]
+
+pub trait TraitWAssocConst {
+    const A: dyn TraitWAssocConst<A = 0>;
+}
+
+fn bar<A: TraitWAssocConst<A = 0>>() {}
+
+fn main() {}

ices/108329.rs

@@ -0,0 +1,100 @@
+#![feature(generic_const_exprs)]
+#![allow(incomplete_features)]
+
+pub enum Restriction<const V: bool = true> {}
+pub trait Valid {}
+
+impl Valid for Restriction<true> {}
+
+/**
+    a circular buffer
+*/
+pub struct CircularBuffer<T, const S: usize> {
+    buffer: Vec<T>,
+    index: usize,
+}
+
+impl<T, const S: usize> CircularBuffer<T, { S }>
+where
+    Restriction<{ S > 0 }>: Valid,
+{
+    /**
+        create a new [`CircularBuffer`] instance
+    */
+    pub fn new() -> Self {
+        Self {
+            buffer: Vec::with_capacity(S),
+            index: S - 1,
+        }
+    }
+
+    /**
+        push a value onto the buffer
+    */
+    pub fn push(&mut self, value: T) {
+        self.index = self.index.checked_add(1).unwrap_or(0) % S;
+        match self.count() < self.capacity() {
+            true => self.buffer.insert(self.index, value),
+            false => self.buffer[self.index] = value,
+        }
+    }
+
+    /**
+        push a value onto the buffer
+    */
+    pub fn pop(&mut self) -> Result<T, CircularBufferError> {
+        if self.count() == 0 {
+            Err(CircularBufferError::Underflow)?
+        }
+
+        let old = self.buffer.remove(self.index);
+        self.index = self.index.checked_sub(1).unwrap_or(S - 1);
+        Ok(old)
+    }
+}
+
+impl<T, const S: usize> CircularBuffer<T, { S }> {
+    /**
+        returns the current count of the buffer
+    */
+    pub fn count(&self) -> usize {
+        self.buffer.len()
+    }
+
+    /**
+        returns the max capacity of the buffer
+    */
+    pub const fn capacity(&self) -> usize {
+        S
+    }
+}
+
+impl<T, const S: usize> CircularBuffer<T, { S }>
+where
+    T: Clone,
+{
+    /**
+        take the values in a vec, leaving an empty buffer
+    */
+    pub fn take(&mut self) -> Vec<T> {
+        let mut buf = Vec::with_capacity(self.buffer.len());
+        buf.copy_from_slice(self.buffer[..]);
+        self.index = S - 1;
+        buf
+    }
+
+    /**
+        returns true if the buffer is empty
+    */
+    pub fn is_empty(&self) -> bool {
+        self.buffer.is_empty()
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub enum CircularBufferError {
+    /// attempted to pop when buffer is empty
+    Underflow,
+}
+
+fn main() {}

ices/108334.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+cat > Cargo.toml <<'EOF'
+[package]
+name = "kandis"
+version = "0.0.1"
+edition = "2021"
+EOF
+
+mkdir -p src
+
+cat > src/main.rs <<'EOF'
+mod foo_1;
+
+/// Hello [`Bar`]. // crash
+pub use foo_1::Bar;
+EOF
+
+cat > src/foo_1.rs <<'EOF'
+pub trait Bar {}
+EOF
+
+cargo doc

ices/79495.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+cat > out.rs <<'EOF'
+#![feature(arbitrary_enum_discriminant, generic_const_exprs, core_intrinsics)]
+
+extern crate core;
+use core::intrinsics::discriminant_value;
+
+#[repr(usize)]
+enum MyWeirdOption<T> {
+    None = 0,
+    Some(T) = std::mem::size_of::<T>(),
+    //~^ ERROR constant expression depends on a generic parameter
+}
+
+fn main() {
+    assert_eq!(discriminant_value(&MyWeirdOption::<u8>::None), 0);
+    assert_eq!(discriminant_value(&MyWeirdOption::Some(0u8)), 1);
+}
+
+EOF
+
+rustdoc --edition=2021 out.rs