lambda expressions

11 files changed, 261 insertions, 123 deletions

diff --git a/src/grammar.ron b/src/grammar.ron
index df7b4083b..24f11f63e 100644
--- a/src/grammar.ron
+++ b/src/grammar.ron
@@ -131,6 +131,7 @@ Grammar(
         "FIELD_EXPR",
         "REF_EXPR",
         "DEREF_EXPR",
+        "LAMBDA_EXPR",
         "STRUCT_LIT",
         "STRUCT_LIT_FIELD",
 
@@ -150,7 +151,6 @@ Grammar(
         "ABI",
         "NAME",
         "NAME_REF",
-        "VALUE_PARAMETER",
         "BLOCK",
 
         "LET_STMT",
@@ -165,6 +165,7 @@ Grammar(
         "ASSOC_TYPE_ARG",
 
         "PARAM_LIST",
+        "VALUE_PARAMETER",
         "SELF_PARAM",
         "ARG_LIST",
     ]
diff --git a/src/parser/grammar/expressions.rs b/src/parser/grammar/expressions.rs
index ef3a0f76c..09b351f31 100644
--- a/src/parser/grammar/expressions.rs
+++ b/src/parser/grammar/expressions.rs
@@ -44,6 +44,63 @@ pub(super) fn expr(p: &mut Parser) {
     }
 }
 
+// test block
+// fn a() {}
+// fn b() { let _ = 1; }
+// fn c() { 1; 2; }
+// fn d() { 1; 2 }
+pub(super) 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),
+            c => {
+                // test block_items
+                // fn a() { fn b() {} }
+                if items::ITEM_FIRST.contains(c) {
+                    items::item(p)
+                } else {
+                    let expr_stmt = p.start();
+                    expressions::expr(p);
+                    if p.eat(SEMI) {
+                        expr_stmt.complete(p, EXPR_STMT);
+                    } else {
+                        expr_stmt.abandon(p);
+                    }
+                }
+            }
+        }
+    }
+    p.expect(R_CURLY);
+    m.complete(p, BLOCK);
+}
+
+// test let_stmt;
+// fn foo() {
+//     let a;
+//     let b: i32;
+//     let c = 92;
+//     let d: i32 = 92;
+// }
+fn let_stmt(p: &mut Parser) {
+    assert!(p.at(LET_KW));
+    let m = p.start();
+    p.bump();
+    patterns::pattern(p);
+    if p.at(COLON) {
+        types::ascription(p);
+    }
+    if p.eat(EQ) {
+        expressions::expr(p);
+    }
+    p.expect(SEMI);
+    m.complete(p, LET_STMT);
+}
+
 fn prefix_expr(p: &mut Parser) -> Option<CompletedMarker> {
     match p.current() {
         AMPERSAND => Some(ref_expr(p)),
@@ -89,6 +146,7 @@ fn atom_expr(p: &mut Parser) -> Option<CompletedMarker> {
 
     match p.current() {
         L_PAREN => Some(tuple_expr(p)),
+        PIPE => Some(lambda_expr(p)),
         _ => {
             p.err_and_bump("expected expression");
             None
@@ -104,6 +162,25 @@ fn tuple_expr(p: &mut Parser) -> CompletedMarker {
     m.complete(p, TUPLE_EXPR)
 }
 
+// test lambda_expr
+// fn foo() {
+//     || ();
+//     || -> i32 { 92 };
+//     |x| x;
+//     |x: i32,| x;
+// }
+fn lambda_expr(p: &mut Parser) -> CompletedMarker {
+    assert!(p.at(PIPE));
+    let m = p.start();
+    params::list_opt_types(p);
+    if fn_ret_type(p) {
+        block(p);
+    } else {
+        expr(p)
+    }
+    m.complete(p, LAMBDA_EXPR)
+}
+
 // test call_expr
 // fn foo() {
 //     let _ = f();
diff --git a/src/parser/grammar/items/mod.rs b/src/parser/grammar/items/mod.rs
index d1da1ecb4..8c2704be5 100644
--- a/src/parser/grammar/items/mod.rs
+++ b/src/parser/grammar/items/mod.rs
@@ -15,7 +15,7 @@ pub(super) fn mod_contents(p: &mut Parser, stop_on_r_curly: bool) {
 pub(super) const ITEM_FIRST: TokenSet =
     token_set![EXTERN_KW, MOD_KW, USE_KW, STRUCT_KW, ENUM_KW, FN_KW, PUB_KW, POUND];
 
-fn item(p: &mut Parser) {
+pub(super) fn item(p: &mut Parser) {
     let item = p.start();
     attributes::outer_attributes(p);
     visibility(p);
@@ -239,7 +239,7 @@ fn fn_item(p: &mut Parser) {
     type_params::list(p);
 
     if p.at(L_PAREN) {
-        fn_value_parameters(p);
+        params::list(p);
     } else {
         p.error("expected function arguments");
     }
@@ -252,64 +252,7 @@ fn fn_item(p: &mut Parser) {
     // fn foo<T>() where T: Copy {}
     type_params::where_clause(p);
 
-    block(p);
-
-    // test block
-    // fn a() {}
-    // fn b() { let _ = 1; }
-    // fn c() { 1; 2; }
-    // fn d() { 1; 2 }
-    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),
-                c => {
-                    // test block_items
-                    // fn a() { fn b() {} }
-                    if ITEM_FIRST.contains(c) {
-                        item(p)
-                    } else {
-                        let expr_stmt = p.start();
-                        expressions::expr(p);
-                        if p.eat(SEMI) {
-                            expr_stmt.complete(p, EXPR_STMT);
-                        } else {
-                            expr_stmt.abandon(p);
-                        }
-                    }
-                }
-            }
-        }
-        p.expect(R_CURLY);
-        m.complete(p, BLOCK);
-    }
-
-    // test let_stmt;
-    // fn foo() {
-    //     let a;
-    //     let b: i32;
-    //     let c = 92;
-    //     let d: i32 = 92;
-    // }
-    fn let_stmt(p: &mut Parser) {
-        assert!(p.at(LET_KW));
-        let m = p.start();
-        p.bump();
-        patterns::pattern(p);
-        if p.at(COLON) {
-            types::ascription(p);
-        }
-        if p.eat(EQ) {
-            expressions::expr(p);
-        }
-        p.expect(SEMI);
-        m.complete(p, LET_STMT);
-    }
+    expressions::block(p);
 }
 
 // test type_item
diff --git a/src/parser/grammar/mod.rs b/src/parser/grammar/mod.rs
index 69942e7f1..d4f9b80cf 100644
--- a/src/parser/grammar/mod.rs
+++ b/src/parser/grammar/mod.rs
@@ -26,8 +26,9 @@ mod expressions;
 mod items;
 mod paths;
 mod patterns;
-mod type_args;
+mod params;
 mod type_params;
+mod type_args;
 mod types;
 
 use {
@@ -95,67 +96,13 @@ 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));
-    let m = p.start();
-    p.bump();
-    self_param(p);
-    while !p.at(EOF) && !p.at(R_PAREN) {
-        value_parameter(p);
-        if !p.at(R_PAREN) {
-            p.expect(COMMA);
-        }
-    }
-    p.expect(R_PAREN);
-    m.complete(p, PARAM_LIST);
-
-    fn value_parameter(p: &mut Parser) {
-        let m = p.start();
-        patterns::pattern(p);
-        p.expect(COLON);
-        types::type_(p);
-        m.complete(p, VALUE_PARAMETER);
-    }
-
-    // test self_param
-    // impl S {
-    //     fn a(self) {}
-    //     fn b(&self,) {}
-    //     fn c(&'a self,) {}
-    //     fn d(&'a mut self, x: i32) {}
-    // }
-    fn self_param(p: &mut Parser) {
-        let la1 = p.nth(1);
-        let la2 = p.nth(2);
-        let la3 = p.nth(3);
-        let n_toks = match (p.current(), la1, la2, la3) {
-            (SELF_KW, _, _, _) => 1,
-            (AMPERSAND, SELF_KW, _, _) => 2,
-            (AMPERSAND, MUT_KW, SELF_KW, _) => 3,
-            (AMPERSAND, LIFETIME, SELF_KW, _) => 3,
-            (AMPERSAND, LIFETIME, MUT_KW, SELF_KW) => 4,
-            _ => return,
-        };
-        let m = p.start();
-        for _ in 0..n_toks {
-            p.bump();
-        }
-        m.complete(p, SELF_PARAM);
-        if !p.at(R_PAREN) {
-            p.expect(COMMA);
-        }
-    }
-}
-
-fn fn_ret_type(p: &mut Parser) {
+fn fn_ret_type(p: &mut Parser) -> bool {
     if p.at(THIN_ARROW) {
         p.bump();
         types::type_(p);
+        true
+    } else {
+        false
     }
 }
 
diff --git a/src/parser/grammar/params.rs b/src/parser/grammar/params.rs
new file mode 100644
index 000000000..1ef2cea88
--- /dev/null
+++ b/src/parser/grammar/params.rs
@@ -0,0 +1,71 @@
+use super::*;
+
+// test param_list
+// fn a() {}
+// fn b(x: i32) {}
+// fn c(x: i32, ) {}
+// fn d(x: i32, y: ()) {}
+pub(super) fn list(p: &mut Parser) {
+    list_(p, true)
+}
+
+pub(super) fn list_opt_types(p: &mut Parser) {
+    list_(p, false)
+}
+
+fn list_(p: &mut Parser, require_types: bool) {
+    assert!(p.at(if require_types { L_PAREN } else { PIPE }));
+    let m = p.start();
+    p.bump();
+    if require_types {
+        self_param(p);
+    }
+    let terminator = if require_types { R_PAREN } else { PIPE };
+    while !p.at(EOF) && !p.at(terminator) {
+        value_parameter(p, require_types);
+        if !p.at(terminator) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(terminator);
+    m.complete(p, PARAM_LIST);
+}
+
+fn value_parameter(p: &mut Parser, require_type: bool) {
+    let m = p.start();
+    patterns::pattern(p);
+    if p.at(COLON) || require_type {
+        types::ascription(p)
+    }
+    m.complete(p, VALUE_PARAMETER);
+}
+
+// test self_param
+// impl S {
+//     fn a(self) {}
+//     fn b(&self,) {}
+//     fn c(&'a self,) {}
+//     fn d(&'a mut self, x: i32) {}
+// }
+fn self_param(p: &mut Parser) {
+    let la1 = p.nth(1);
+    let la2 = p.nth(2);
+    let la3 = p.nth(3);
+    let n_toks = match (p.current(), la1, la2, la3) {
+        (SELF_KW, _, _, _) => 1,
+        (AMPERSAND, SELF_KW, _, _) => 2,
+        (AMPERSAND, MUT_KW, SELF_KW, _) => 3,
+        (AMPERSAND, LIFETIME, SELF_KW, _) => 3,
+        (AMPERSAND, LIFETIME, MUT_KW, SELF_KW) => 4,
+        _ => return,
+    };
+    let m = p.start();
+    for _ in 0..n_toks {
+        p.bump();
+    }
+    m.complete(p, SELF_PARAM);
+    if !p.at(R_PAREN) {
+        p.expect(COMMA);
+    }
+}
+
diff --git a/src/parser/grammar/types.rs b/src/parser/grammar/types.rs
index 31871ceec..6535f6872 100644
--- a/src/parser/grammar/types.rs
+++ b/src/parser/grammar/types.rs
@@ -166,7 +166,7 @@ fn fn_pointer_type(p: &mut Parser) {
         return;
     }
 
-    fn_value_parameters(p);
+    params::list(p);
     // test fn_pointer_type_with_ret
     // type F = fn() -> ();
     fn_ret_type(p);
diff --git a/src/syntax_kinds/generated.rs b/src/syntax_kinds/generated.rs
index 156d42db4..93a3250a4 100644
--- a/src/syntax_kinds/generated.rs
+++ b/src/syntax_kinds/generated.rs
@@ -122,6 +122,7 @@ pub enum SyntaxKind {
     FIELD_EXPR,
     REF_EXPR,
     DEREF_EXPR,
+    LAMBDA_EXPR,
     STRUCT_LIT,
     STRUCT_LIT_FIELD,
     EXTERN_BLOCK,
@@ -140,7 +141,6 @@ pub enum SyntaxKind {
     ABI,
     NAME,
     NAME_REF,
-    VALUE_PARAMETER,
     BLOCK,
     LET_STMT,
     EXPR_STMT,
@@ -152,6 +152,7 @@ pub enum SyntaxKind {
     TYPE_ARG,
     ASSOC_TYPE_ARG,
     PARAM_LIST,
+    VALUE_PARAMETER,
     SELF_PARAM,
     ARG_LIST,
     // Technical SyntaxKinds: they appear temporally during parsing,
@@ -283,6 +284,7 @@ impl SyntaxKind {
             FIELD_EXPR => &SyntaxInfo { name: "FIELD_EXPR" },
             REF_EXPR => &SyntaxInfo { name: "REF_EXPR" },
             DEREF_EXPR => &SyntaxInfo { name: "DEREF_EXPR" },
+            LAMBDA_EXPR => &SyntaxInfo { name: "LAMBDA_EXPR" },
             STRUCT_LIT => &SyntaxInfo { name: "STRUCT_LIT" },
             STRUCT_LIT_FIELD => &SyntaxInfo { name: "STRUCT_LIT_FIELD" },
             EXTERN_BLOCK => &SyntaxInfo { name: "EXTERN_BLOCK" },
@@ -301,7 +303,6 @@ 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" },
             EXPR_STMT => &SyntaxInfo { name: "EXPR_STMT" },
@@ -313,6 +314,7 @@ impl SyntaxKind {
             TYPE_ARG => &SyntaxInfo { name: "TYPE_ARG" },
             ASSOC_TYPE_ARG => &SyntaxInfo { name: "ASSOC_TYPE_ARG" },
             PARAM_LIST => &SyntaxInfo { name: "PARAM_LIST" },
+            VALUE_PARAMETER => &SyntaxInfo { name: "VALUE_PARAMETER" },
             SELF_PARAM => &SyntaxInfo { name: "SELF_PARAM" },
             ARG_LIST => &SyntaxInfo { name: "ARG_LIST" },
             TOMBSTONE => &SyntaxInfo { name: "TOMBSTONE" },
diff --git a/tests/data/parser/inline/0063_lambda_expr.rs b/tests/data/parser/inline/0063_lambda_expr.rs
new file mode 100644
index 000000000..3c30a9209
--- /dev/null
+++ b/tests/data/parser/inline/0063_lambda_expr.rs
@@ -0,0 +1,6 @@
+fn foo() {
+    || ();
+    || -> i32 { 92 };
+    |x| x;
+    |x: i32,| x;
+}
diff --git a/tests/data/parser/inline/0063_lambda_expr.txt b/tests/data/parser/inline/0063_lambda_expr.txt
new file mode 100644
index 000000000..b1edffc14
--- /dev/null
+++ b/tests/data/parser/inline/0063_lambda_expr.txt
@@ -0,0 +1,91 @@
+FILE@[0; 74)
+  FN_ITEM@[0; 74)
+    FN_KW@[0; 2)
+    NAME@[2; 6)
+      WHITESPACE@[2; 3)
+      IDENT@[3; 6) "foo"
+    PARAM_LIST@[6; 9)
+      L_PAREN@[6; 7)
+      R_PAREN@[7; 8)
+      WHITESPACE@[8; 9)
+    BLOCK@[9; 74)
+      L_CURLY@[9; 10)
+      EXPR_STMT@[10; 26)
+        LAMBDA_EXPR@[10; 20)
+          PARAM_LIST@[10; 18)
+            WHITESPACE@[10; 15)
+            PIPE@[15; 16)
+            PIPE@[16; 17)
+            WHITESPACE@[17; 18)
+          TUPLE_EXPR@[18; 20)
+            L_PAREN@[18; 19)
+            R_PAREN@[19; 20)
+        SEMI@[20; 21)
+        WHITESPACE@[21; 26)
+      EXPR_STMT@[26; 48)
+        LAMBDA_EXPR@[26; 42)
+          PARAM_LIST@[26; 29)
+            PIPE@[26; 27)
+            PIPE@[27; 28)
+            WHITESPACE@[28; 29)
+          THIN_ARROW@[29; 31)
+          PATH_TYPE@[31; 36)
+            PATH@[31; 36)
+              PATH_SEGMENT@[31; 36)
+                NAME_REF@[31; 36)
+                  WHITESPACE@[31; 32)
+                  IDENT@[32; 35) "i32"
+                  WHITESPACE@[35; 36)
+          BLOCK@[36; 42)
+            L_CURLY@[36; 37)
+            LITERAL@[37; 41)
+              WHITESPACE@[37; 38)
+              INT_NUMBER@[38; 40)
+              WHITESPACE@[40; 41)
+            R_CURLY@[41; 42)
+        SEMI@[42; 43)
+        WHITESPACE@[43; 48)
+      EXPR_STMT@[48; 59)
+        LAMBDA_EXPR@[48; 53)
+          PARAM_LIST@[48; 52)
+            PIPE@[48; 49)
+            VALUE_PARAMETER@[49; 50)
+              BIND_PAT@[49; 50)
+                NAME@[49; 50)
+                  IDENT@[49; 50) "x"
+            PIPE@[50; 51)
+            WHITESPACE@[51; 52)
+          PATH_EXPR@[52; 53)
+            PATH@[52; 53)
+              PATH_SEGMENT@[52; 53)
+                NAME_REF@[52; 53)
+                  IDENT@[52; 53) "x"
+        SEMI@[53; 54)
+        WHITESPACE@[54; 59)
+      EXPR_STMT@[59; 72)
+        LAMBDA_EXPR@[59; 70)
+          PARAM_LIST@[59; 69)
+            PIPE@[59; 60)
+            VALUE_PARAMETER@[60; 66)
+              BIND_PAT@[60; 61)
+                NAME@[60; 61)
+                  IDENT@[60; 61) "x"
+              COLON@[61; 62)
+              PATH_TYPE@[62; 66)
+                PATH@[62; 66)
+                  PATH_SEGMENT@[62; 66)
+                    NAME_REF@[62; 66)
+                      WHITESPACE@[62; 63)
+                      IDENT@[63; 66) "i32"
+            COMMA@[66; 67)
+            PIPE@[67; 68)
+            WHITESPACE@[68; 69)
+          PATH_EXPR@[69; 70)
+            PATH@[69; 70)
+              PATH_SEGMENT@[69; 70)
+                NAME_REF@[69; 70)
+                  IDENT@[69; 70) "x"
+        SEMI@[70; 71)
+        WHITESPACE@[71; 72)
+      R_CURLY@[72; 73)
+      WHITESPACE@[73; 74)
diff --git a/tests/data/parser/inline/0033_fn_value_parameters.rs b/tests/data/parser/inline/0064_param_list.rs
index 9d55bedbb..9d55bedbb 100644
--- a/tests/data/parser/inline/0033_fn_value_parameters.rs
+++ b/tests/data/parser/inline/0064_param_list.rs
diff --git a/tests/data/parser/inline/0033_fn_value_parameters.txt b/tests/data/parser/inline/0064_param_list.txt
index 96e03d71a..96e03d71a 100644
--- a/tests/data/parser/inline/0033_fn_value_parameters.txt
+++ b/tests/data/parser/inline/0064_param_list.txt