Merge #29

29: Structs r=matklad a=matklad

r? @CAD97 

8 files changed, 415 insertions, 74 deletions

diff --git a/grammar.ron b/grammar.ron
index 70e269e20..7c76d595d 100644
--- a/grammar.ron
+++ b/grammar.ron
@@ -88,5 +88,8 @@ Grammar(
         "LITERAL",
         "ALIAS",
         "VISIBILITY",
+        "TYPE_PARAM_LIST",
+        "LIFETIME_PARAM",
+        "TYPE_PARAM",
     ]
-)
\ No newline at end of file
+)
diff --git a/src/parser/event_parser/grammar/items.rs b/src/parser/event_parser/grammar/items/mod.rs
index 56e3208ac..f10fb230b 100644
--- a/src/parser/event_parser/grammar/items.rs
+++ b/src/parser/event_parser/grammar/items/mod.rs
@@ -1,5 +1,7 @@
 use super::*;
 
+mod structs;
+
 pub(super) fn mod_contents(p: &mut Parser, stop_on_r_curly: bool) {
     attributes::inner_attributes(p);
     while !p.at(EOF) && !(stop_on_r_curly && p.at(R_CURLY)) {
@@ -29,7 +31,7 @@ fn item(p: &mut Parser) {
             USE_ITEM
         }
         STRUCT_KW => {
-            struct_item(p);
+            structs::struct_item(p);
             STRUCT_ITEM
         }
         FN_KW => {
@@ -57,90 +59,50 @@ fn item(p: &mut Parser) {
     item.complete(p, item_kind);
 }
 
-fn struct_item(p: &mut Parser) {
-    assert!(p.at(STRUCT_KW));
-    p.bump();
-
-    if !p.expect(IDENT) {
+fn type_param_list(p: &mut Parser) {
+    if !p.at(L_ANGLE) {
         return;
     }
-    generic_parameters(p);
-    match p.current() {
-        WHERE_KW => {
-            where_clause(p);
-            match p.current() {
-                SEMI => {
-                    p.bump();
-                    return;
-                }
-                L_CURLY => named_fields(p),
-                _ => {
-                    //TODO: special case `(` error message
-                    p.error().message("expected `;` or `{`").emit();
-                    return;
-                }
-            }
-        }
-        SEMI => {
-            p.bump();
-            return;
-        }
-        L_CURLY => named_fields(p),
-        L_PAREN => {
-            pos_fields(p);
-            p.expect(SEMI);
-        }
-        _ => {
-            p.error().message("expected `;`, `{`, or `(`").emit();
-            return;
-        }
-    }
-}
-
-fn named_fields(p: &mut Parser) {
-    assert!(p.at(L_CURLY));
+    let m = p.start();
     p.bump();
-    while !p.at(R_CURLY) && !p.at(EOF) {
-        named_field(p);
-        if !p.at(R_CURLY) {
-            p.expect(COMMA);
-        }
-    }
-    p.expect(R_CURLY);
 
-    fn named_field(p: &mut Parser) {
-        let field = p.start();
-        visibility(p);
-        if p.expect(IDENT) {
-            p.expect(COLON);
-            types::type_ref(p);
-            field.complete(p, NAMED_FIELD);
-        } else {
-            field.abandon(p);
-            p.err_and_bump("expected field declaration");
+    while !p.at(EOF) && !p.at(R_ANGLE) {
+        match p.current() {
+            LIFETIME => lifetime_param(p),
+            IDENT => type_param(p),
+            _ => p.err_and_bump("expected type parameter"),
+        }
+        if !p.at(R_ANGLE) && !p.expect(COMMA) {
+            break;
         }
     }
-}
+    p.expect(R_ANGLE);
+    m.complete(p, TYPE_PARAM_LIST);
 
-fn pos_fields(p: &mut Parser) {
-    if !p.expect(L_PAREN) {
-        return;
+    fn lifetime_param(p: &mut Parser) {
+        assert!(p.at(LIFETIME));
+        let m = p.start();
+        p.bump();
+        if p.eat(COLON) {
+            while p.at(LIFETIME) {
+                p.bump();
+                if !p.eat(PLUS) {
+                    break;
+                }
+            }
+        }
+        m.complete(p, LIFETIME_PARAM);
     }
-    while !p.at(R_PAREN) && !p.at(EOF) {
-        let pos_field = p.start();
-        visibility(p);
-        types::type_ref(p);
-        pos_field.complete(p, POS_FIELD);
 
-        if !p.at(R_PAREN) {
-            p.expect(COMMA);
-        }
+    fn type_param(p: &mut Parser) {
+        assert!(p.at(IDENT));
+        let m = p.start();
+        p.bump();
+        m.complete(p, TYPE_PARAM);
+        //TODO: bounds
     }
-    p.expect(R_PAREN);
 }
 
-fn generic_parameters(_: &mut Parser) {}
-
 fn where_clause(_: &mut Parser) {}
 
 fn extern_crate_item(p: &mut Parser) {
diff --git a/src/parser/event_parser/grammar/items/structs.rs b/src/parser/event_parser/grammar/items/structs.rs
new file mode 100644
index 000000000..0934f3d28
--- /dev/null
+++ b/src/parser/event_parser/grammar/items/structs.rs
@@ -0,0 +1,83 @@
+use super::*;
+
+pub(super) fn struct_item(p: &mut Parser) {
+    assert!(p.at(STRUCT_KW));
+    p.bump();
+
+    if !p.expect(IDENT) {
+        return;
+    }
+    type_param_list(p);
+    match p.current() {
+        WHERE_KW => {
+            where_clause(p);
+            match p.current() {
+                SEMI => {
+                    p.bump();
+                    return;
+                }
+                L_CURLY => named_fields(p),
+                _ => {
+                    //TODO: special case `(` error message
+                    p.error().message("expected `;` or `{`").emit();
+                    return;
+                }
+            }
+        }
+        SEMI => {
+            p.bump();
+            return;
+        }
+        L_CURLY => named_fields(p),
+        L_PAREN => {
+            pos_fields(p);
+            p.expect(SEMI);
+        }
+        _ => {
+            p.error().message("expected `;`, `{`, or `(`").emit();
+            return;
+        }
+    }
+}
+
+fn named_fields(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    p.bump();
+    while !p.at(R_CURLY) && !p.at(EOF) {
+        named_field(p);
+        if !p.at(R_CURLY) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_CURLY);
+
+    fn named_field(p: &mut Parser) {
+        let field = p.start();
+        visibility(p);
+        if p.expect(IDENT) {
+            p.expect(COLON);
+            types::type_ref(p);
+            field.complete(p, NAMED_FIELD);
+        } else {
+            field.abandon(p);
+            p.err_and_bump("expected field declaration");
+        }
+    }
+}
+
+fn pos_fields(p: &mut Parser) {
+    if !p.expect(L_PAREN) {
+        return;
+    }
+    while !p.at(R_PAREN) && !p.at(EOF) {
+        let pos_field = p.start();
+        visibility(p);
+        types::type_ref(p);
+        pos_field.complete(p, POS_FIELD);
+
+        if !p.at(R_PAREN) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_PAREN);
+}
diff --git a/src/syntax_kinds.rs b/src/syntax_kinds.rs
index 23a0881b7..b6c281cd5 100644
--- a/src/syntax_kinds.rs
+++ b/src/syntax_kinds.rs
@@ -90,6 +90,9 @@ pub enum SyntaxKind {
     LITERAL,
     ALIAS,
     VISIBILITY,
+    TYPE_PARAM_LIST,
+    LIFETIME_PARAM,
+    TYPE_PARAM,
 
     // Technical SyntaxKinds: they appear temporally during parsing,
     // but never end up in the final tree
@@ -187,6 +190,9 @@ impl SyntaxKind {
             LITERAL => &SyntaxInfo { name: "LITERAL" },
             ALIAS => &SyntaxInfo { name: "ALIAS" },
             VISIBILITY => &SyntaxInfo { name: "VISIBILITY" },
+            TYPE_PARAM_LIST => &SyntaxInfo { name: "TYPE_PARAM_LIST" },
+            LIFETIME_PARAM => &SyntaxInfo { name: "LIFETIME_PARAM" },
+            TYPE_PARAM => &SyntaxInfo { name: "TYPE_PARAM" },
 
             TOMBSTONE => &SyntaxInfo { name: "TOMBSTONE" },
             EOF => &SyntaxInfo { name: "EOF" },
diff --git a/tests/data/parser/err/0009_broken_struct_type_parameter.rs b/tests/data/parser/err/0009_broken_struct_type_parameter.rs
new file mode 100644
index 000000000..0dd30d0bd
--- /dev/null
+++ b/tests/data/parser/err/0009_broken_struct_type_parameter.rs
@@ -0,0 +1,5 @@
+struct S<90 + 2> {
+    f: u32
+}
+
+struct T;
diff --git a/tests/data/parser/err/0009_broken_struct_type_parameter.txt b/tests/data/parser/err/0009_broken_struct_type_parameter.txt
new file mode 100644
index 000000000..c6b1adb0c
--- /dev/null
+++ b/tests/data/parser/err/0009_broken_struct_type_parameter.txt
@@ -0,0 +1,42 @@
+FILE@[0; 43)
+  STRUCT_ITEM@[0; 12)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    IDENT@[7; 8)
+    TYPE_PARAM_LIST@[8; 12)
+      L_ANGLE@[8; 9)
+      ERROR@[9; 12)
+      err: `expected type parameter`
+        INT_NUMBER@[9; 11)
+        WHITESPACE@[11; 12)
+      err: `expected COMMA`
+      err: `expected R_ANGLE`
+    err: `expected `;`, `{`, or `(``
+  ERROR@[12; 14)
+  err: `expected item`
+    PLUS@[12; 13)
+    WHITESPACE@[13; 14)
+  ERROR@[14; 15)
+  err: `expected item`
+    INT_NUMBER@[14; 15)
+  ERROR@[15; 17)
+  err: `expected item`
+    R_ANGLE@[15; 16)
+    WHITESPACE@[16; 17)
+  ERROR@[17; 33)
+  err: `expected item`
+    L_CURLY@[17; 18)
+    WHITESPACE@[18; 23)
+    IDENT@[23; 24)
+    COLON@[24; 25)
+    WHITESPACE@[25; 26)
+    IDENT@[26; 29)
+    WHITESPACE@[29; 30)
+    R_CURLY@[30; 31)
+    WHITESPACE@[31; 33)
+  STRUCT_ITEM@[33; 43)
+    STRUCT_KW@[33; 39)
+    WHITESPACE@[39; 40)
+    IDENT@[40; 41)
+    SEMI@[41; 42)
+    WHITESPACE@[42; 43)
diff --git a/tests/data/parser/ok/0018_struct_type_params.rs b/tests/data/parser/ok/0018_struct_type_params.rs
new file mode 100644
index 000000000..88c544923
--- /dev/null
+++ b/tests/data/parser/ok/0018_struct_type_params.rs
@@ -0,0 +1,17 @@
+struct S1<T>;
+struct S2<T>(u32);
+struct S3<T> { u: u32 }
+
+struct S4<>;
+struct S5<'a>;
+struct S6<'a:>;
+struct S7<'a: 'b>;
+struct S8<'a: 'b + >;
+struct S9<'a: 'b + 'c>;
+struct S10<'a,>;
+struct S11<'a, 'b>;
+struct S12<'a: 'b+, 'b: 'c,>;
+
+struct S13<T>;
+struct S14<T, U>;
+struct S15<'a, T, U>;
diff --git a/tests/data/parser/ok/0018_struct_type_params.txt b/tests/data/parser/ok/0018_struct_type_params.txt
new file mode 100644
index 000000000..b2e7ef9d7
--- /dev/null
+++ b/tests/data/parser/ok/0018_struct_type_params.txt
@@ -0,0 +1,223 @@
+FILE@[0; 290)
+  STRUCT_ITEM@[0; 14)
+    STRUCT_KW@[0; 6)
+    WHITESPACE@[6; 7)
+    IDENT@[7; 9)
+    TYPE_PARAM_LIST@[9; 12)
+      L_ANGLE@[9; 10)
+      TYPE_PARAM@[10; 11)
+        IDENT@[10; 11)
+      R_ANGLE@[11; 12)
+    SEMI@[12; 13)
+    WHITESPACE@[13; 14)
+  STRUCT_ITEM@[14; 33)
+    STRUCT_KW@[14; 20)
+    WHITESPACE@[20; 21)
+    IDENT@[21; 23)
+    TYPE_PARAM_LIST@[23; 26)
+      L_ANGLE@[23; 24)
+      TYPE_PARAM@[24; 25)
+        IDENT@[24; 25)
+      R_ANGLE@[25; 26)
+    L_PAREN@[26; 27)
+    POS_FIELD@[27; 30)
+      IDENT@[27; 30)
+    R_PAREN@[30; 31)
+    SEMI@[31; 32)
+    WHITESPACE@[32; 33)
+  STRUCT_ITEM@[33; 58)
+    STRUCT_KW@[33; 39)
+    WHITESPACE@[39; 40)
+    IDENT@[40; 42)
+    TYPE_PARAM_LIST@[42; 46)
+      L_ANGLE@[42; 43)
+      TYPE_PARAM@[43; 44)
+        IDENT@[43; 44)
+      R_ANGLE@[44; 45)
+      WHITESPACE@[45; 46)
+    L_CURLY@[46; 47)
+    NAMED_FIELD@[47; 55)
+      WHITESPACE@[47; 48)
+      IDENT@[48; 49)
+      COLON@[49; 50)
+      WHITESPACE@[50; 51)
+      IDENT@[51; 54)
+      WHITESPACE@[54; 55)
+    R_CURLY@[55; 56)
+    WHITESPACE@[56; 58)
+  STRUCT_ITEM@[58; 71)
+    STRUCT_KW@[58; 64)
+    WHITESPACE@[64; 65)
+    IDENT@[65; 67)
+    TYPE_PARAM_LIST@[67; 69)
+      L_ANGLE@[67; 68)
+      R_ANGLE@[68; 69)
+    SEMI@[69; 70)
+    WHITESPACE@[70; 71)
+  STRUCT_ITEM@[71; 86)
+    STRUCT_KW@[71; 77)
+    WHITESPACE@[77; 78)
+    IDENT@[78; 80)
+    TYPE_PARAM_LIST@[80; 84)
+      L_ANGLE@[80; 81)
+      LIFETIME_PARAM@[81; 83)
+        LIFETIME@[81; 83)
+      R_ANGLE@[83; 84)
+    SEMI@[84; 85)
+    WHITESPACE@[85; 86)
+  STRUCT_ITEM@[86; 102)
+    STRUCT_KW@[86; 92)
+    WHITESPACE@[92; 93)
+    IDENT@[93; 95)
+    TYPE_PARAM_LIST@[95; 100)
+      L_ANGLE@[95; 96)
+      LIFETIME_PARAM@[96; 99)
+        LIFETIME@[96; 98)
+        COLON@[98; 99)
+      R_ANGLE@[99; 100)
+    SEMI@[100; 101)
+    WHITESPACE@[101; 102)
+  STRUCT_ITEM@[102; 121)
+    STRUCT_KW@[102; 108)
+    WHITESPACE@[108; 109)
+    IDENT@[109; 111)
+    TYPE_PARAM_LIST@[111; 119)
+      L_ANGLE@[111; 112)
+      LIFETIME_PARAM@[112; 118)
+        LIFETIME@[112; 114)
+        COLON@[114; 115)
+        WHITESPACE@[115; 116)
+        LIFETIME@[116; 118)
+      R_ANGLE@[118; 119)
+    SEMI@[119; 120)
+    WHITESPACE@[120; 121)
+  STRUCT_ITEM@[121; 143)
+    STRUCT_KW@[121; 127)
+    WHITESPACE@[127; 128)
+    IDENT@[128; 130)
+    TYPE_PARAM_LIST@[130; 141)
+      L_ANGLE@[130; 131)
+      LIFETIME_PARAM@[131; 140)
+        LIFETIME@[131; 133)
+        COLON@[133; 134)
+        WHITESPACE@[134; 135)
+        LIFETIME@[135; 137)
+        WHITESPACE@[137; 138)
+        PLUS@[138; 139)
+        WHITESPACE@[139; 140)
+      R_ANGLE@[140; 141)
+    SEMI@[141; 142)
+    WHITESPACE@[142; 143)
+  STRUCT_ITEM@[143; 167)
+    STRUCT_KW@[143; 149)
+    WHITESPACE@[149; 150)
+    IDENT@[150; 152)
+    TYPE_PARAM_LIST@[152; 165)
+      L_ANGLE@[152; 153)
+      LIFETIME_PARAM@[153; 164)
+        LIFETIME@[153; 155)
+        COLON@[155; 156)
+        WHITESPACE@[156; 157)
+        LIFETIME@[157; 159)
+        WHITESPACE@[159; 160)
+        PLUS@[160; 161)
+        WHITESPACE@[161; 162)
+        LIFETIME@[162; 164)
+      R_ANGLE@[164; 165)
+    SEMI@[165; 166)
+    WHITESPACE@[166; 167)
+  STRUCT_ITEM@[167; 184)
+    STRUCT_KW@[167; 173)
+    WHITESPACE@[173; 174)
+    IDENT@[174; 177)
+    TYPE_PARAM_LIST@[177; 182)
+      L_ANGLE@[177; 178)
+      LIFETIME_PARAM@[178; 180)
+        LIFETIME@[178; 180)
+      COMMA@[180; 181)
+      R_ANGLE@[181; 182)
+    SEMI@[182; 183)
+    WHITESPACE@[183; 184)
+  STRUCT_ITEM@[184; 204)
+    STRUCT_KW@[184; 190)
+    WHITESPACE@[190; 191)
+    IDENT@[191; 194)
+    TYPE_PARAM_LIST@[194; 202)
+      L_ANGLE@[194; 195)
+      LIFETIME_PARAM@[195; 197)
+        LIFETIME@[195; 197)
+      COMMA@[197; 198)
+      LIFETIME_PARAM@[198; 201)
+        WHITESPACE@[198; 199)
+        LIFETIME@[199; 201)
+      R_ANGLE@[201; 202)
+    SEMI@[202; 203)
+    WHITESPACE@[203; 204)
+  STRUCT_ITEM@[204; 235)
+    STRUCT_KW@[204; 210)
+    WHITESPACE@[210; 211)
+    IDENT@[211; 214)
+    TYPE_PARAM_LIST@[214; 232)
+      L_ANGLE@[214; 215)
+      LIFETIME_PARAM@[215; 222)
+        LIFETIME@[215; 217)
+        COLON@[217; 218)
+        WHITESPACE@[218; 219)
+        LIFETIME@[219; 221)
+        PLUS@[221; 222)
+      COMMA@[222; 223)
+      LIFETIME_PARAM@[223; 230)
+        WHITESPACE@[223; 224)
+        LIFETIME@[224; 226)
+        COLON@[226; 227)
+        WHITESPACE@[227; 228)
+        LIFETIME@[228; 230)
+      COMMA@[230; 231)
+      R_ANGLE@[231; 232)
+    SEMI@[232; 233)
+    WHITESPACE@[233; 235)
+  STRUCT_ITEM@[235; 250)
+    STRUCT_KW@[235; 241)
+    WHITESPACE@[241; 242)
+    IDENT@[242; 245)
+    TYPE_PARAM_LIST@[245; 248)
+      L_ANGLE@[245; 246)
+      TYPE_PARAM@[246; 247)
+        IDENT@[246; 247)
+      R_ANGLE@[247; 248)
+    SEMI@[248; 249)
+    WHITESPACE@[249; 250)
+  STRUCT_ITEM@[250; 268)
+    STRUCT_KW@[250; 256)
+    WHITESPACE@[256; 257)
+    IDENT@[257; 260)
+    TYPE_PARAM_LIST@[260; 266)
+      L_ANGLE@[260; 261)
+      TYPE_PARAM@[261; 262)
+        IDENT@[261; 262)
+      COMMA@[262; 263)
+      TYPE_PARAM@[263; 265)
+        WHITESPACE@[263; 264)
+        IDENT@[264; 265)
+      R_ANGLE@[265; 266)
+    SEMI@[266; 267)
+    WHITESPACE@[267; 268)
+  STRUCT_ITEM@[268; 290)
+    STRUCT_KW@[268; 274)
+    WHITESPACE@[274; 275)
+    IDENT@[275; 278)
+    TYPE_PARAM_LIST@[278; 288)
+      L_ANGLE@[278; 279)
+      LIFETIME_PARAM@[279; 281)
+        LIFETIME@[279; 281)
+      COMMA@[281; 282)
+      TYPE_PARAM@[282; 284)
+        WHITESPACE@[282; 283)
+        IDENT@[283; 284)
+      COMMA@[284; 285)
+      TYPE_PARAM@[285; 287)
+        WHITESPACE@[285; 286)
+        IDENT@[286; 287)
+      R_ANGLE@[287; 288)
+    SEMI@[288; 289)
+    WHITESPACE@[289; 290)