chore: fmt & clippy

Author: freshtonic

packages/eql-mapper/src/inference/sql_fn_macros.rs

@@ -1,30 +1,30 @@
 #[macro_export]
 macro_rules! to_kind {
     (NATIVE) => {
-        crate::Kind::Native
+        $crate::Kind::Native
     };
     ($generic:ident) => {
-        crate::Kind::Generic(stringify!($generic))
+        $crate::Kind::Generic(stringify!($generic))
     };
 }
 
 #[macro_export]
 macro_rules! sql_fn_args {
     (()) => { vec![] };
 
-    (($arg:ident)) => { vec![crate::to_kind!($arg)] };
+    (($arg:ident)) => { vec![$crate::to_kind!($arg)] };
 
     (($arg:ident $(,$rest:ident)*)) => {
-        vec![crate::to_kind!($arg) $(,crate::to_kind!($rest))*]
+        vec![$crate::to_kind!($arg) $(, $crate::to_kind!($rest))*]
     };
 }
 
 #[macro_export]
 macro_rules! sql_fn {
     ($name:ident $args:tt -> $return_kind:ident) => {
-        crate::SqlFunction::new(
+        $crate::SqlFunction::new(
             stringify!($name),
-            FunctionSig::new(crate::sql_fn_args!($args), crate::to_kind!($return_kind)),
+            FunctionSig::new($crate::sql_fn_args!($args), $crate::to_kind!($return_kind)),
         )
     };
-}
+}

packages/eql-mapper/src/inference/sql_functions.rs

@@ -110,7 +110,6 @@ impl FunctionSig {
         };
 
         let args: Vec<Arc<Type>> = (0..arg_count)
-            .into_iter()
             .map(|_| Arc::new(Type::any_native()))
             .collect();
 
@@ -134,7 +133,7 @@ impl InstantiatedSig {
 
         match &function.args {
             FunctionArguments::None => {
-                if self.args.len() == 0 {
+                if self.args.is_empty() {
                     Ok(())
                 } else {
                     Err(TypeError::Conflict(format!(
@@ -197,38 +196,39 @@ impl From<&str> for CompoundIdent {
 impl From<&Vec<Ident>> for CompoundIdent {
     fn from(value: &Vec<Ident>) -> Self {
         let mut idents = Vec1::<SqlIdent<Ident>>::new(SqlIdent(value[0].clone()));
-        idents.extend(value[1..].into_iter().cloned().map(SqlIdent));
+        idents.extend(value[1..].iter().cloned().map(SqlIdent));
         CompoundIdent(idents)
     }
 }
 
 /// SQL functions that are handled with special case type checking rules.
-static SQL_FUNCTION_SIGNATURES: LazyLock<HashMap<CompoundIdent, Vec<FunctionSig>>> = LazyLock::new(|| {
-    // Notation: a single uppercase letter denotes an unknown type. Matching letters in a signature will be assigned
-    // *the same type variable* and thus must resolve to the same type. (🙏 Haskell)
-    //
-    // Eventually we should type check EQL types against their configured indexes instead of leaving that to the EQL
-    // extension in the database. I can imagine supporting type bounds in signatures here, such as: `T: Eq`
-    let sql_fns = vec![
-        sql_fn!(count(T) -> NATIVE),
-        sql_fn!(min(T) -> T),
-        sql_fn!(max(T) -> T),
-        sql_fn!(jsonb_path_query(T, T) -> T),
-        sql_fn!(jsonb_path_query_first(T, T) -> T),
-        sql_fn!(jsonb_path_exists(T, T) -> T),
-    ];
-
-    let mut sql_fns_by_name: HashMap<CompoundIdent, Vec<FunctionSig>> = HashMap::new();
-
-    for (key, chunk) in &sql_fns.into_iter().chunk_by(|sql_fn| sql_fn.0.clone()) {
-        sql_fns_by_name.insert(
-            key.clone(),
-            chunk.into_iter().map(|sql_fn| sql_fn.1).collect(),
-        );
-    }
+static SQL_FUNCTION_SIGNATURES: LazyLock<HashMap<CompoundIdent, Vec<FunctionSig>>> =
+    LazyLock::new(|| {
+        // Notation: a single uppercase letter denotes an unknown type. Matching letters in a signature will be assigned
+        // *the same type variable* and thus must resolve to the same type. (🙏 Haskell)
+        //
+        // Eventually we should type check EQL types against their configured indexes instead of leaving that to the EQL
+        // extension in the database. I can imagine supporting type bounds in signatures here, such as: `T: Eq`
+        let sql_fns = vec![
+            sql_fn!(count(T) -> NATIVE),
+            sql_fn!(min(T) -> T),
+            sql_fn!(max(T) -> T),
+            sql_fn!(jsonb_path_query(T, T) -> T),
+            sql_fn!(jsonb_path_query_first(T, T) -> T),
+            sql_fn!(jsonb_path_exists(T, T) -> T),
+        ];
+
+        let mut sql_fns_by_name: HashMap<CompoundIdent, Vec<FunctionSig>> = HashMap::new();
+
+        for (key, chunk) in &sql_fns.into_iter().chunk_by(|sql_fn| sql_fn.0.clone()) {
+            sql_fns_by_name.insert(
+                key.clone(),
+                chunk.into_iter().map(|sql_fn| sql_fn.1).collect(),
+            );
+        }
 
-    sql_fns_by_name
-});
+        sql_fns_by_name
+    });
 
 pub(crate) fn get_type_signature_for_special_cased_sql_function(
     fn_name: &CompoundIdent,

packages/eql-mapper/src/model/sql_ident.rs

@@ -110,20 +110,20 @@ impl Hash for SqlIdent<&Ident> {
                 state.write_u8(1);
                 state.write_u32(ch as u32);
                 state.write(self.0.value.as_bytes());
-            },
+            }
             None => {
                 state.write_u8(0);
-                for ch in self.0.value.chars().map(|ch| ch.to_lowercase()).flatten() {
+                for ch in self.0.value.chars().flat_map(|ch| ch.to_lowercase()) {
                     state.write_u32(ch as u32);
                 }
-            },
+            }
         }
     }
 }
 
 impl Hash for SqlIdent<Ident> {
     fn hash<H: Hasher>(&self, state: &mut H) {
-       SqlIdent(&self.0).hash(state)
+        SqlIdent(&self.0).hash(state)
     }
 }
 

packages/eql-mapper/src/test_helpers.rs

@@ -46,12 +46,12 @@ pub(crate) fn get_node_key_of_json_selector<'ast>(
         .expect("could not find selector Value node")
 }
 
-pub(crate) fn dummy_encrypted_json_selector<'ast>(
-    statement: &'ast Statement,
+pub(crate) fn dummy_encrypted_json_selector(
+    statement: &Statement,
     selector: Value,
-) -> HashMap<NodeKey<'ast>, ast::Value> {
+) -> HashMap<NodeKey<'_>, ast::Value> {
     if let Value::SingleQuotedString(s) = &selector {
-        return HashMap::from_iter(vec![(
+        HashMap::from_iter(vec![(
             get_node_key_of_json_selector(statement, &selector),
             ast::Value::SingleQuotedString(format!("<encrypted-selector({})>", s)),
         )])
@@ -61,10 +61,10 @@ pub(crate) fn dummy_encrypted_json_selector<'ast>(
 }
 
 /// Utility for finding the [`NodeKey`] of a [`Value`] node in `statement` by providing a `matching` equal node to search for.
-pub(crate) fn find_nodekey_for_value_node<'ast>(
-    statement: &'ast Statement,
+pub(crate) fn find_nodekey_for_value_node(
+    statement: &Statement,
     matching: ast::Value,
-) -> Option<NodeKey<'ast>> {
+) -> Option<NodeKey<'_>> {
     struct FindNode<'ast> {
         needle: ast::Value,
         found: Option<NodeKey<'ast>>,