fix: clippy

lykiadb-lang/benches/parsing.rs

@@ -11,6 +11,12 @@ pub struct ParserBenchmark {
     locals: Locals,
 }
 
+impl Default for ParserBenchmark {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ParserBenchmark {
     pub fn new() -> ParserBenchmark {
         ParserBenchmark {
@@ -60,7 +66,7 @@ fn runtime() {
 
 fn bench(c: &mut Criterion) {
     let mut group = c.benchmark_group("sample-size-example");
-    group.bench_function("2-way join", |b| b.iter(|| runtime()));
+    group.bench_function("2-way join", |b| b.iter(runtime));
     group.finish();
 }
 

lykiadb-lang/src/parser/mod.rs

@@ -912,7 +912,7 @@ macro_rules! optional_with_expected {
     };
 }
 
-impl<'a> Parser<'a> {
+impl Parser<'_> {
     fn sql_insert(&mut self) -> ParseResult<Box<Expr>> {
         if !self.match_next(&skw!(Insert)) {
             return self.sql_update();

lykiadb-lang/src/parser/resolver.rs

@@ -34,11 +34,7 @@ impl<'a> Resolver<'a> {
     ) -> Resolver<'a> {
         Resolver {
             scopes,
-            locals: if let Some(previous_locals) = previous_locals {
-                previous_locals
-            } else {
-                FxHashMap::default()
-            },
+            locals: previous_locals.unwrap_or_default(),
             program,
         }
     }
@@ -91,7 +87,7 @@ impl<'a> Resolver<'a> {
     }
 }
 
-impl<'a> VisitorMut<(), ResolveError> for Resolver<'a> {
+impl VisitorMut<(), ResolveError> for Resolver<'_> {
     fn visit_expr(&mut self, e: &Expr) -> Result<(), ResolveError> {
         match e {
             Expr::Literal { value, .. } => match value {

lykiadb-lang/src/tokenizer/scanner.rs

@@ -21,7 +21,7 @@ pub enum ScanError {
     MalformedNumberLiteral { span: Span },
 }
 
-impl<'a> Scanner<'a> {
+impl Scanner<'_> {
     pub fn scan(source: &str) -> Result<Vec<Token>, ScanError> {
         let mut scanner = Scanner {
             chars: source.chars().enumerate().peekable(),

lykiadb-server/src/engine/error.rs

@@ -169,7 +169,7 @@ pub fn report_error(
 }
 #[cfg(test)]
 mod tests {
-    use core::panic;
+
 
     use super::*;
     use lykiadb_lang::{

lykiadb-server/src/engine/interpreter.rs

@@ -142,7 +142,7 @@ impl LoopStack {
         if self.is_loops_empty() {
             return None;
         }
-        return self.ongoing_loops.last();
+        self.ongoing_loops.last()
     }
 
     pub fn set_last_loop(&mut self, to: LoopState) {
@@ -259,13 +259,13 @@ impl Interpreter {
             self.env_man.read().unwrap().read_at(
                 self.env,
                 unwrapped,
-                &name,
+                name,
                 &self.interner.get_or_intern(name),
             )
         } else {
             self.env_man.read().unwrap().read(
                 self.root_env,
-                &name,
+                name,
                 &self.interner.get_or_intern(name),
             )
         }
@@ -283,7 +283,7 @@ impl Interpreter {
 
         for (i, param) in parameters.iter().enumerate() {
             // TODO: Remove clone here
-            write_guard.declare(fn_env, param.clone(), arguments.get(i).unwrap().clone());
+            write_guard.declare(fn_env, *param, arguments.get(i).unwrap().clone());
         }
 
         drop(write_guard);

lykiadb-server/src/engine/mod.rs

@@ -97,7 +97,7 @@ pub mod test_helpers {
                     .split(',')
                     .map(|flag| {
                         let kv: Vec<&str> = flag.split('=').collect();
-                        return (kv[0].trim(), kv[1].trim());
+                        (kv[0].trim(), kv[1].trim())
                     })
                     .fold(std::collections::HashMap::new(), |mut acc, (k, v)| {
                         acc.insert(k, v);

lykiadb-server/src/value/callable.rs

@@ -67,7 +67,7 @@ impl Function {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             Function::Stateful(_) | Function::Lambda { .. } => write!(f, "<native_fn>"),
-            Function::UserDefined { name, .. } => write!(f, "{}", "<user_defined_fn>"),
+            Function::UserDefined {  .. } => write!(f, "<user_defined_fn>"),
         }
     }
 }

lykiadb-server/src/value/environment.rs

@@ -3,7 +3,7 @@ use core::panic;
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 use std::borrow::{Borrow, BorrowMut};
-use string_interner::{symbol::SymbolU32, StringInterner, Symbol};
+use string_interner::symbol::SymbolU32;
 
 use super::RV;
 
@@ -191,7 +191,7 @@ mod test {
         env_man.declare(env, interner.get_or_intern("five"), RV::Num(5.0));
         assert_eq!(
             env_man
-                .read(env, &"five", &interner.get_or_intern("five"))
+                .read(env, "five", &interner.get_or_intern("five"))
                 .unwrap(),
             RV::Num(5.0)
         );
@@ -206,7 +206,7 @@ mod test {
         let child = env_man.push(Some(parent));
         assert_eq!(
             env_man
-                .read(child, &"five", &interner.get_or_intern("five"))
+                .read(child, "five", &interner.get_or_intern("five"))
                 .unwrap(),
             RV::Num(5.0)
         );
@@ -220,17 +220,17 @@ mod test {
         env_man.declare(parent, interner.get_or_intern("five"), RV::Num(5.0));
         let child = env_man.push(Some(parent));
         env_man
-            .assign(child, &"five", interner.get_or_intern("five"), RV::Num(5.1))
+            .assign(child, "five", interner.get_or_intern("five"), RV::Num(5.1))
             .unwrap();
         assert_eq!(
             env_man
-                .read(parent, &"five", &interner.get_or_intern("five"))
+                .read(parent, "five", &interner.get_or_intern("five"))
                 .unwrap(),
             RV::Num(5.1)
         );
         assert_eq!(
             env_man
-                .read(child, &"five", &interner.get_or_intern("five"))
+                .read(child, "five", &interner.get_or_intern("five"))
                 .unwrap(),
             RV::Num(5.1)
         );
@@ -242,7 +242,7 @@ mod test {
         let mut interner = get_interner();
         let env = env_man.top();
         assert!(env_man
-            .read(env, &"five", &interner.get_or_intern("five"))
+            .read(env, "five", &interner.get_or_intern("five"))
             .is_err());
     }
 
@@ -252,7 +252,7 @@ mod test {
         let mut interner = get_interner();
         let env = env_man.top();
         assert!(env_man
-            .assign(env, &"five", interner.get_or_intern("five"), RV::Num(5.0))
+            .assign(env, "five", interner.get_or_intern("five"), RV::Num(5.0))
             .is_err());
     }
 }