type checking !?!?

src/parser/v3/nodes/struc.rs

@@ -1,8 +1,8 @@
 use std::fmt::Debug;
 
 use super::{
-    util::parse_list, PIdent, Keyword, Node, Parsable, ParseResult, ParserCtx, ParserMsg, Symbol,
-    PType, PVarDef,
+    util::parse_list, Keyword, Node, PExpr, PFieldDef, PIdent, PType, PVarDef, Parsable,
+    ParseResult, ParserCtx, CompilerMsg, Symbol,
 };
 
 #[derive(Debug)]
@@ -11,6 +11,12 @@ pub struct PStruct {
     pub fields: PStructFields,
 }
 
+#[derive(Debug)]
+pub struct PConstruct {
+    pub name: Node<PIdent>,
+    pub fields: PConstructFields,
+}
+
 #[derive(Debug)]
 pub enum PStructFields {
     Named(Vec<Node<PVarDef>>),
@@ -18,6 +24,13 @@ pub enum PStructFields {
     None,
 }
 
+#[derive(Debug)]
+pub enum PConstructFields {
+    Named(Vec<Node<PFieldDef>>),
+    Tuple(Vec<Node<PExpr>>),
+    None,
+}
+
 impl Parsable for PStruct {
     fn parse(ctx: &mut ParserCtx) -> ParseResult<Self> {
         ctx.expect_kw(Keyword::Struct)?;
@@ -33,7 +46,7 @@ impl Parsable for PStruct {
             ctx.next();
             PStructFields::Tuple(parse_list(ctx, Symbol::CloseParen)?)
         } else {
-            let msg = ParserMsg::unexpected_token(next, "`;`, `(`, or `{`");
+            let msg = CompilerMsg::unexpected_token(next, "`;`, `(`, or `{`");
             ctx.err(msg);
             return ParseResult::Recover(PStruct {
                 name,
@@ -43,3 +56,29 @@ impl Parsable for PStruct {
         ParseResult::Ok(PStruct { name, fields })
     }
 }
+
+impl Parsable for PConstruct {
+    fn parse(ctx: &mut ParserCtx) -> ParseResult<Self> {
+        ctx.expect_kw(Keyword::Struct)?;
+        let name = ctx.parse()?;
+        let next = ctx.expect_peek()?;
+        let fields = if next.is_symbol(Symbol::Semicolon) {
+            ctx.next();
+            PConstructFields::None
+        } else if next.is_symbol(Symbol::OpenCurly) {
+            ctx.next();
+            PConstructFields::Named(parse_list(ctx, Symbol::CloseCurly)?)
+        } else if next.is_symbol(Symbol::OpenParen) {
+            ctx.next();
+            PConstructFields::Tuple(parse_list(ctx, Symbol::CloseParen)?)
+        } else {
+            let msg = CompilerMsg::unexpected_token(next, "`;`, `(`, or `{`");
+            ctx.err(msg);
+            return ParseResult::Recover(PConstruct {
+                name,
+                fields: PConstructFields::None,
+            });
+        };
+        ParseResult::Ok(PConstruct { name, fields })
+    }
+}