work in progress parser

crates/concrete_ast/src/common.rs

@@ -1,9 +1,15 @@
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Span {
     pub from: usize,
     pub to: usize,
 }
 
+impl Span {
+    pub fn new(from: usize, to: usize) -> Self {
+        Self { from, to }
+    }
+}
+
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct DocString {
     contents: String,
@@ -12,6 +18,7 @@ pub struct DocString {
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub struct Ident {
     pub name: String,
+    pub span: Span,
 }
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]

crates/concrete_ast/src/constants.rs

@@ -13,6 +13,6 @@ pub struct ConstantDecl {
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct ConstantDef {
-    decl: ConstantDecl,
+    pub decl: ConstantDecl,
     pub value: Expression,
 }

crates/concrete_parser/src/grammar.lalrpop

@@ -1,5 +1,7 @@
 use crate::tokens::Token;
+use crate::lexer::LexicalError;
 use concrete_ast as ast;
+use std::str::FromStr;
 
 grammar;
 
@@ -24,7 +26,8 @@ extern {
 
     // literals
     "identifier" => Token::Identifier(<String>),
-    "integer" => Token::String(<String>),
+    "integer" => Token::Integer(<u64>),
+    "string" => Token::String(<String>),
     "boolean" => Token::Boolean(<bool>),
 
     // Other
@@ -57,6 +60,79 @@ extern {
   }
 }
 
-pub Term: () = {
-    "identifier" => (),
+Comma<T>: Vec<T> = {
+    <mut v:(<T> ",")*> <e:T?> => match e {
+        None => v,
+        Some(e) => {
+            v.push(e);
+            v
+        }
+    }
+};
+
+SemiColonSeparated<T>: Vec<T> = {
+  <T> ";" => vec![<>],
+  <mut s:SemiColonSeparated<T>> ";" <n:T> ";" => {
+    s.push(n);
+    s
+  }
+};
+
+pub(crate) Ident: ast::common::Ident = {
+  <lo:@L> <name:"identifier"> <hi:@R> => ast::common::Ident {
+    name,
+    span: ast::common::Span::new(lo, hi),
+  }
+}
+
+pub Program: Vec<ast::modules::ModuleBase> = {
+  <ModuleBase> => vec![<>],
+  <mut s:Program> <n:ModuleBase> => {
+      s.push(n);
+      s
+  },
+}
+
+pub(crate) ModuleBase: ast::modules::ModuleBase = {
+  "mod" <name:Ident> "{" <contents:SemiColonSeparated<ModuleDefItem>> "}" => {
+    ast::modules::ModuleBase {
+      doc_string: None,
+      imports: vec![], // todo: add imports
+      name,
+      contents
+    }
+  }
+}
+
+pub(crate) ModuleDefItem: ast::modules::ModuleDefItem = {
+  "const" <name:Ident> ":" <type_spec:TypeSpec> "=" <exp:Expression> => {
+    ast::modules::ModuleDefItem::Constant(ast::constants::ConstantDef {
+      decl: ast::constants::ConstantDecl {
+        doc_string: None,
+        name,
+        r#type: type_spec
+      },
+      value: exp,
+    })
+  }
+}
+
+pub(crate) TypeSpec: ast::types::TypeSpec = {
+  <name:Ident> => ast::types::TypeSpec::Simple {
+    name
+  },
+  <name:Ident> "<" <type_params:Comma<TypeSpec>> ">" => ast::types::TypeSpec::Generic {
+    name,
+    type_params
+  }
+}
+
+pub(crate) Expression: ast::expressions::Expression = {
+  <AtomicExpr> => ast::expressions::Expression::Atomic(<>),
+}
+
+pub(crate) AtomicExpr: ast::expressions::AtomicExpr = {
+  <"integer"> => ast::expressions::AtomicExpr::ConstInt(<>),
+  <"boolean"> => ast::expressions::AtomicExpr::ConstBool(<>),
+  <"string"> => ast::expressions::AtomicExpr::ConstStr(<>),
 }

crates/concrete_parser/src/lib.rs

@@ -1,4 +1,26 @@
 #![allow(unused)]
 
+use lalrpop_util::lalrpop_mod;
+
 mod lexer;
 pub mod tokens;
+
+lalrpop_mod!(pub grammar);
+
+#[cfg(test)]
+mod tests {
+    use crate::{grammar, lexer::Lexer};
+
+    #[test]
+    fn parse_program() {
+        let source = r##"
+mod ModuleName {
+    const MY_CONSTANT: u8 = 2;
+}
+        "##;
+        let lexer = Lexer::new(source);
+        let parser = grammar::ProgramParser::new();
+        let mut ast = parser.parse(lexer).unwrap();
+        dbg!(ast);
+    }
+}

crates/concrete_parser/src/tokens.rs

@@ -1,4 +1,5 @@
 use logos::Logos;
+use std::str::FromStr;
 use std::{convert::Infallible, fmt}; // to implement the Display trait
 
 #[derive(Debug, PartialEq, Clone, Default)]
@@ -53,8 +54,8 @@ pub enum Token {
     Identifier(String),
 
     // Literals
-    #[regex(r"\d+", |lex| lex.slice().to_string())]
-    Integer(String),
+    #[regex(r"\d+", |lex| lex.slice().parse::<u64>().unwrap())]
+    Integer(u64),
     #[regex(r#""(?:[^"]|\\")*""#, |lex| lex.slice().to_string())]
     String(String),
     #[regex(r"(true|false)", |lex| lex.slice().parse::<bool>().unwrap())]