add meeting notes

Author: lcnr

meetings/2021.02.09-lazy-norm.md

@@ -1,4 +1,4 @@
-# cg meeting 09.02.2020
+# cg meeting 09.02.2020 ([zulip thread](https://rust-lang.zulipchat.com/#narrow/stream/260443-project-const-generics/topic/meeting.202021-02-09))
 
 *mostly taken from https://hackmd.io/9LIywezOQj-h5HX8vvEnSw?view*
 

meetings/2021.02.16-lazy-norm.md

@@ -1,4 +1,4 @@
-# cg meeting 2021-02-16
+# cg meeting 2021-02-16 ([zulip thread](https://rust-lang.zulipchat.com/#narrow/stream/260443-project-const-generics/topic/meeting.202021-02-16))
 
 ## issue
 

meetings/2021.02.23-ct-in-where-bounds.md

@@ -0,0 +1,95 @@
+# cg meeting 2021-02-23 ([zulip thread](https://rust-lang.zulipchat.com/#narrow/stream/260443-project-const-generics/topic/meeting.202021-02-23))
+
+## anon consts in where bounds
+
+with anon consts being inside of their own where-bounds (since they inherit where bounds from their parent item) they can quite easily cause cycle errors (https://github.com/rust-lang/rust/issues/79356):
+```rust
+#![feature(const_generics)]
+struct Foo<T>(T);
+
+fn test() where [u8; {
+    // `Foo<X>` requires `X: Sized`.
+    //
+    // We have a `[u8; unevaluated]: Sized` predicate in the
+    // where bounds, we try to unify `[u8; 7]` with that array,
+    // causing a cycle.
+    //
+    // We prioritize candidates from the where-bounds over global ones
+    // which is why we don't just use the builtin candidate for `array: Sized`.
+    let _: Foo<[u8; 7]>; 
+    3
+}]: Sized {}
+```
+we can't just remove any bounds containing the anon const itself, as this wouldn't prevent cycles for
+```rust
+#![feature(const_generics)]
+struct Foo<T>(T);
+
+fn test() where [u8; {
+    let _: Foo<[u8; 7]>;
+    3
+}]: Sized,
+[u8; {
+    let _: Foo<[u8; 7]>;
+    4
+}]: Sized  {}
+```
+
+### Can we just not worry about this while stabilizing lazy norm
+
+I think just removing bounds containing the anon const itseft might not be an issue, as using that predicate probably caused a cycle so there won't be any code relying on this. Removing additional predicates which might cycle is a lot scarier and probably not possible after we stabilized lazy norm.
+
+Even if we can fix this without breaking back-compat, the user experience when encountering cycle errors is probably bad enough for us to still fix this first.
+These cycles happen for code currently compiling on stable, so this would also require a crater run.
+
+### the cycle
+
+```
+error[E0391]: cycle detected when simplifying constant for the type system `test::{constant#0}`
+  --> src/lib.rs:4:22
+   |
+4  |   fn test() where [u8; {
+   |  ______________________^
+5  | |     // `Foo<X>` requires `X: Sized`.
+6  | |     //
+7  | |     // We have a `[u8; unevaluated]: Sized` predicate in the
+...  |
+11 | |     3
+12 | | }]: Sized {}
+   | |_^
+   |
+note: ...which requires const-evaluating + checking `test::{constant#0}`...
+  --> src/lib.rs:4:22
+   |
+4  |   fn test() where [u8; {
+   |  ______________________^
+5  | |     // `Foo<X>` requires `X: Sized`.
+6  | |     //
+7  | |     // We have a `[u8; unevaluated]: Sized` predicate in the
+...  |
+11 | |     3
+12 | | }]: Sized {}
+   | |_^
+note: ...which requires type-checking `test::{constant#0}`...
+  --> src/lib.rs:4:22
+   |
+4  |   fn test() where [u8; {
+   |  ______________________^
+5  | |     // `Foo<X>` requires `X: Sized`.
+6  | |     //
+7  | |     // We have a `[u8; unevaluated]: Sized` predicate in the
+...  |
+11 | |     3
+12 | | }]: Sized {}
+   | |_^
+   = note: ...which requires evaluating trait selection obligation `[u8; 7]: std::marker::Sized`...
+   = note: ...which again requires simplifying constant for the type system `test::{constant#0}`, completing the cycle
+   ```
+
+### Results
+
+Using chalk we can solve this by allowing our query system to deal with cycles by trying something different when encountering them. This still has some open problems and is probably still somewhat far in the future.
+
+We did not have other promising ideas on how to otherwise solve this without being too restrictive.
+
+Requires some additional thought outside of the meeting.