5 files changed, 133 insertions, 4 deletions

diff --git a/src/parser/grammar/expressions.rs b/src/parser/grammar/expressions.rs
index 3704cb16f..2145b8d8b 100644
--- a/src/parser/grammar/expressions.rs
+++ b/src/parser/grammar/expressions.rs
@@ -14,7 +14,20 @@ pub(super) fn literal(p: &mut Parser) -> bool {
 }
 
 pub(super) fn expr(p: &mut Parser) {
-    if !literal(p) {
-        p.error("expected expression");
+    if literal(p) {
+        return;
     }
+
+    match p.current() {
+        L_PAREN => tuple_expr(p),
+        _ => p.error("expected expression"),
+    }
+}
+
+fn tuple_expr(p: &mut Parser) {
+    assert!(p.at(L_PAREN));
+    let m = p.start();
+    p.expect(L_PAREN);
+    p.expect(R_PAREN);
+    m.complete(p, TUPLE_EXPR);
 }
diff --git a/src/parser/grammar/items/mod.rs b/src/parser/grammar/items/mod.rs
index 3af6d13a1..1fe646652 100644
--- a/src/parser/grammar/items/mod.rs
+++ b/src/parser/grammar/items/mod.rs
@@ -218,9 +218,33 @@ fn fn_item(p: &mut Parser) {
         p.error("expected function arguments");
     }
 
-    if p.at(L_CURLY) {
-        p.expect(L_CURLY);
+    block(p);
+
+    fn block(p: &mut Parser) {
+        if !p.at(L_CURLY) {
+            p.error("expected block");
+        }
+        let m = p.start();
+        p.bump();
+        while !p.at(EOF) && !p.at(R_CURLY) {
+            match p.current() {
+                LET_KW => let_stmt(p),
+                _ => p.err_and_bump("expected statement"),
+            }
+        }
         p.expect(R_CURLY);
+        m.complete(p, BLOCK);
+    }
+
+    fn let_stmt(p: &mut Parser) {
+        assert!(p.at(LET_KW));
+        let m = p.start();
+        p.bump();
+        patterns::pattern(p);
+        p.expect(EQ);
+        expressions::expr(p);
+        p.expect(SEMI);
+        m.complete(p, LET_STMT);
     }
 }
 
diff --git a/src/parser/grammar/mod.rs b/src/parser/grammar/mod.rs
index ee0263203..54a63a547 100644
--- a/src/parser/grammar/mod.rs
+++ b/src/parser/grammar/mod.rs
@@ -30,6 +30,7 @@ mod items;
 mod attributes;
 mod expressions;
 mod types;
+mod patterns;
 mod paths;
 mod type_params;
 
@@ -85,10 +86,29 @@ fn abi(p: &mut Parser) {
     abi.complete(p, ABI);
 }
 
+// test fn_value_parameters
+// fn a() {}
+// fn b(x: i32) {}
+// fn c(x: i32, ) {}
+// fn d(x: i32, y: ()) {}
 fn fn_value_parameters(p: &mut Parser) {
     assert!(p.at(L_PAREN));
     p.bump();
+    while !p.at(EOF) && !p.at(R_PAREN) {
+        value_parameter(p);
+        if !p.at(R_PAREN) {
+            p.expect(COMMA);
+        }
+    }
     p.expect(R_PAREN);
+
+    fn value_parameter(p: &mut Parser) {
+        let m = p.start();
+        patterns::pattern(p);
+        p.expect(COLON);
+        types::type_(p);
+        m.complete(p, VALUE_PARAMETER);
+    }
 }
 
 fn fn_ret_type(p: &mut Parser) {
diff --git a/src/parser/grammar/patterns.rs b/src/parser/grammar/patterns.rs
new file mode 100644
index 000000000..6e4f2236b
--- /dev/null
+++ b/src/parser/grammar/patterns.rs
@@ -0,0 +1,52 @@
+use super::*;
+
+pub(super) fn pattern(p: &mut Parser) {
+    match p.current() {
+        UNDERSCORE => placeholder_pat(p),
+        AMPERSAND => ref_pat(p),
+        IDENT | REF_KW => bind_pat(p),
+        _ => p.err_and_bump("expected pattern"),
+    }
+}
+
+// test placeholder_pat
+// fn main() { let _ = (); }
+fn placeholder_pat(p: &mut Parser) {
+    assert!(p.at(UNDERSCORE));
+    let m = p.start();
+    p.bump();
+    m.complete(p, PLACEHOLDER_PAT);
+}
+
+// test ref_pat
+// fn main() {
+//     let &a = ();
+//     let &mut b = ();
+// }
+fn ref_pat(p: &mut Parser) {
+    assert!(p.at(AMPERSAND));
+    let m = p.start();
+    p.bump();
+    p.eat(MUT_KW);
+    pattern(p);
+    m.complete(p, REF_PAT);
+}
+
+// test bind_pat
+// fn main() {
+//     let a = ();
+//     let ref b = ();
+//     let ref mut c = ();
+//     let d @ _ = ();
+// }
+fn bind_pat(p: &mut Parser) {
+    let m = p.start();
+    if p.eat(REF_KW) {
+        p.eat(MUT_KW);
+    }
+    name(p);
+    if p.eat(AT) {
+        pattern(p);
+    }
+    m.complete(p, BIND_PAT);
+}
diff --git a/src/syntax_kinds.rs b/src/syntax_kinds.rs
index 537a80417..1cc29bb61 100644
--- a/src/syntax_kinds.rs
+++ b/src/syntax_kinds.rs
@@ -84,6 +84,8 @@ pub enum SyntaxKind {
     MUT_KW,
     UNSAFE_KW,
     TYPE_KW,
+    REF_KW,
+    LET_KW,
     AUTO_KW,
     DEFAULT_KW,
     UNION_KW,
@@ -110,6 +112,10 @@ pub enum SyntaxKind {
     PLACEHOLDER_TYPE,
     FN_POINTER_TYPE,
     FOR_TYPE,
+    REF_PAT,
+    BIND_PAT,
+    PLACEHOLDER_PAT,
+    TUPLE_EXPR,
     EXTERN_BLOCK,
     ENUM_VARIANT,
     NAMED_FIELD,
@@ -129,6 +135,9 @@ pub enum SyntaxKind {
     ABI,
     NAME,
     NAME_REF,
+    VALUE_PARAMETER,
+    BLOCK,
+    LET_STMT,
 
     // Technical SyntaxKinds: they appear temporally during parsing,
     // but never end up in the final tree
@@ -220,6 +229,8 @@ impl SyntaxKind {
             MUT_KW => &SyntaxInfo { name: "MUT_KW" },
             UNSAFE_KW => &SyntaxInfo { name: "UNSAFE_KW" },
             TYPE_KW => &SyntaxInfo { name: "TYPE_KW" },
+            REF_KW => &SyntaxInfo { name: "REF_KW" },
+            LET_KW => &SyntaxInfo { name: "LET_KW" },
             AUTO_KW => &SyntaxInfo { name: "AUTO_KW" },
             DEFAULT_KW => &SyntaxInfo { name: "DEFAULT_KW" },
             UNION_KW => &SyntaxInfo { name: "UNION_KW" },
@@ -246,6 +257,10 @@ impl SyntaxKind {
             PLACEHOLDER_TYPE => &SyntaxInfo { name: "PLACEHOLDER_TYPE" },
             FN_POINTER_TYPE => &SyntaxInfo { name: "FN_POINTER_TYPE" },
             FOR_TYPE => &SyntaxInfo { name: "FOR_TYPE" },
+            REF_PAT => &SyntaxInfo { name: "REF_PAT" },
+            BIND_PAT => &SyntaxInfo { name: "BIND_PAT" },
+            PLACEHOLDER_PAT => &SyntaxInfo { name: "PLACEHOLDER_PAT" },
+            TUPLE_EXPR => &SyntaxInfo { name: "TUPLE_EXPR" },
             EXTERN_BLOCK => &SyntaxInfo { name: "EXTERN_BLOCK" },
             ENUM_VARIANT => &SyntaxInfo { name: "ENUM_VARIANT" },
             NAMED_FIELD => &SyntaxInfo { name: "NAMED_FIELD" },
@@ -265,6 +280,9 @@ impl SyntaxKind {
             ABI => &SyntaxInfo { name: "ABI" },
             NAME => &SyntaxInfo { name: "NAME" },
             NAME_REF => &SyntaxInfo { name: "NAME_REF" },
+            VALUE_PARAMETER => &SyntaxInfo { name: "VALUE_PARAMETER" },
+            BLOCK => &SyntaxInfo { name: "BLOCK" },
+            LET_STMT => &SyntaxInfo { name: "LET_STMT" },
 
             TOMBSTONE => &SyntaxInfo { name: "TOMBSTONE" },
             EOF => &SyntaxInfo { name: "EOF" },
@@ -301,6 +319,8 @@ pub(crate) fn ident_to_keyword(ident: &str) -> Option<SyntaxKind> {
         "mut" => Some(MUT_KW),
         "unsafe" => Some(UNSAFE_KW),
         "type" => Some(TYPE_KW),
+        "ref" => Some(REF_KW),
+        "let" => Some(LET_KW),
         _ => None,
     }
 }