ok

crates/concrete_ast/src/expressions.rs

@@ -3,12 +3,8 @@ use crate::{operations::Operation, statements::Statement};
 #[derive(Clone, Debug, PartialEq)]
 pub enum Expression {
     Match(MatchExpr),
+    If(IfExpr),
     Operation(Operation),
-    // Block(Vec<Statement>),
-}
-
-pub struct BlockExpr {
-    pub statements: Vec<Statement>,
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -17,6 +13,13 @@ pub struct MatchExpr {
     pub variants: Vec<MatchVariant>,
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub struct IfExpr {
+    pub value: Operation,
+    pub contents: Vec<Statement>,
+    pub r#else: Option<Vec<Statement>>,
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct MatchVariant {
     pub case: Operation,

crates/concrete_ast/src/statements.rs

@@ -1,6 +1,6 @@
 use crate::{
     common::Ident,
-    expressions::{Expression, MatchExpr},
+    expressions::{Expression, MatchExpr, IfExpr},
     operations::{Operation, PathOp},
     types::TypeSpec,
 };
@@ -10,7 +10,7 @@ pub enum Statement {
     Assign(AssignStmt),
     Match(MatchExpr),
     For(ForStmt),
-    If(IfStmt),
+    If(IfExpr),
     Let(LetStmt),
     Return(ReturnStmt),
     While(WhileStmt),
@@ -55,13 +55,6 @@ pub struct ForStmt {
     pub contents: Vec<Statement>,
 }
 
-#[derive(Clone, Debug, PartialEq)]
-pub struct IfStmt {
-    pub value: Operation,
-    pub contents: Vec<Statement>,
-    pub r#else: Option<Vec<Statement>>,
-}
-
 #[derive(Clone, Debug, PartialEq)]
 pub struct WhileStmt {
     pub value: Operation,

crates/concrete_parser/src/grammar.lalrpop

@@ -46,6 +46,8 @@ extern {
     "," => Token::Coma,
     "<" => Token::LessThanSign,
     ">" => Token::MoreThanSign,
+    ">=" => Token::MoreThanEqSign,
+    "<=" => Token::LessThanEqSign,
     "." => Token::Dot,
 
     // operators
@@ -230,9 +232,21 @@ pub(crate) FunctionDef: ast::functions::FunctionDef = {
 
 pub(crate) Expression: ast::expressions::Expression = {
   <MatchExpr> => ast::expressions::Expression::Match(<>),
+  <IfExpr> => ast::expressions::Expression::If(<>),
   <Operation> => ast::expressions::Expression::Operation(<>),
 }
 
+pub(crate) IfExpr: ast::expressions::IfExpr = {
+  "if" <value:Operation> "{" <contents:SemiColonSeparated<Statement>> "}"
+    <else_stmts:("else" "{" <SemiColonSeparated<Statement>> "}")?> => {
+    ast::expressions::IfExpr {
+      value,
+      contents,
+      r#else: else_stmts,
+    }
+  }
+}
+
 pub(crate) MatchExpr: ast::expressions::MatchExpr = {
   "match" <value:Operation> "{" <variants:Comma<MatchVariant>> "}" => {
     ast::expressions::MatchExpr {
@@ -276,6 +290,8 @@ pub(crate) AtomicOp: ast::operations::AtomicOp = {
 
 pub(crate) CompoundOp: ast::operations::CompoundOp = {
   <ArithOp> => ast::operations::CompoundOp::Arith(<>),
+  <CmpOp> => ast::operations::CompoundOp::Compare(<>),
+  <LogicOp> => ast::operations::CompoundOp::Logic(<>),
 }
 
 pub(crate) ArithOp: ast::operations::ArithOp = {
@@ -290,6 +306,21 @@ pub(crate) ArithOp: ast::operations::ArithOp = {
   "-" <value:AtomicOp> => ast::operations::ArithOp::Neg(value),
 }
 
+pub(crate) CmpOp: ast::operations::CmpOp = {
+  <lhs:AtomicOp> "==" <rhs:AtomicOp> => ast::operations::CmpOp::Eq(lhs, rhs),
+  <lhs:AtomicOp> "!=" <rhs:AtomicOp> => ast::operations::CmpOp::NotEq(lhs, rhs),
+  <lhs:AtomicOp> "<=" <rhs:AtomicOp> => ast::operations::CmpOp::LtEq(lhs, rhs),
+  <lhs:AtomicOp> ">=" <rhs:AtomicOp> => ast::operations::CmpOp::GtEq(lhs, rhs),
+  <lhs:AtomicOp> ">" <rhs:AtomicOp> => ast::operations::CmpOp::Lt(lhs, rhs),
+  <lhs:AtomicOp> "<" <rhs:AtomicOp> => ast::operations::CmpOp::Gt(lhs, rhs),
+}
+
+pub(crate) LogicOp: ast::operations::LogicOp = {
+  <lhs:AtomicOp> "&&" <rhs:AtomicOp> => ast::operations::LogicOp::And(lhs, rhs),
+  <lhs:AtomicOp> "||" <rhs:AtomicOp> => ast::operations::LogicOp::Or(lhs, rhs),
+  "!" <rhs:AtomicOp> => ast::operations::LogicOp::Not(rhs),
+}
+
 pub(crate) PathOp: ast::operations::PathOp = {
   <first:Ident> <extra:PathSegments?> => ast::operations::PathOp {
     first,
@@ -321,6 +352,7 @@ pub(crate) FnCallOp: ast::operations::FnCallOp = {
 
 pub(crate) Statement: ast::statements::Statement = {
   <MatchExpr> => ast::statements::Statement::Match(<>),
+  <IfExpr> => ast::statements::Statement::If(<>),
   <LetStmt> => ast::statements::Statement::Let(<>),
   <AssignStmt> => ast::statements::Statement::Assign(<>),
   <ReturnStmt> => ast::statements::Statement::Return(<>),

crates/concrete_parser/src/lib.rs

@@ -84,13 +84,19 @@ mod ModuleName {
         x = x + 4;
         x = x - 2;
         x = x % 2;
+
         match x {
             0 -> return 2,
             1 -> {
                 let y: u64 = x * 2;
                 return y * 10;
             },
         };
+
+        if x == 2 {
+            return 0;
+        }
+
         return x;
     }
 }

crates/concrete_parser/src/tokens.rs

@@ -91,6 +91,10 @@ pub enum Token {
     LessThanSign,
     #[token(">")]
     MoreThanSign,
+    #[token(">=")]
+    MoreThanEqSign,
+    #[token("<=")]
+    LessThanEqSign,
 
     #[token("+")]
     OperatorAdd,