Support Unary plus operator

Author: AmrDeveloper

crates/gitql-ast/src/operator.rs

@@ -1,6 +1,7 @@
 #[derive(Clone, PartialEq)]
 pub enum PrefixUnaryOperator {
-    Negative,
+    Plus,
+    Minus,
     Bang,
     Not,
 }

crates/gitql-ast/src/types/base.rs

@@ -413,6 +413,19 @@ pub trait DataType: DynClone {
         Box::new(NullType)
     }
 
+    /// Return a list of types that it's possible to perform unary `+' operator with
+    /// between current DataType and any one of them
+    fn can_perform_plus_op(&self) -> bool {
+        false
+    }
+
+    /// Return the expected type after perform unary `+' operator on current type
+    ///
+    /// Note that you don't need to check again that the argument type is possible to perform operator with
+    fn plus_op_result_type(&self) -> Box<dyn DataType> {
+        Box::new(NullType)
+    }
+
     /// Return a list of types that it's possible to perform unary `-' operator with
     /// between current DataType and any one of them
     fn can_perform_neg_op(&self) -> bool {

crates/gitql-ast/src/types/integer.rs

@@ -158,6 +158,14 @@ impl DataType for IntType {
         vec![Box::new(ArrayType::new(Box::new(IntType)))]
     }
 
+    fn can_perform_plus_op(&self) -> bool {
+        true
+    }
+
+    fn plus_op_result_type(&self) -> Box<dyn DataType> {
+        Box::new(self.clone())
+    }
+
     fn can_perform_neg_op(&self) -> bool {
         true
     }

crates/gitql-core/src/values/base.rs

@@ -289,6 +289,11 @@ pub trait Value: DynClone {
         Err("Unsupported operator for this type".to_string())
     }
 
+    /// Perform unary `+` operator and return new [`Value`] represent the result or Exception message as [`String`]
+    fn plus_op(&self) -> Result<Box<dyn Value>, String> {
+        Err("Unsupported operator for this type".to_string())
+    }
+
     /// Perform unary `-` operator and return new [`Value`] represent the result or Exception message as [`String`]
     fn neg_op(&self) -> Result<Box<dyn Value>, String> {
         Err("Unsupported operator for this type".to_string())

crates/gitql-core/src/values/integer.rs

@@ -355,8 +355,12 @@ impl Value for IntValue {
         Err("Unexpected type to perform `<=` with".to_string())
     }
 
+    fn plus_op(&self) -> Result<Box<dyn Value>, String> {
+        Ok(Box::new(IntValue::new(self.value)))
+    }
+
     fn neg_op(&self) -> Result<Box<dyn Value>, String> {
-        Ok(Box::new(IntValue { value: -self.value }))
+        Ok(Box::new(IntValue::new(-self.value)))
     }
 
     fn cast_op(&self, target_type: &Box<dyn DataType>) -> Result<Box<dyn Value>, String> {

crates/gitql-engine/src/engine_evaluator.rs

@@ -325,7 +325,8 @@ fn evaluate_prefix_unary(
 ) -> Result<Box<dyn Value>, String> {
     let rhs = evaluate_expression(env, &expr.right, titles, object)?;
     match expr.operator {
-        PrefixUnaryOperator::Negative => rhs.neg_op(),
+        PrefixUnaryOperator::Plus => rhs.plus_op(),
+        PrefixUnaryOperator::Minus => rhs.neg_op(),
         PrefixUnaryOperator::Bang => rhs.bang_op(),
         PrefixUnaryOperator::Not => rhs.not_op(),
     }

crates/gitql-parser/src/parser.rs

@@ -2958,32 +2958,26 @@ fn parse_prefix_unary_expression(
     if *position < tokens.len() && is_prefix_unary_operator(&tokens[*position]) {
         let operator = &tokens[*position];
 
-        // Consume `!`, `-` or `~` operator
+        // Consume `+`, `-`, `!`, `~` operator
         *position += 1;
 
         let rhs = parse_prefix_unary_expression(context, env, tokens, position)?;
         let rhs_type = rhs.expr_type();
 
-        // Parse and Check side for unary `!`or `NOT` operator
-        if operator.kind == TokenKind::Bang || operator.kind == TokenKind::Not {
+        // Parse and Check side for unary `+` operator
+        if operator.kind == TokenKind::Plus {
             // Can perform this operator between RHS
-            if rhs_type.can_perform_bang_op() {
+            if rhs_type.can_perform_plus_op() {
                 return Ok(Box::new(UnaryExpr {
                     right: rhs,
-                    operator: PrefixUnaryOperator::Bang,
-                    result_type: rhs_type.bang_op_result_type(),
+                    operator: PrefixUnaryOperator::Plus,
+                    result_type: rhs_type.neg_op_result_type(),
                 }));
             }
 
             // Return error if this operator can't be performed even with implicit cast
-            let op_name = if operator.kind == TokenKind::Bang {
-                "!"
-            } else {
-                "NOT"
-            };
-
             return Err(Diagnostic::error(&format!(
-                "Operator unary `{op_name}` can't be performed on type `{rhs_type}`"
+                "Operator unary `+` can't be performed on type `{rhs_type}`"
             ))
             .with_location(operator.location)
             .as_boxed());
@@ -2995,7 +2989,7 @@ fn parse_prefix_unary_expression(
             if rhs_type.can_perform_neg_op() {
                 return Ok(Box::new(UnaryExpr {
                     right: rhs,
-                    operator: PrefixUnaryOperator::Negative,
+                    operator: PrefixUnaryOperator::Minus,
                     result_type: rhs_type.neg_op_result_type(),
                 }));
             }
@@ -3008,6 +3002,31 @@ fn parse_prefix_unary_expression(
             .as_boxed());
         }
 
+        // Parse and Check side for unary `!`or `NOT` operator
+        if operator.kind == TokenKind::Bang || operator.kind == TokenKind::Not {
+            // Can perform this operator between RHS
+            if rhs_type.can_perform_bang_op() {
+                return Ok(Box::new(UnaryExpr {
+                    right: rhs,
+                    operator: PrefixUnaryOperator::Bang,
+                    result_type: rhs_type.bang_op_result_type(),
+                }));
+            }
+
+            // Return error if this operator can't be performed even with implicit cast
+            let op_name = if operator.kind == TokenKind::Bang {
+                "!"
+            } else {
+                "NOT"
+            };
+
+            return Err(Diagnostic::error(&format!(
+                "Operator unary `{op_name}` can't be performed on type `{rhs_type}`"
+            ))
+            .with_location(operator.location)
+            .as_boxed());
+        }
+
         // Parse and Check side for unary `~` operator
         if operator.kind == TokenKind::BitwiseNot {
             // Can perform this operator between RHS
@@ -3026,6 +3045,14 @@ fn parse_prefix_unary_expression(
             .with_location(operator.location)
             .as_boxed());
         }
+
+        // Unkown unary operator
+        return Err(Diagnostic::error(&format!(
+            "Operator unary `{}` is not supported for `{rhs_type}`",
+            operator
+        ))
+        .with_location(operator.location)
+        .as_boxed());
     }
 
     parse_between_expression(context, env, tokens, position)
@@ -4017,7 +4044,11 @@ fn is_bitwise_shift_operator(tokens: &[Token], position: &usize) -> bool {
 fn is_prefix_unary_operator(token: &Token) -> bool {
     matches!(
         token.kind,
-        TokenKind::Bang | TokenKind::Not | TokenKind::Minus | TokenKind::BitwiseNot
+        TokenKind::Plus
+            | TokenKind::Bang
+            | TokenKind::Not
+            | TokenKind::Minus
+            | TokenKind::BitwiseNot
     )
 }