refactor: Make all ast binary op has similar name for nodes and op

AmrDeveloper · Sep 13, 2024 · 8be92c7 · 8be92c7
1 parent ae107fc
commit 8be92c7
Show file tree

Hide file tree

Showing 3 changed files with 20 additions and 17 deletions.
diff --git a/crates/gitql-ast/src/expression.rs b/crates/gitql-ast/src/expression.rs
@@ -219,7 +219,7 @@ impl Expression for BooleanExpression {
 
 pub struct UnaryExpression {
     pub right: Box<dyn Expression>,
-    pub op: PrefixUnaryOperator,
+    pub operator: PrefixUnaryOperator,
 }
 
 impl Expression for UnaryExpression {
@@ -228,7 +228,7 @@ impl Expression for UnaryExpression {
     }
 
     fn expr_type(&self, scope: &Environment) -> DataType {
-        if self.op == PrefixUnaryOperator::Bang {
+        if self.operator == PrefixUnaryOperator::Bang {
             DataType::Boolean
         } else {
             self.right.expr_type(scope)
@@ -339,9 +339,9 @@ impl Expression for ComparisonExpression {
 }
 
 pub struct ContainsExpression {
-    pub lhs: Box<dyn Expression>,
-    pub rhs: Box<dyn Expression>,
-    pub op: ContainsOperator,
+    pub left: Box<dyn Expression>,
+    pub right: Box<dyn Expression>,
+    pub operator: ContainsOperator,
 }
 
 impl Expression for ContainsExpression {

diff --git a/crates/gitql-engine/src/engine_evaluator.rs b/crates/gitql-engine/src/engine_evaluator.rs
@@ -404,7 +404,7 @@ fn evaluate_prefix_unary(
     object: &Vec<Value>,
 ) -> Result<Value, String> {
     let rhs = evaluate_expression(env, &expr.right, titles, object)?;
-    match expr.op {
+    match expr.operator {
         PrefixUnaryOperator::Minus => {
             if rhs.data_type().is_int() {
                 Ok(Value::Integer(-rhs.as_int()))
@@ -494,10 +494,10 @@ fn evaluate_contains(
     titles: &[String],
     object: &Vec<Value>,
 ) -> Result<Value, String> {
-    let lhs = evaluate_expression(env, &expr.lhs, titles, object)?;
-    let rhs = evaluate_expression(env, &expr.rhs, titles, object)?;
+    let lhs = evaluate_expression(env, &expr.left, titles, object)?;
+    let rhs = evaluate_expression(env, &expr.right, titles, object)?;
 
-    match expr.op {
+    match expr.operator {
         ContainsOperator::RangeContainsElement => {
             let collection_range = lhs.as_range();
             let is_in_range = Ordering::is_ge(collection_range.0.compare(&rhs))

diff --git a/crates/gitql-parser/src/parser.rs b/crates/gitql-parser/src/parser.rs
@@ -1478,7 +1478,7 @@ fn parse_regex_expression(
         return Ok(if has_not_keyword {
             Box::new(UnaryExpression {
                 right: regex_expr,
-                op: PrefixUnaryOperator::Bang,
+                operator: PrefixUnaryOperator::Bang,
             })
         } else {
             regex_expr
@@ -2039,19 +2039,19 @@ fn parse_contains_expression(
                 // Example: Range<T> @> Range<T>
                 if is_both_side_has_same_type {
                     return Ok(Box::new(ContainsExpression {
-                        lhs,
-                        rhs,
-                        op: ContainsOperator::RangeContainsRange,
+                        left: lhs,
+                        right: rhs,
+                        operator: ContainsOperator::RangeContainsRange,
                     }));
                 }
 
                 // Is Range contains another element of the same Range element type
                 // Example: Range<T> @> T
                 if *range_element_type == rhs_type {
                     return Ok(Box::new(ContainsExpression {
-                        lhs,
-                        rhs,
-                        op: ContainsOperator::RangeContainsElement,
+                        left: lhs,
+                        right: rhs,
+                        operator: ContainsOperator::RangeContainsElement,
                     }));
                 }
 
@@ -2504,7 +2504,10 @@ fn parse_prefix_unary_expression(
             _ => {}
         }
 
-        return Ok(Box::new(UnaryExpression { right: rhs, op }));
+        return Ok(Box::new(UnaryExpression {
+            right: rhs,
+            operator: op,
+        }));
     }
 
     parse_function_call_expression(context, env, tokens, position)