1 files changed, 379 insertions, 0 deletions

diff --git a/crates/parser/src/grammar/patterns.rs b/crates/parser/src/grammar/patterns.rs
new file mode 100644
index 000000000..716bdc978
--- /dev/null
+++ b/crates/parser/src/grammar/patterns.rs
@@ -0,0 +1,379 @@
+//! FIXME: write short doc here
+
+use super::*;
+
+pub(super) const PATTERN_FIRST: TokenSet = expressions::LITERAL_FIRST
+    .union(paths::PATH_FIRST)
+    .union(token_set![T![box], T![ref], T![mut], T!['('], T!['['], T![&], T![_], T![-], T![.]]);
+
+pub(crate) fn pattern(p: &mut Parser) {
+    pattern_r(p, PAT_RECOVERY_SET);
+}
+
+/// Parses a pattern list separated by pipes `|`
+pub(super) fn pattern_top(p: &mut Parser) {
+    pattern_top_r(p, PAT_RECOVERY_SET)
+}
+
+pub(crate) fn pattern_single(p: &mut Parser) {
+    pattern_single_r(p, PAT_RECOVERY_SET);
+}
+
+/// Parses a pattern list separated by pipes `|`
+/// using the given `recovery_set`
+pub(super) fn pattern_top_r(p: &mut Parser, recovery_set: TokenSet) {
+    p.eat(T![|]);
+    pattern_r(p, recovery_set);
+}
+
+/// Parses a pattern list separated by pipes `|`, with no leading `|`,using the
+/// given `recovery_set`
+// test or_pattern
+// fn main() {
+//     match () {
+//         (_ | _) => (),
+//         &(_ | _) => (),
+//         (_ | _,) => (),
+//         [_ | _,] => (),
+//     }
+// }
+fn pattern_r(p: &mut Parser, recovery_set: TokenSet) {
+    let m = p.start();
+    pattern_single_r(p, recovery_set);
+
+    if !p.at(T![|]) {
+        m.abandon(p);
+        return;
+    }
+    while p.eat(T![|]) {
+        pattern_single_r(p, recovery_set);
+    }
+    m.complete(p, OR_PAT);
+}
+
+fn pattern_single_r(p: &mut Parser, recovery_set: TokenSet) {
+    if let Some(lhs) = atom_pat(p, recovery_set) {
+        // test range_pat
+        // fn main() {
+        //     match 92 {
+        //         0 ... 100 => (),
+        //         101 ..= 200 => (),
+        //         200 .. 301=> (),
+        //     }
+        // }
+        for &range_op in [T![...], T![..=], T![..]].iter() {
+            if p.at(range_op) {
+                let m = lhs.precede(p);
+                p.bump(range_op);
+                atom_pat(p, recovery_set);
+                m.complete(p, RANGE_PAT);
+                return;
+            }
+        }
+    }
+}
+
+const PAT_RECOVERY_SET: TokenSet =
+    token_set![LET_KW, IF_KW, WHILE_KW, LOOP_KW, MATCH_KW, R_PAREN, COMMA];
+
+fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
+    let m = match p.nth(0) {
+        T![box] => box_pat(p),
+        T![ref] | T![mut] => bind_pat(p, true),
+        IDENT => match p.nth(1) {
+            // Checks the token after an IDENT to see if a pattern is a path (Struct { .. }) or macro
+            // (T![x]).
+            T!['('] | T!['{'] | T![!] => path_or_macro_pat(p),
+            T![:] if p.nth_at(1, T![::]) => path_or_macro_pat(p),
+            _ => bind_pat(p, true),
+        },
+
+        // test type_path_in_pattern
+        // fn main() { let <_>::Foo = (); }
+        _ if paths::is_path_start(p) => path_or_macro_pat(p),
+        _ if is_literal_pat_start(p) => literal_pat(p),
+
+        T![.] if p.at(T![..]) => dot_dot_pat(p),
+        T![_] => placeholder_pat(p),
+        T![&] => ref_pat(p),
+        T!['('] => tuple_pat(p),
+        T!['['] => slice_pat(p),
+
+        _ => {
+            p.err_recover("expected pattern", recovery_set);
+            return None;
+        }
+    };
+
+    Some(m)
+}
+
+fn is_literal_pat_start(p: &Parser) -> bool {
+    p.at(T![-]) && (p.nth(1) == INT_NUMBER || p.nth(1) == FLOAT_NUMBER)
+        || p.at_ts(expressions::LITERAL_FIRST)
+}
+
+// test literal_pattern
+// fn main() {
+//     match () {
+//         -1 => (),
+//         92 => (),
+//         'c' => (),
+//         "hello" => (),
+//     }
+// }
+fn literal_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(is_literal_pat_start(p));
+    let m = p.start();
+    if p.at(T![-]) {
+        p.bump(T![-]);
+    }
+    expressions::literal(p);
+    m.complete(p, LITERAL_PAT)
+}
+
+// test path_part
+// fn foo() {
+//     let foo::Bar = ();
+//     let ::Bar = ();
+//     let Bar { .. } = ();
+//     let Bar(..) = ();
+// }
+fn path_or_macro_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(paths::is_path_start(p));
+    let m = p.start();
+    paths::expr_path(p);
+    let kind = match p.current() {
+        T!['('] => {
+            tuple_pat_fields(p);
+            TUPLE_STRUCT_PAT
+        }
+        T!['{'] => {
+            record_field_pat_list(p);
+            RECORD_PAT
+        }
+        // test marco_pat
+        // fn main() {
+        //     let m!(x) = 0;
+        // }
+        T![!] => {
+            items::macro_call_after_excl(p);
+            return m.complete(p, MACRO_CALL).precede(p).complete(p, MACRO_PAT);
+        }
+        _ => PATH_PAT,
+    };
+    m.complete(p, kind)
+}
+
+// test tuple_pat_fields
+// fn foo() {
+//     let S() = ();
+//     let S(_) = ();
+//     let S(_,) = ();
+//     let S(_, .. , x) = ();
+// }
+fn tuple_pat_fields(p: &mut Parser) {
+    assert!(p.at(T!['(']));
+    p.bump(T!['(']);
+    pat_list(p, T![')']);
+    p.expect(T![')']);
+}
+
+// test record_field_pat_list
+// fn foo() {
+//     let S {} = ();
+//     let S { f, ref mut g } = ();
+//     let S { h: _, ..} = ();
+//     let S { h: _, } = ();
+// }
+fn record_field_pat_list(p: &mut Parser) {
+    assert!(p.at(T!['{']));
+    let m = p.start();
+    p.bump(T!['{']);
+    while !p.at(EOF) && !p.at(T!['}']) {
+        match p.current() {
+            // A trailing `..` is *not* treated as a REST_PAT.
+            T![.] if p.at(T![..]) => p.bump(T![..]),
+            T!['{'] => error_block(p, "expected ident"),
+
+            c => {
+                let m = p.start();
+                match c {
+                    // test record_field_pat
+                    // fn foo() {
+                    //     let S { 0: 1 } = ();
+                    //     let S { x: 1 } = ();
+                    // }
+                    IDENT | INT_NUMBER if p.nth(1) == T![:] => {
+                        name_ref_or_index(p);
+                        p.bump(T![:]);
+                        pattern(p);
+                    }
+                    T![box] => {
+                        // FIXME: not all box patterns should be allowed
+                        box_pat(p);
+                    }
+                    _ => {
+                        bind_pat(p, false);
+                    }
+                }
+                m.complete(p, RECORD_PAT_FIELD);
+            }
+        }
+        if !p.at(T!['}']) {
+            p.expect(T![,]);
+        }
+    }
+    p.expect(T!['}']);
+    m.complete(p, RECORD_PAT_FIELD_LIST);
+}
+
+// test placeholder_pat
+// fn main() { let _ = (); }
+fn placeholder_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(T![_]));
+    let m = p.start();
+    p.bump(T![_]);
+    m.complete(p, WILDCARD_PAT)
+}
+
+// test dot_dot_pat
+// fn main() {
+//     let .. = ();
+//     //
+//     // Tuples
+//     //
+//     let (a, ..) = ();
+//     let (a, ..,) = ();
+//     let Tuple(a, ..) = ();
+//     let Tuple(a, ..,) = ();
+//     let (.., ..) = ();
+//     let Tuple(.., ..) = ();
+//     let (.., a, ..) = ();
+//     let Tuple(.., a, ..) = ();
+//     //
+//     // Slices
+//     //
+//     let [..] = ();
+//     let [head, ..] = ();
+//     let [head, tail @ ..] = ();
+//     let [head, .., cons] = ();
+//     let [head, mid @ .., cons] = ();
+//     let [head, .., .., cons] = ();
+//     let [head, .., mid, tail @ ..] = ();
+//     let [head, .., mid, .., cons] = ();
+// }
+fn dot_dot_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(T![..]));
+    let m = p.start();
+    p.bump(T![..]);
+    m.complete(p, REST_PAT)
+}
+
+// test ref_pat
+// fn main() {
+//     let &a = ();
+//     let &mut b = ();
+// }
+fn ref_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(T![&]));
+    let m = p.start();
+    p.bump(T![&]);
+    p.eat(T![mut]);
+    pattern_single(p);
+    m.complete(p, REF_PAT)
+}
+
+// test tuple_pat
+// fn main() {
+//     let (a, b, ..) = ();
+//     let (a,) = ();
+//     let (..) = ();
+//     let () = ();
+// }
+fn tuple_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(T!['(']));
+    let m = p.start();
+    p.bump(T!['(']);
+    let mut has_comma = false;
+    let mut has_pat = false;
+    let mut has_rest = false;
+    while !p.at(EOF) && !p.at(T![')']) {
+        has_pat = true;
+        if !p.at_ts(PATTERN_FIRST) {
+            p.error("expected a pattern");
+            break;
+        }
+        has_rest |= p.at(T![..]);
+
+        pattern(p);
+        if !p.at(T![')']) {
+            has_comma = true;
+            p.expect(T![,]);
+        }
+    }
+    p.expect(T![')']);
+
+    m.complete(p, if !has_comma && !has_rest && has_pat { PAREN_PAT } else { TUPLE_PAT })
+}
+
+// test slice_pat
+// fn main() {
+//     let [a, b, ..] = [];
+// }
+fn slice_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(T!['[']));
+    let m = p.start();
+    p.bump(T!['[']);
+    pat_list(p, T![']']);
+    p.expect(T![']']);
+    m.complete(p, SLICE_PAT)
+}
+
+fn pat_list(p: &mut Parser, ket: SyntaxKind) {
+    while !p.at(EOF) && !p.at(ket) {
+        if !p.at_ts(PATTERN_FIRST) {
+            p.error("expected a pattern");
+            break;
+        }
+
+        pattern(p);
+        if !p.at(ket) {
+            p.expect(T![,]);
+        }
+    }
+}
+
+// test bind_pat
+// fn main() {
+//     let a = ();
+//     let mut b = ();
+//     let ref c = ();
+//     let ref mut d = ();
+//     let e @ _ = ();
+//     let ref mut f @ g @ _ = ();
+// }
+fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
+    let m = p.start();
+    p.eat(T![ref]);
+    p.eat(T![mut]);
+    name(p);
+    if with_at && p.eat(T![@]) {
+        pattern_single(p);
+    }
+    m.complete(p, IDENT_PAT)
+}
+
+// test box_pat
+// fn main() {
+//     let box i = ();
+//     let box Outer { box i, j: box Inner(box &x) } = ();
+//     let box ref mut i = ();
+// }
+fn box_pat(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(T![box]));
+    let m = p.start();
+    p.bump(T![box]);
+    pattern_single(p);
+    m.complete(p, BOX_PAT)
+}