Implement Binary combine matchers

Author: AmrDeveloper

src/clang_ql/matchers/combine.rs

@@ -72,6 +72,56 @@ impl<T: Clone> Matcher<T> for CombineMatcher<T> {
     }
 }
 
+#[derive(PartialEq, Clone)]
+enum CombineBinaryMatcherKind {
+    And,
+    Or,
+    Xor,
+}
+
+#[derive(Clone)]
+pub struct CombineBinaryMatcher<T> {
+    lhs: Box<dyn Matcher<T>>,
+    rhs: Box<dyn Matcher<T>>,
+    kind: CombineBinaryMatcherKind,
+}
+
+impl<T: Clone> CombineBinaryMatcher<T> {
+    pub fn and(lhs: Box<dyn Matcher<T>>, rhs: Box<dyn Matcher<T>>) -> Self {
+        CombineBinaryMatcher {
+            lhs,
+            rhs,
+            kind: CombineBinaryMatcherKind::And,
+        }
+    }
+
+    pub fn or(lhs: Box<dyn Matcher<T>>, rhs: Box<dyn Matcher<T>>) -> Self {
+        CombineBinaryMatcher {
+            lhs,
+            rhs,
+            kind: CombineBinaryMatcherKind::Or,
+        }
+    }
+
+    pub fn xor(lhs: Box<dyn Matcher<T>>, rhs: Box<dyn Matcher<T>>) -> Self {
+        CombineBinaryMatcher {
+            lhs,
+            rhs,
+            kind: CombineBinaryMatcherKind::Xor,
+        }
+    }
+}
+
+impl<T: Clone> Matcher<T> for CombineBinaryMatcher<T> {
+    fn is_match(&self, node: &T) -> bool {
+        match &self.kind {
+            CombineBinaryMatcherKind::And => self.lhs.is_match(node) && self.rhs.is_match(node),
+            CombineBinaryMatcherKind::Or => self.lhs.is_match(node) || self.rhs.is_match(node),
+            CombineBinaryMatcherKind::Xor => self.lhs.is_match(node) ^ self.rhs.is_match(node),
+        }
+    }
+}
+
 #[derive(Clone)]
 enum CombineUnaryMatcherKind {
     Not,

src/clang_ql/matchers/mod.rs

@@ -16,6 +16,7 @@ pub use function::IsStaticMethodMatcher;
 pub use function::IsVirtualMatcher;
 
 mod combine;
+pub use combine::CombineBinaryMatcher;
 pub use combine::CombineMatcher;
 pub use combine::UnaryCombineMatcher;
 

src/clang_ql/types/matcher.rs

@@ -25,6 +25,30 @@ impl DataType for FunctionMatcherType {
         self
     }
 
+    fn can_perform_logical_and_op_with(&self) -> Vec<Box<dyn DataType>> {
+        vec![Box::new(FunctionMatcherType)]
+    }
+
+    fn logical_and_op_result_type(&self, _other: &Box<dyn DataType>) -> Box<dyn DataType> {
+        Box::new(FunctionMatcherType)
+    }
+
+    fn can_perform_logical_or_op_with(&self) -> Vec<Box<dyn DataType>> {
+        vec![Box::new(FunctionMatcherType)]
+    }
+
+    fn logical_or_op_result_type(&self, _other: &Box<dyn DataType>) -> Box<dyn DataType> {
+        Box::new(FunctionMatcherType)
+    }
+
+    fn can_perform_logical_xor_op_with(&self) -> Vec<Box<dyn DataType>> {
+        vec![Box::new(FunctionMatcherType)]
+    }
+
+    fn logical_xor_op_result_type(&self, _other: &Box<dyn DataType>) -> Box<dyn DataType> {
+        Box::new(FunctionMatcherType)
+    }
+
     fn can_perform_bang_op(&self) -> bool {
         true
     }

src/clang_ql/values/matcher.rs

@@ -1,6 +1,6 @@
 use gitql_core::values::base::Value;
 
-use crate::clang_ql::matchers::{Matcher, UnaryCombineMatcher};
+use crate::clang_ql::matchers::{CombineBinaryMatcher, Matcher, UnaryCombineMatcher};
 use crate::clang_ql::types::FunctionMatcherType;
 
 use super::FunctionNode;
@@ -37,6 +37,42 @@ impl Value for FunctionMatcherValue {
         self
     }
 
+    fn logical_and_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
+        let lhs = self.matcher.clone();
+        let rhs = other
+            .as_any()
+            .downcast_ref::<FunctionMatcherValue>()
+            .unwrap()
+            .matcher
+            .clone();
+        let combine_matcher = Box::new(CombineBinaryMatcher::and(lhs, rhs));
+        Ok(Box::new(FunctionMatcherValue::new(combine_matcher)))
+    }
+
+    fn logical_or_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
+        let lhs = self.matcher.clone();
+        let rhs = other
+            .as_any()
+            .downcast_ref::<FunctionMatcherValue>()
+            .unwrap()
+            .matcher
+            .clone();
+        let combine_matcher = Box::new(CombineBinaryMatcher::or(lhs, rhs));
+        Ok(Box::new(FunctionMatcherValue::new(combine_matcher)))
+    }
+
+    fn logical_xor_op(&self, other: &Box<dyn Value>) -> Result<Box<dyn Value>, String> {
+        let lhs = self.matcher.clone();
+        let rhs = other
+            .as_any()
+            .downcast_ref::<FunctionMatcherValue>()
+            .unwrap()
+            .matcher
+            .clone();
+        let combine_matcher = Box::new(CombineBinaryMatcher::xor(lhs, rhs));
+        Ok(Box::new(FunctionMatcherValue::new(combine_matcher)))
+    }
+
     fn bang_op(&self) -> Result<Box<dyn Value>, String> {
         let combine_matcher = Box::new(UnaryCombineMatcher::not(self.matcher.clone()));
         Ok(Box::new(FunctionMatcherValue::new(combine_matcher)))