add and and or operations

src/main.rs

@@ -3,11 +3,7 @@ use lumina::compile_and_run;
 fn main() {
     let source = r#"
         fn fib(n: int) -> int {
-            if n == 0 {
-                return n;
-            }
-
-            if n == 1 {
+            if n == 0 || n == 1 {
                 return n;
             }
 

src/repr/ast/base/expression/infix.rs

@@ -8,6 +8,8 @@ pub enum InfixOperation {
     Plus,
     Eq,
     NotEq,
+    And,
+    Or,
 }
 
 impl InfixOperation {
@@ -29,6 +31,8 @@ impl TryFrom<Token> for InfixOperation {
             Token::Minus => Ok(InfixOperation::Minus),
             Token::DoubleEq => Ok(InfixOperation::Eq),
             Token::NotEq => Ok(InfixOperation::NotEq),
+            Token::And => Ok(InfixOperation::And),
+            Token::Or => Ok(InfixOperation::Or),
             _ => Err(()),
         }
     }

src/repr/ir/triple/ops.rs

@@ -6,6 +6,8 @@ pub enum BinaryOp {
     Sub,
     Eq,
     NotEq,
+    And,
+    Or,
 }
 
 impl From<&ast::InfixOperation> for BinaryOp {
@@ -15,6 +17,8 @@ impl From<&ast::InfixOperation> for BinaryOp {
             ast::InfixOperation::Minus => Self::Sub,
             ast::InfixOperation::Eq => Self::Eq,
             ast::InfixOperation::NotEq => Self::NotEq,
+            ast::InfixOperation::And => Self::And,
+            ast::InfixOperation::Or => Self::Or,
         }
     }
 }

src/repr/token.rs

@@ -16,6 +16,10 @@ pub enum Token {
     DoubleEq,
     #[token("!=")]
     NotEq,
+    #[token("&&")]
+    And,
+    #[token("||")]
+    Or,
 
     /*
      * Language tokens
@@ -104,6 +108,8 @@ impl Display for Token {
             Token::Minus => write!(f, "-"),
             Token::DoubleEq => write!(f, "=="),
             Token::NotEq => write!(f, "!="),
+            Token::And => write!(f, "&&"),
+            Token::Or => write!(f, "||"),
             Token::Eq => write!(f, "="),
             Token::ThinArrow => write!(f, "->"),
             Token::Colon => write!(f, ":"),

src/stage/codegen/llvm/mod.rs

@@ -177,6 +177,8 @@ impl<'ctx, 'ink, Ctx: LLVMCtx> FunctionGenerator<'ctx, 'ink, Ctx> {
                 .builder
                 .build_int_compare(IntPredicate::NE, lhs, rhs, "not_eq_result")
                 .unwrap(),
+            BinaryOp::And => self.builder.build_and(lhs, rhs, "and_result").unwrap(),
+            BinaryOp::Or => self.builder.build_or(lhs, rhs, "or_result").unwrap(),
         }
     }
 

src/stage/parse/expression/mod.rs

@@ -14,6 +14,7 @@ mod e_integer;
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Precedence {
     Lowest,
+    Binary,
     Equality,
     Sum,
     Call,
@@ -23,6 +24,7 @@ impl Precedence {
     pub fn of(token: &Token) -> Self {
         match token {
             Token::Minus | Token::Plus => Precedence::Sum,
+            Token::And | Token::Or => Precedence::Binary,
             Token::DoubleEq | Token::NotEq => Precedence::Equality,
             Token::LeftParen => Precedence::Call,
             _ => Precedence::Lowest,

src/stage/type_check/expression/infix.rs

@@ -10,6 +10,7 @@ impl InfixOperation {
         match (self, left, right) {
             (Plus | Minus, Ty::Int, Ty::Int) => Ok(Ty::Int),
             (Eq | NotEq, left, right) if left.check(right) => Ok(Ty::Boolean),
+            (And | Or, Ty::Boolean, Ty::Boolean) => Ok(Ty::Boolean),
             (_, left, right) => Err(TyError::Mismatch(*left, *right)),
         }
     }

tests/programs.rs

@@ -93,11 +93,7 @@ fn main() -> int {
 #[case::fibonacci(
     4181,
     r#"fn fib(n: int) -> int {
-        if n == 0 {
-            return n;
-        }
-
-        if n == 1 {
+        if n == 0 || n == 1 {
             return n;
         }