Implement the basic ast matchers for the function table

Author: AmrDeveloper

src/clang_ql/functions/ast/mod.rs

@@ -8,11 +8,11 @@ use gitql_core::signature::Signature;
 use gitql_core::signature::StandardFunction;
 
 #[inline(always)]
-pub fn register_ast_functions(map: &mut HashMap<&'static str, StandardFunction>) {
+pub(crate) fn register_ast_functions(map: &mut HashMap<&'static str, StandardFunction>) {
     register_ast_function_functions(map);
 }
 
 #[inline(always)]
-pub fn register_ast_signatures(map: &mut HashMap<&'static str, Signature>) {
+pub(crate) fn register_ast_signatures(map: &mut HashMap<&'static str, Signature>) {
     register_ast_function_signatures(map);
 }

src/clang_ql/functions/matchers/function.rs

@@ -0,0 +1,107 @@
+use std::collections::HashMap;
+
+use gitql_ast::types::boolean::BoolType;
+use gitql_core::signature::Signature;
+use gitql_core::signature::StandardFunction;
+use gitql_core::values::base::Value;
+use gitql_core::values::boolean::BoolValue;
+
+use crate::clang_ql::matchers::IsConstMethodMatcher;
+use crate::clang_ql::matchers::IsDeletedMethodMatcher;
+use crate::clang_ql::matchers::IsMethodMatcher;
+use crate::clang_ql::matchers::IsPureVirtualMatcher;
+use crate::clang_ql::matchers::IsStaticMethodMatcher;
+use crate::clang_ql::matchers::IsVirtualMatcher;
+use crate::clang_ql::types::FunctionMatcherType;
+use crate::clang_ql::types::FunctionType;
+use crate::clang_ql::values::FunctionMatcherValue;
+use crate::clang_ql::values::FunctionValue;
+
+#[inline(always)]
+pub(crate) fn register_function_matchers_functions(
+    map: &mut HashMap<&'static str, StandardFunction>,
+) {
+    map.insert("m_function", match_function);
+
+    map.insert("m_virtual", match_virtual_function);
+    map.insert("m_pure_virtual", match_pure_virtual_function);
+    map.insert("m_static", match_static_function);
+    map.insert("m_const", match_const_function);
+    map.insert("m_deleted", match_deleted_function);
+    map.insert("m_method", match_method_function);
+}
+
+#[inline(always)]
+pub(crate) fn register_function_matchers_signatures(map: &mut HashMap<&'static str, Signature>) {
+    map.insert(
+        "m_function",
+        Signature::with_return(Box::new(BoolType))
+            .add_parameter(Box::new(FunctionType))
+            .add_parameter(Box::new(FunctionMatcherType)),
+    );
+
+    map.insert(
+        "m_virtual",
+        Signature::with_return(Box::new(FunctionMatcherType)),
+    );
+
+    map.insert(
+        "m_pure_virtual",
+        Signature::with_return(Box::new(FunctionMatcherType)),
+    );
+
+    map.insert(
+        "m_const",
+        Signature::with_return(Box::new(FunctionMatcherType)),
+    );
+
+    map.insert(
+        "m_deleted",
+        Signature::with_return(Box::new(FunctionMatcherType)),
+    );
+
+    map.insert(
+        "m_method",
+        Signature::with_return(Box::new(FunctionMatcherType)),
+    );
+}
+
+fn match_function(values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let function_node = values[0].as_any().downcast_ref::<FunctionValue>().unwrap();
+    let function_matcher = values[1]
+        .as_any()
+        .downcast_ref::<FunctionMatcherValue>()
+        .unwrap();
+    let is_matches = function_matcher.matcher.is_match(&function_node.node);
+    Box::new(BoolValue::new(is_matches))
+}
+
+fn match_virtual_function(_values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let matcher = Box::new(IsVirtualMatcher);
+    Box::new(FunctionMatcherValue::new(matcher))
+}
+
+fn match_pure_virtual_function(_values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let matcher = Box::new(IsPureVirtualMatcher);
+    Box::new(FunctionMatcherValue::new(matcher))
+}
+
+fn match_static_function(_values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let matcher = Box::new(IsStaticMethodMatcher);
+    Box::new(FunctionMatcherValue::new(matcher))
+}
+
+fn match_const_function(_values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let matcher = Box::new(IsConstMethodMatcher);
+    Box::new(FunctionMatcherValue::new(matcher))
+}
+
+fn match_deleted_function(_values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let matcher = Box::new(IsDeletedMethodMatcher);
+    Box::new(FunctionMatcherValue::new(matcher))
+}
+
+fn match_method_function(_values: &[Box<dyn Value>]) -> Box<dyn Value> {
+    let matcher = Box::new(IsMethodMatcher);
+    Box::new(FunctionMatcherValue::new(matcher))
+}

src/clang_ql/functions/matchers/mod.rs

@@ -0,0 +1,16 @@
+use std::collections::HashMap;
+
+use gitql_core::signature::Signature;
+use gitql_core::signature::StandardFunction;
+
+mod function;
+
+#[inline(always)]
+pub(crate) fn register_matchers_functions(map: &mut HashMap<&'static str, StandardFunction>) {
+    function::register_function_matchers_functions(map);
+}
+
+#[inline(always)]
+pub(crate) fn register_matchers_signatures(map: &mut HashMap<&'static str, Signature>) {
+    function::register_function_matchers_signatures(map);
+}

src/clang_ql/functions/mod.rs

@@ -7,13 +7,15 @@ use gitql_std::standard::standard_function_signatures;
 use gitql_std::standard::standard_functions;
 
 mod ast;
+mod matchers;
 
 #[inline(always)]
 pub fn clang_ql_functions() -> &'static HashMap<&'static str, StandardFunction> {
     static HASHMAP: OnceLock<HashMap<&'static str, StandardFunction>> = OnceLock::new();
     HASHMAP.get_or_init(|| {
         let mut map = standard_functions().to_owned();
         ast::register_ast_functions(&mut map);
+        matchers::register_matchers_functions(&mut map);
         map
     })
 }
@@ -22,5 +24,6 @@ pub fn clang_ql_functions() -> &'static HashMap<&'static str, StandardFunction>
 pub fn clang_ql_functions_signatures() -> HashMap<&'static str, Signature> {
     let mut map = standard_function_signatures().to_owned();
     ast::register_ast_signatures(&mut map);
+    matchers::register_matchers_signatures(&mut map);
     map
 }

src/clang_ql/matchers/function.rs

@@ -0,0 +1,67 @@
+use clang_sys::clang_CXXMethod_isConst;
+use clang_sys::clang_CXXMethod_isPureVirtual;
+use clang_sys::clang_CXXMethod_isStatic;
+use clang_sys::clang_CXXMethod_isVirtual;
+use clang_sys::clang_getCursorKind;
+use clang_sys::CXCursor_CXXMethod;
+
+use crate::clang_ql::values::FunctionNode;
+
+use super::FunctionMatcher;
+
+#[derive(Clone)]
+pub struct IsVirtualMatcher;
+
+impl FunctionMatcher for IsVirtualMatcher {
+    fn is_match(&self, function: &FunctionNode) -> bool {
+        unsafe { clang_CXXMethod_isVirtual(function.cursor) != 0 }
+    }
+}
+
+#[derive(Clone)]
+pub struct IsPureVirtualMatcher;
+
+impl FunctionMatcher for IsPureVirtualMatcher {
+    fn is_match(&self, function: &FunctionNode) -> bool {
+        unsafe { clang_CXXMethod_isPureVirtual(function.cursor) != 0 }
+    }
+}
+
+#[derive(Clone)]
+pub struct IsStaticMethodMatcher;
+
+impl FunctionMatcher for IsStaticMethodMatcher {
+    fn is_match(&self, function: &FunctionNode) -> bool {
+        unsafe { clang_CXXMethod_isStatic(function.cursor) != 0 }
+    }
+}
+
+#[derive(Clone)]
+pub struct IsConstMethodMatcher;
+
+impl FunctionMatcher for IsConstMethodMatcher {
+    fn is_match(&self, function: &FunctionNode) -> bool {
+        unsafe { clang_CXXMethod_isConst(function.cursor) != 0 }
+    }
+}
+
+#[derive(Clone)]
+pub struct IsDeletedMethodMatcher;
+
+impl FunctionMatcher for IsDeletedMethodMatcher {
+    fn is_match(&self, function: &FunctionNode) -> bool {
+        unsafe { clang_CXXMethod_isConst(function.cursor) != 0 }
+    }
+}
+
+#[derive(Clone)]
+pub struct IsMethodMatcher;
+
+impl FunctionMatcher for IsMethodMatcher {
+    fn is_match(&self, function: &FunctionNode) -> bool {
+        unsafe {
+            let cursor_kind = clang_getCursorKind(function.cursor);
+            cursor_kind == CXCursor_CXXMethod
+        }
+    }
+}

src/clang_ql/matchers/mod.rs

@@ -2,8 +2,16 @@ use dyn_clone::DynClone;
 
 use super::values::FunctionNode;
 
+mod function;
+pub use function::IsConstMethodMatcher;
+pub use function::IsDeletedMethodMatcher;
+pub use function::IsMethodMatcher;
+pub use function::IsPureVirtualMatcher;
+pub use function::IsStaticMethodMatcher;
+pub use function::IsVirtualMatcher;
+
 dyn_clone::clone_trait_object!(FunctionMatcher);
 
 pub trait FunctionMatcher: DynClone {
-    fn is_match(&self, function: FunctionNode) -> bool;
+    fn is_match(&self, node: &FunctionNode) -> bool;
 }

src/clang_ql/schema.rs

@@ -12,7 +12,7 @@ use gitql_std::aggregation::aggregation_functions;
 use gitql_std::window::window_function_signatures;
 use gitql_std::window::window_functions;
 
-use super::functions::clang_ql_functions;
+use super::functions;
 use super::functions::clang_ql_functions_signatures;
 use super::types::FunctionType;
 use super::types::SourceLocType;
@@ -87,7 +87,7 @@ pub fn create_clang_ql_environment() -> Environment {
     };
 
     let std_signatures = clang_ql_functions_signatures();
-    let std_functions = clang_ql_functions();
+    let std_functions = functions::clang_ql_functions();
 
     let aggregation_signatures = aggregation_function_signatures();
     let aggregation_functions = aggregation_functions();

src/clang_ql/types/matcher.rs

@@ -0,0 +1,27 @@
+use std::any::Any;
+
+use gitql_ast::types::base::DataType;
+
+#[derive(Clone)]
+pub struct FunctionMatcherType;
+
+impl DataType for FunctionMatcherType {
+    fn literal(&self) -> String {
+        "FunctionMatcherType".to_string()
+    }
+
+    #[allow(clippy::borrowed_box)]
+    fn equals(&self, other: &Box<dyn DataType>) -> bool {
+        let self_type: Box<dyn DataType> = Box::new(FunctionMatcherType);
+        other.is_any()
+            || other.is_variant_contains(&self_type)
+            || other
+                .as_any()
+                .downcast_ref::<FunctionMatcherType>()
+                .is_some()
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+}

src/clang_ql/types/mod.rs

@@ -3,3 +3,6 @@ pub use source_location::SourceLocType;
 
 mod function;
 pub use function::FunctionType;
+
+mod matcher;
+pub use matcher::FunctionMatcherType;

src/clang_ql/values/matcher.rs

@@ -0,0 +1,37 @@
+use gitql_core::values::base::Value;
+
+use crate::clang_ql::matchers::FunctionMatcher;
+use crate::clang_ql::types::FunctionMatcherType;
+
+#[derive(Clone)]
+pub struct FunctionMatcherValue {
+    pub matcher: Box<dyn FunctionMatcher>,
+}
+
+impl FunctionMatcherValue {
+    pub fn new(matcher: Box<dyn FunctionMatcher>) -> Self {
+        FunctionMatcherValue { matcher }
+    }
+}
+
+impl Value for FunctionMatcherValue {
+    fn literal(&self) -> String {
+        "FunctionMatcherValue".to_string()
+    }
+
+    fn equals(&self, _other: &Box<dyn Value>) -> bool {
+        false
+    }
+
+    fn compare(&self, _other: &Box<dyn Value>) -> Option<std::cmp::Ordering> {
+        None
+    }
+
+    fn data_type(&self) -> Box<dyn gitql_ast::types::base::DataType> {
+        Box::new(FunctionMatcherType)
+    }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+}

src/clang_ql/values/mod.rs

@@ -5,3 +5,6 @@ pub use source_location::SourceLocValue;
 mod function;
 pub use function::FunctionNode;
 pub use function::FunctionValue;
+
+mod matcher;
+pub use matcher::FunctionMatcherValue;