Feat: Implement Bitwise Operations and Unary Operators

front/lexer/src/lexer/lexer.rs

@@ -638,17 +638,17 @@ impl<'a> Lexer<'a> {
                             line: self.line,
                         }
                     },
-                    "rol" => {
+                    "<<" => {
                         Token {
                             token_type: TokenType::Rol,
-                            lexeme: "rol".to_string(),
+                            lexeme: "<<".to_string(),
                             line: self.line,
                         }
                     },
-                    "ror" => {
+                    ">>" => {
                         Token {
                             token_type: TokenType::Ror,
-                            lexeme: "ror".to_string(),
+                            lexeme: ">>".to_string(),
                             line: self.line,
                         }
                     },

front/parser/src/parser/ast.rs

@@ -122,6 +122,10 @@ pub enum Expression {
         object: Box<Expression>,
         field: String,
     },
+    Unary {
+        operator: Operator,
+        expr: Box<Expression>,
+    },
 }
 
 #[derive(Debug, Clone)]
@@ -149,6 +153,11 @@ pub enum Operator {
     LogicalOr,
     BitwiseOr,
     Assign,
+    ShiftLeft,              // <<
+    ShiftRight,             // >>
+    BitwiseXor,
+    LogicalNot,
+    BitwiseNot,
 }
 
 #[derive(Debug, Clone)]

front/parser/src/parser/format.rs

@@ -37,6 +37,24 @@ pub fn parse_expression<'a, T>(tokens: &mut Peekable<T>) -> Option<Expression>
 where
     T: Iterator<Item = &'a Token>,
 {
+    if let Some(Token { token_type: TokenType::Not, .. }) = tokens.peek() {
+        tokens.next();
+        let inner = parse_expression(tokens)?;
+        return Some(Expression::Unary {
+            operator: Operator::LogicalNot,
+            expr: Box::new(inner),
+        });
+    }
+
+    if let Some(Token { token_type: TokenType::BitwiseNot, .. }) = tokens.peek() {
+        tokens.next();
+        let inner = parse_expression(tokens)?;
+        return Some(Expression::Unary {
+            operator: Operator::BitwiseNot,
+            expr: Box::new(inner),
+        });
+    }
+
     if let Some(Token { token_type: TokenType::AddressOf, .. }) = tokens.peek() {
         tokens.next(); // consume '&'
         let inner = parse_expression(tokens)?;
@@ -86,7 +104,7 @@ pub fn parse_logical_expression<'a, T>(tokens: &mut Peekable<T>) -> Option<Expre
 where
     T: Iterator<Item = &'a Token>,
 {
-    let mut left = parse_relational_expression(tokens)?;
+    let mut left = parse_bitwise_expression(tokens)?;
 
     while let Some(token) = tokens.peek() {
         match token.token_type {
@@ -618,4 +636,52 @@ where
             None
         }
     }
+}
+
+pub fn parse_shift_expression<'a, T>(tokens: &mut Peekable<T>) -> Option<Expression>
+where
+    T: Iterator<Item = &'a Token>,
+{
+    let mut left = parse_relational_expression(tokens)?;
+
+    while let Some(token) = tokens.peek() {
+        let op = match token.token_type {
+            TokenType::Rol => Operator::ShiftLeft,
+            TokenType::Ror => Operator::ShiftRight,
+            _ => break,
+        };
+
+        tokens.next();
+        let right = parse_relational_expression(tokens)?;
+        left = Expression::BinaryExpression {
+            left: Box::new(left),
+            operator: op,
+            right: Box::new(right),
+        };
+    }
+    Some(left)
+}
+
+pub fn parse_bitwise_expression<'a, T>(tokens: &mut Peekable<T>) -> Option<Expression>
+where
+    T: Iterator<Item = &'a Token>,
+{
+    let mut left = parse_shift_expression(tokens)?;
+
+    while let Some(token) = tokens.peek() {
+        let op = match token.token_type {
+            TokenType::BitwiseOr => Operator::BitwiseOr,
+            TokenType::Xor => Operator::BitwiseXor,
+            _ => break,
+        };
+
+        tokens.next();
+        let right = parse_shift_expression(tokens)?;
+        left = Expression::BinaryExpression {
+            left: Box::new(left),
+            operator: op,
+            right: Box::new(right),
+        };
+    }
+    Some(left)
 }

llvm_temporary/src/llvm_temporary/expression.rs

@@ -440,6 +440,8 @@ pub fn generate_expression_ir<'ctx>(
                         Operator::Multiply => builder.build_int_mul(l_casted, r_casted, "multmp"),
                         Operator::Divide => builder.build_int_signed_div(l_casted, r_casted, "divtmp"),
                         Operator::Remainder => builder.build_int_signed_rem(l_casted, r_casted, "modtmp"),
+                        Operator::ShiftLeft => builder.build_left_shift(l_casted, r_casted, "shl"),
+                        Operator::ShiftRight => builder.build_right_shift(l_casted, r_casted, true, "shr"),
                         Operator::Greater => builder.build_int_compare(IntPredicate::SGT, l_casted, r_casted, "cmptmp"),
                         Operator::Less => builder.build_int_compare(IntPredicate::SLT, l_casted, r_casted, "cmptmp"),
                         Operator::Equal => builder.build_int_compare(IntPredicate::EQ, l_casted, r_casted, "cmptmp"),
@@ -731,6 +733,34 @@ pub fn generate_expression_ir<'ctx>(
                 .as_basic_value_enum()
         }
 
+        Expression::Unary { operator, expr } => {
+            let val = generate_expression_ir(
+                context,
+                builder,
+                expr,
+                variables,
+                module,
+                None,
+                global_consts,
+                struct_types,
+                struct_field_indices,
+            );
+
+            match (operator, val) {
+                // ! (logical not)
+                (Operator::LogicalNot, BasicValueEnum::IntValue(v)) => {
+                    let one = v.get_type().const_int(1, false);
+                    builder.build_xor(v, one, "logical_not").unwrap().as_basic_value_enum()
+                }
+
+                (Operator::BitwiseNot, BasicValueEnum::IntValue(v)) => {
+                    builder.build_not(v, "bitwise_not").unwrap().as_basic_value_enum()
+                }
+
+                _ => panic!("Unsupported unary operator {:?} for value {:?}", operator, val),
+            }
+        }
+
         _ => unimplemented!("Unsupported expression type"),
     }
 }

test/test70.wave

@@ -0,0 +1,53 @@
+fun main() {
+    var a: i32 = 10;
+    var b: i32 = 3;
+
+    println("a + b = {}", a + b);
+    println("a - b = {}", a - b);
+    println("a * b = {}", a * b);
+    println("a / b = {}", a / b);
+    println("a % b = {}", a % b);
+
+    var x: i32 = 5;
+    x += 2;
+    println("x += 2 -> {}", x);
+    x -= 1;
+    println("x -= 1 -> {}", x);
+    x *= 3;
+    println("x *= 3 -> {}", x);
+    x /= 2;
+    println("x /= 2 -> {}", x);
+
+    println("a == b -> {}", a == b);
+    println("a != b -> {}", a != b);
+    println("a < b  -> {}", a < b);
+    println("a <= b -> {}", a <= b);
+    println("a > b  -> {}", a > b);
+    println("a >= b -> {}", a >= b);
+
+    var t: bool = true;
+    var f: bool = false;
+
+    println("t && f -> {}", t && f);
+    println("t || f -> {}", t || f);
+    println("!t -> {}", !t);
+
+    var m: i32 = 0b1010; // 10
+    var n: i32 = 0b0110; // 6
+
+    println("m | n  -> {}", m | n);
+    println("m ^ n  -> {}", m ^ n);
+    println("~m     -> {}", ~m);
+
+    println("a << 1 -> {}", a << 1);
+    println("a >> 1 -> {}", a >> 1);
+
+    var y: i32 = a + b * 2;
+    println("a + b * 2 -> {}", y);
+
+    var z: bool = a > b && b < 5;
+    println("a > b && b < 5 -> {}", z);
+
+    var w: i32 = (a + b) << 2;
+    println("(a + b) << 2 -> {}", w);
+}