add more ices (#1000)

Author: matthiaskrgr

ices/90110.rs

@@ -0,0 +1,55 @@
+use std::fs::File;
+use std::io::{BufReader, BufRead};
+use std::str::Split;
+use std::path::Path;
+
+pub trait Parser<D>
+where dyn Parser<D>: Sized
+{
+    fn new(split_header: Split<&str>) -> Self where Self: Sized;
+    fn parse_line(&self, split_line: &Split<&str>) -> D;
+}
+
+
+pub struct CsvReader<D> {
+    parser: Box<dyn Parser<D>>,
+
+    reader: BufReader<File>,
+    buf: String,    // Buffer we will read into. Avoids re-allocation on each line.
+    path: String,   // Record this so we can return more informative error messages.
+    line: usize,    // Same motivation for this.
+}
+
+impl<D> CsvReader<D>
+where dyn Parser<D>: Sized 
+{
+    fn new<F>(path: &str, make_parser: F) -> CsvReader<D>
+    where F: Fn(Split<char>) -> dyn Parser<D> {
+        let file = match File::open(Path::new(path)) {
+            Err(err) => panic!("Couldn't read {}: {}", path, err),
+            Ok(file) => file,
+        };
+
+        let mut reader = BufReader::new(file);
+
+        let mut buf = String::new();
+
+        let parser = Box::new(match reader.read_line(&mut buf) {
+            Err(err) => panic!("Failed to read the header line from {}: {}", path, err),
+            Ok(_) => {
+                let split_header = buf.split(',');
+                make_parser(split_header)
+            },
+        });
+
+        CsvReader {
+            parser: parser,
+            reader,
+            buf,
+            path: path.to_string(),
+            line: 2,
+        }
+    }
+}
+
+pub fn main() {}

ices/90150.rs

@@ -0,0 +1,15 @@
+#![feature(inline_const)]
+#![feature(generic_const_exprs)]
+
+const fn foo(val: usize) -> usize { val }
+
+fn bar<const N: usize>(num: usize) -> &'static str
+where [(); foo(N)]:
+{
+    match num {
+        const { foo(N) } => "fizz",
+        _ => "buzz"
+    }
+}
+
+pub fn main() {}

ices/90177.rs

@@ -0,0 +1,17 @@
+trait Base<'f> {
+    type Assoc;
+
+    fn do_something(&self);
+}
+
+trait ForAnyLifetime: for<'f> Base<'f> {}
+
+impl<T> ForAnyLifetime for T where T: for<'f> Base<'f> {}
+
+trait CanBeDynamic: ForAnyLifetime + for<'f> Base<'f, Assoc = ()> {}
+
+fn foo(a: &dyn CanBeDynamic) {
+    a.do_something();
+}
+
+fn main() {}