Rename Compound Matchers to Combine Matchers similar to LLVM API

Author: AmrDeveloper

docs/InstructionMatcher.md

@@ -137,9 +137,9 @@ Instructions Matchers are functions that build a instruction matcher to match ag
 |   m_invoke   |     ()     | InstMatcher |   Build Inst Matcher that match invoke Instruction   |
 | m_landingpad |     ()     | InstMatcher | Build Inst Matcher that match landingpad Instruction |
 
-### Compound Instructions Matchers functions
+### Combine Instructions Matchers functions
 
 |   Function   |       Parameters       |   Return    |                                   Description                                    |
 | :----------: | :--------------------: | :---------: | :------------------------------------------------------------------------------: |
 | m_inst_oneof | (inst: ...InstMatcher) | InstMatcher | Build Inst Matcher from list of matchers that return true if one of them matches |
-| m_inst_allof | (inst: ...InstMatcher) | InstMatcher | Build Inst Matcher from list of matchers that return true if all of them matches |
+| m_inst_allof | (inst: ...InstMatcher) | InstMatcher | Build Inst Matcher from list of matchers that return true if all of them matches |

src/functions/matchers/combine.rs

@@ -0,0 +1,68 @@
+use std::collections::HashMap;
+
+use gitql_ast::types::varargs::VarargsType;
+use gitql_core::signature::Signature;
+use gitql_core::signature::StandardFunction;
+use gitql_core::values::base::Value;
+
+use crate::ir::types::InstMatcherType;
+use crate::ir::values::InstMatcherValue;
+use crate::matchers::combine::CombineInstMatcher;
+use crate::matchers::InstMatcher;
+
+#[inline(always)]
+pub fn register_combine_matchers_function(map: &mut HashMap<&'static str, StandardFunction>) {
+    map.insert("m_inst_oneof", match_oneof_combine_inst);
+    map.insert("m_inst_allof", match_allof_combine_inst);
+}
+
+#[inline(always)]
+pub fn register_combine_matchers_function_signatures(map: &mut HashMap<&'static str, Signature>) {
+    map.insert(
+        "m_inst_oneof",
+        Signature {
+            parameters: vec![
+                Box::new(InstMatcherType),
+                Box::new(VarargsType {
+                    base: Box::new(InstMatcherType),
+                }),
+            ],
+            return_type: Box::new(InstMatcherType),
+        },
+    );
+
+    map.insert(
+        "m_inst_allof",
+        Signature {
+            parameters: vec![
+                Box::new(InstMatcherType),
+                Box::new(VarargsType {
+                    base: Box::new(InstMatcherType),
+                }),
+            ],
+            return_type: Box::new(InstMatcherType),
+        },
+    );
+}
+
+fn match_oneof_combine_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let mut matchers: Vec<Box<dyn InstMatcher>> = vec![];
+    for value in values.iter() {
+        if let Some(inst_matcher) = value.as_any().downcast_ref::<InstMatcherValue>() {
+            matchers.push(inst_matcher.matcher.to_owned());
+        }
+    }
+    let matcher = Box::new(CombineInstMatcher::create_one_of(matchers));
+    Box::new(InstMatcherValue { matcher })
+}
+
+fn match_allof_combine_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let mut matchers: Vec<Box<dyn InstMatcher>> = vec![];
+    for value in values.iter() {
+        if let Some(inst_matcher) = value.as_any().downcast_ref::<InstMatcherValue>() {
+            matchers.push(inst_matcher.matcher.to_owned());
+        }
+    }
+    let matcher = Box::new(CombineInstMatcher::create_all_of(matchers));
+    Box::new(InstMatcherValue { matcher })
+}

src/functions/matchers/compound.rs

@@ -11,13 +11,13 @@ use crate::matchers::compound::CompoundInstMatcher;
 use crate::matchers::InstMatcher;
 
 #[inline(always)]
-pub fn register_compound_matchers_function(map: &mut HashMap<&'static str, StandardFunction>) {
-    map.insert("m_inst_oneof", match_oneof_compound_inst);
-    map.insert("m_inst_allof", match_allof_compound_inst);
+pub fn register_combine_matchers_function(map: &mut HashMap<&'static str, StandardFunction>) {
+    map.insert("m_inst_oneof", match_oneof_combine_inst);
+    map.insert("m_inst_allof", match_allof_combine_inst);
 }
 
 #[inline(always)]
-pub fn register_compound_matchers_function_signatures(map: &mut HashMap<&'static str, Signature>) {
+pub fn register_combine_matchers_function_signatures(map: &mut HashMap<&'static str, Signature>) {
     map.insert(
         "m_inst_oneof",
         Signature {
@@ -45,24 +45,24 @@ pub fn register_compound_matchers_function_signatures(map: &mut HashMap<&'static
     );
 }
 
-fn match_oneof_compound_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
+fn match_oneof_combine_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
     let mut matchers: Vec<Box<dyn InstMatcher>> = vec![];
     for value in values.iter() {
         if let Some(inst_matcher) = value.as_any().downcast_ref::<InstMatcherValue>() {
             matchers.push(inst_matcher.matcher.to_owned());
         }
     }
-    let matcher = Box::new(CompoundInstMatcher::create_one_of(matchers));
+    let matcher = Box::new(CombineInstMatcher::create_one_of(matchers));
     Box::new(InstMatcherValue { matcher })
 }
 
-fn match_allof_compound_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
+fn match_allof_combine_inst(values: &[Box<dyn Value>]) -> Box<dyn Value> {
     let mut matchers: Vec<Box<dyn InstMatcher>> = vec![];
     for value in values.iter() {
         if let Some(inst_matcher) = value.as_any().downcast_ref::<InstMatcherValue>() {
             matchers.push(inst_matcher.matcher.to_owned());
         }
     }
-    let matcher = Box::new(CompoundInstMatcher::create_all_of(matchers));
+    let matcher = Box::new(CombineInstMatcher::create_all_of(matchers));
     Box::new(InstMatcherValue { matcher })
 }

src/functions/matchers/mod.rs

@@ -1,6 +1,6 @@
 pub mod arithmetic;
 pub mod binary;
-pub mod compound;
+pub mod combine;
 pub mod constants;
 pub mod exception;
 pub mod fcmp;

src/functions/mod.rs

@@ -12,8 +12,8 @@ use matchers::arithmetic::register_arithmetic_matchers_function_signatures;
 use matchers::arithmetic::register_arithmetic_matchers_functions;
 use matchers::binary::register_binary_inst_matchers_function_signatures;
 use matchers::binary::register_binary_inst_matchers_functions;
-use matchers::compound::register_compound_matchers_function;
-use matchers::compound::register_compound_matchers_function_signatures;
+use matchers::combine::register_combine_matchers_function;
+use matchers::combine::register_combine_matchers_function_signatures;
 use matchers::constants::register_constants_matchers_function_signatures;
 use matchers::constants::register_constants_matchers_functions;
 use matchers::exception::register_exception_inst_matchers_function_signatures;
@@ -52,7 +52,7 @@ pub fn llvm_ir_functions() -> &'static HashMap<&'static str, StandardFunction> {
         register_shift_matchers_functions(&mut map);
         register_binary_inst_matchers_functions(&mut map);
         register_exception_inst_matchers_functions(&mut map);
-        register_compound_matchers_function(&mut map);
+        register_combine_matchers_function(&mut map);
         map
     })
 }
@@ -69,7 +69,7 @@ pub fn llvm_ir_function_signatures() -> HashMap<&'static str, Signature> {
     register_shift_matchers_function_signatures(&mut map);
     register_binary_inst_matchers_function_signatures(&mut map);
     register_exception_inst_matchers_function_signatures(&mut map);
-    register_compound_matchers_function_signatures(&mut map);
+    register_combine_matchers_function_signatures(&mut map);
     map
 }
 

src/matchers/compound.rs renamed to src/matchers/combine.rs

@@ -3,46 +3,46 @@ use inkwell::llvm_sys::prelude::LLVMValueRef;
 use super::InstMatcher;
 
 #[derive(PartialEq, Clone)]
-enum CompoundMatcherKind {
+enum CombineMatcherKind {
     OneOf,
     AllOf,
 }
 
 #[derive(Clone)]
-pub struct CompoundInstMatcher {
+pub struct CombineInstMatcher {
     matchers: Vec<Box<dyn InstMatcher>>,
-    matcher_kind: CompoundMatcherKind,
+    matcher_kind: CombineMatcherKind,
 }
 
-impl CompoundInstMatcher {
+impl CombineInstMatcher {
     pub fn create_one_of(matchers: Vec<Box<dyn InstMatcher>>) -> Self {
-        CompoundInstMatcher {
+        CombineInstMatcher {
             matchers,
-            matcher_kind: CompoundMatcherKind::OneOf,
+            matcher_kind: CombineMatcherKind::OneOf,
         }
     }
 
     pub fn create_all_of(matchers: Vec<Box<dyn InstMatcher>>) -> Self {
-        CompoundInstMatcher {
+        CombineInstMatcher {
             matchers,
-            matcher_kind: CompoundMatcherKind::AllOf,
+            matcher_kind: CombineMatcherKind::AllOf,
         }
     }
 }
 
-impl InstMatcher for CompoundInstMatcher {
+impl InstMatcher for CombineInstMatcher {
     fn is_match(&self, instruction: LLVMValueRef) -> bool {
         let mut matches_count = 0;
         for matcher in self.matchers.iter() {
             let is_matches = matcher.is_match(instruction);
 
             // If kind is `oneOf` and one if matches, return true
-            if is_matches && self.matcher_kind == CompoundMatcherKind::OneOf {
+            if is_matches && self.matcher_kind == CombineMatcherKind::OneOf {
                 return true;
             }
 
             // If kind is `allOf` and one is not matches, return false
-            if !is_matches && self.matcher_kind == CompoundMatcherKind::AllOf {
+            if !is_matches && self.matcher_kind == CombineMatcherKind::AllOf {
                 return false;
             }
 
@@ -52,8 +52,8 @@ impl InstMatcher for CompoundInstMatcher {
         }
 
         match self.matcher_kind {
-            CompoundMatcherKind::OneOf => matches_count > 1,
-            CompoundMatcherKind::AllOf => matches_count == self.matchers.len(),
+            CombineMatcherKind::OneOf => matches_count > 1,
+            CombineMatcherKind::AllOf => matches_count == self.matchers.len(),
         }
     }
 }

src/matchers/mod.rs

@@ -39,7 +39,7 @@ impl InstMatcher for AnyInstMatcher {
 
 pub mod arithmetic;
 pub mod binary;
-pub mod compound;
+pub mod combine;
 pub mod constants;
 pub mod exception;
 pub mod fcmp;

src/matchers/other.rs

@@ -33,6 +33,7 @@ pub struct ExtractValueInstMatcher {
 }
 
 impl InstMatcher for ExtractValueInstMatcher {
+    #[allow(clippy::not_unsafe_ptr_arg_deref)]
     fn is_match(&self, instruction: LLVMValueRef) -> bool {
         unsafe {
             if LLVMGetInstructionOpcode(instruction) == LLVMOpcode::LLVMExtractValue {