Document behavior of ! with MbE

tests/ui/rfcs/rfc-0000-never_patterns/macros.e2018.stderr

@@ -0,0 +1,9 @@
+error[E0308]: mismatched types
+  --> $DIR/macros.rs:34:39
+   |
+LL |     assert_eq!(detect_pat!(true | !), Pattern);
+   |                                       ^^^^^^^ expected `Other`, found `Pattern`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.

tests/ui/rfcs/rfc-0000-never_patterns/macros.rs

@@ -0,0 +1,46 @@
+// revisions: e2018 e2021
+//[e2018] edition:2018
+//[e2021] edition:2021
+//[e2021] check-pass
+#![feature(never_patterns)]
+#![allow(incomplete_features)]
+
+#[derive(Debug, PartialEq, Eq)]
+struct Pattern;
+#[derive(Debug, PartialEq, Eq)]
+struct Never;
+#[derive(Debug, PartialEq, Eq)]
+struct Other;
+
+macro_rules! detect_pat {
+    ($p:pat) => {
+        Pattern
+    };
+    (!) => {
+        Never
+    };
+    ($($x:tt)*) => {
+        Other
+    };
+}
+
+fn main() {
+    // For backwards compatibility this does not match `$p:pat`. This is similar to how or-patterns
+    // without parens don't match `$p:pat` either.
+    assert_eq!(detect_pat!(!), Never);
+
+    // Edition 2018 parses the first one as `Other`.
+    // FIXME(never_patterns): Neither edition parses the second one as a pattern.
+    assert_eq!(detect_pat!(true | !), Pattern);
+    //[e2018]~^ ERROR mismatched types
+    assert_eq!(detect_pat!(! | true), Other);
+
+    // These are never patterns; they take no body when they're in a match arm.
+    assert_eq!(detect_pat!((!)), Pattern);
+    assert_eq!(detect_pat!((true, !)), Pattern);
+    assert_eq!(detect_pat!(Some(!)), Pattern);
+
+    // These count as normal patterns.
+    assert_eq!(detect_pat!((! | true)), Pattern);
+    assert_eq!(detect_pat!((Ok(x) | Err(&!))), Pattern);
+}

tests/ui/rfcs/rfc-0000-never_patterns/parse.rs

@@ -68,4 +68,9 @@ fn parse(x: Void) {
     //~^ ERROR top-level or-patterns are not allowed in `let` bindings
     let (Ok(_) | Err(!)) = &res;
     let (Ok(_) | Err(&!)) = res.as_ref();
+
+    let ! = x;
+    let y @ ! = x;
 }
+
+fn foo(!: Void) {}