Union & enum syntax

crates/concrete_ast/src/enums.rs

@@ -0,0 +1,29 @@
+use crate::{
+    common::{GenericParam, Ident, Span},
+    expressions::Expression,
+    structs::Field,
+};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct UnionDecl {
+    pub name: Ident,
+    pub generics: Vec<GenericParam>,
+    pub variants: Vec<Field>,
+    pub span: Span,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EnumDecl {
+    pub name: Ident,
+    pub generics: Vec<GenericParam>,
+    pub variants: Vec<EnumVariant>,
+    pub span: Span,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EnumVariant {
+    pub name: Ident,
+    pub fields: Vec<Field>,
+    pub discriminant: Option<Expression>,
+    pub span: Span,
+}

crates/concrete_ast/src/lib.rs

@@ -4,6 +4,7 @@ use modules::Module;
 
 pub mod common;
 pub mod constants;
+pub mod enums;
 pub mod expressions;
 pub mod functions;
 pub mod imports;

crates/concrete_ast/src/modules.rs

@@ -1,6 +1,7 @@
 use crate::{
     common::{DocString, Ident, Span},
     constants::ConstantDef,
+    enums::{EnumDecl, UnionDecl},
     functions::{FunctionDecl, FunctionDef},
     imports::ImportStmt,
     structs::StructDecl,
@@ -22,6 +23,8 @@ pub enum ModuleDefItem {
     Function(FunctionDef),
     FunctionDecl(FunctionDecl),
     Struct(StructDecl),
+    Union(UnionDecl),
+    Enum(EnumDecl),
     Type(TypeDecl),
     Module(Module),
 }

crates/concrete_ir/src/lowering.rs

@@ -168,6 +168,8 @@ fn lower_module(mut ctx: BuildCtx, module: &Module, id: DefId) -> Result<BuildCt
                 ctx = lower_module(ctx, mod_def, id)?;
             }
             ModuleDefItem::Struct(_) => { /* already processed */ }
+            ModuleDefItem::Union(_) => todo!(),
+            ModuleDefItem::Enum(_) => todo!(),
             ModuleDefItem::FunctionDecl(fn_decl) => {
                 ctx = lower_func_decl(ctx, fn_decl, id)?;
             }

crates/concrete_ir/src/lowering/prepass.rs

@@ -95,6 +95,8 @@ pub fn prepass_module(
                         .insert(info.name.name.clone(), next_id);
                     current_module.modules.insert(next_id);
                 }
+                ast::modules::ModuleDefItem::Union(_) => todo!(),
+                ast::modules::ModuleDefItem::Enum(_) => todo!(),
                 ast::modules::ModuleDefItem::FunctionDecl(info) => {
                     let next_id = gen.next_defid();
                     current_module
@@ -210,6 +212,8 @@ pub fn prepass_sub_module(
                         .insert(info.name.name.clone(), next_id);
                     submodule.modules.insert(next_id);
                 }
+                ast::modules::ModuleDefItem::Union(_) => todo!(),
+                ast::modules::ModuleDefItem::Enum(_) => todo!(),
                 ast::modules::ModuleDefItem::FunctionDecl(info) => {
                     let next_id = gen.next_defid();
                     submodule

crates/concrete_parser/src/grammar.lalrpop

@@ -18,6 +18,8 @@ extern {
     "fn" => Token::KeywordFn,
     "return" => Token::KeywordReturn,
     "struct" => Token::KeywordStruct,
+    "union" => Token::KeywordUnion,
+    "enum" => Token::KeywordEnum,
     "if" => Token::KeywordIf,
     "else" => Token::KeywordElse,
     "while" => Token::KeywordWhile,
@@ -243,6 +245,12 @@ pub(crate) ModuleDefItem: ast::modules::ModuleDefItem = {
   <StructDef> => {
     ast::modules::ModuleDefItem::Struct(<>)
   },
+  <UnionDef> => {
+    ast::modules::ModuleDefItem::Union(<>)
+  },
+  <EnumDef> => {
+    ast::modules::ModuleDefItem::Enum(<>)
+  },
   <FunctionDef> => {
     ast::modules::ModuleDefItem::Function(<>)
   },
@@ -328,6 +336,35 @@ pub(crate) StructDef: ast::structs::StructDecl = {
     }
 }
 
+
+pub(crate) UnionDef: ast::enums::UnionDecl = {
+    <lo:@L> "union" <name:Ident> <generics:GenericParams?> "{" <variants:Comma<StructField>> "}" <hi:@R> => ast::enums::UnionDecl {
+        name,
+        variants,
+        generics: generics.unwrap_or(vec![]),
+        span: Span::new(lo, hi),
+    }
+}
+
+pub(crate) EnumDef: ast::enums::EnumDecl = {
+    <lo:@L> "enum" <name:Ident> <generics:GenericParams?> "{" <variants:Comma<EnumVariant>> "}" <hi:@R> => ast::enums::EnumDecl {
+        name,
+        variants,
+        generics: generics.unwrap_or(vec![]),
+        span: Span::new(lo, hi),
+    }
+}
+
+
+pub(crate) EnumVariant: ast::enums::EnumVariant = {
+    <lo:@L> <name:Ident> <fields:("{" <Comma<StructField>> "}")?> <discriminant:("=" <Expression>)?><hi:@R> => ast::enums::EnumVariant {
+        name,
+        fields: fields.unwrap_or_default(),
+        discriminant,
+        span: Span::new(lo, hi),
+    }
+}
+
 pub(crate) StructInitField: (ast::common::Ident, ast::expressions::StructInitField) = {
     <lo:@L> <name:Ident> ":" <value:Expression> <hi:@R> => (name, ast::expressions::StructInitField {
         value,

crates/concrete_parser/src/lib.rs

@@ -150,6 +150,44 @@ mod ModuleName {
     fn parse_empty_fn() {
         let source = r##"mod MyMod {
             fn hello() {}
+}"##;
+        let lexer = Lexer::new(source);
+        let parser = grammar::ProgramParser::new();
+        parser.parse(lexer).unwrap();
+    }
+
+    #[test]
+    fn parse_union_declaration() {
+        let source = r##"mod MyMod {
+    union Foo {
+        bar: i32,
+        baz: i64,
+    }
+
+    fn main() -> i32 {
+        let mut foo: Foo = Foo { bar: 1 };
+
+		// unsafe!
+		let bar: i32 = foo.bar;
+    }
+}"##;
+        let lexer = Lexer::new(source);
+        let parser = grammar::ProgramParser::new();
+        parser.parse(lexer).unwrap();
+    }
+
+    #[test]
+    fn parse_enum() {
+        let source = r##"mod MyMod {
+    enum Foo {
+        Bar,
+		Baz { n1: i32, n2: i32 },
+		Qux = 3,
+    }
+
+    fn main() -> i32 {
+        let mut foo: Foo = Foo.Bar;
+    }
 }"##;
         let lexer = Lexer::new(source);
         let parser = grammar::ProgramParser::new();

crates/concrete_parser/src/tokens.rs

@@ -33,6 +33,10 @@ pub enum Token {
     KeywordReturn,
     #[token("struct")]
     KeywordStruct,
+    #[token("union")]
+    KeywordUnion,
+    #[token("enum")]
+    KeywordEnum,
     #[token("if")]
     KeywordIf,
     #[token("else")]

examples/enum.con

@@ -0,0 +1,17 @@
+mod EnumExample {
+    enum Foo {
+		Bar,
+		Baz { n1: i32, n2: i32 },
+		Qux = 3,
+    }
+
+    fn main() -> i32 {
+        let mut foo: Foo = Foo.Bar;
+
+		match foo {
+			Foo.Bar -> return 1;,
+			Foo.Baz -> return 2;,
+			Foo.Qux -> return 3;,
+		}
+    }
+}

examples/union.con

@@ -0,0 +1,13 @@
+mod UnionExample {
+    union Foo {
+        bar: i32,
+        baz: i64,
+    }
+
+    fn main() -> i32 {
+        let mut foo: Foo = Foo { bar: 1 };
+
+		// unsafe!
+		let bar: i32 = foo.bar;
+    }
+}