Clippy fix

Author: Glyphack

compat/src/parser_compat.rs

@@ -131,7 +131,6 @@ macro_rules! parser_test {
 // Mostly matching the offsets and names
 #[cfg(test)]
 mod tests {
-    use super::*;
 
     //     #[test]
     //     fn test_simple_compat() {

parser/src/parser/compat.rs

@@ -1,3 +1,4 @@
+#![allow(unused_variables)]
 use crate::ast::*;
 use crate::parser::parser::Parser;
 use serde_json::{json, Value};

typechecker/src/build.rs

@@ -98,7 +98,7 @@ impl<'a> BuildManager {
 
         let span = span!(Level::TRACE, "type check", path = %path.display());
         let _guard = span.enter();
-        let mut checker = TypeChecker::new(*id, &self);
+        let mut checker = TypeChecker::new(*id, self);
         for stmt in file.tree.body.iter() {
             checker.type_check(stmt);
         }

typechecker/src/checker.rs

@@ -6,7 +6,7 @@ use enderpy_python_parser::ast::{self, *};
 
 use super::{type_evaluator::TypeEvaluator, types::PythonType};
 use crate::build::BuildManager;
-use crate::symbol_table::{self, Id};
+use crate::symbol_table::Id;
 use crate::types::ModuleRef;
 use crate::{ast_visitor::TraversalVisitor, diagnostic::CharacterSpan};
 use rust_lapper::{Interval, Lapper};

typechecker/src/symbol_table.rs

@@ -222,7 +222,7 @@ impl SymbolTable {
     pub fn get_scope(&self, pos: u32) -> u32 {
         let scope = self.scopes.iter().find(|scope| scope.start_pos == pos);
         if let Some(scope) = scope {
-            return scope.id;
+            scope.id
         } else {
             panic!("no scope found for position: {}", pos);
         }

typechecker/src/type_evaluator.rs

@@ -707,7 +707,7 @@ impl<'a> TypeEvaluator<'a> {
             symbol_table.file_path,
         );
 
-        let find_in_current_symbol_table = symbol_table.lookup_in_scope(&name, scope_id);
+        let find_in_current_symbol_table = symbol_table.lookup_in_scope(name, scope_id);
         if let Some(f) = find_in_current_symbol_table {
             return self.get_symbol_type(f, symbol_table, position);
         };
@@ -722,7 +722,7 @@ impl<'a> TypeEvaluator<'a> {
             for id in star_import.resolved_ids.iter() {
                 let star_import_sym_table = self.build_manager.symbol_tables.get(id).unwrap();
                 // In the star import we can only lookup the global scope
-                let res = star_import_sym_table.lookup_in_scope(&name, 0);
+                let res = star_import_sym_table.lookup_in_scope(name, 0);
                 match res {
                     Some(res) => {
                         return self.get_symbol_type(res, symbol_table, position);
@@ -1172,7 +1172,7 @@ impl<'a> TypeEvaluator<'a> {
         let found_declaration = match decl {
             Declaration::Class(c) => {
                 let decl_scope = decl.declaration_path().scope_id;
-                self.get_class_declaration_type(&c, builtins_symbol_table, decl_scope)
+                self.get_class_declaration_type(c, builtins_symbol_table, decl_scope)
                     .unwrap_or_else(|_| {
                         panic!("Error getting type for builtin class: {:?}", c.class_node)
                     })
@@ -1699,14 +1699,14 @@ impl<'a> TypeEvaluator<'a> {
 
                 let mut new_class = class_type.clone();
                 new_class.specialized = resolved;
-                return PythonType::Class(new_class);
+                PythonType::Class(new_class)
             }
             PythonType::Instance(instance_type) => todo!(),
             PythonType::Optional(python_type) => todo!(),
             PythonType::TypeVar(type_var) => {
                 let name = type_var.name.as_str();
                 let mut index: Option<usize> = None;
-                for (i, tp) in type_parameters.into_iter().enumerate() {
+                for (i, tp) in type_parameters.iter().enumerate() {
                     let PythonType::TypeVar(ref tp) = tp else {
                         continue;
                     };
@@ -1720,8 +1720,8 @@ impl<'a> TypeEvaluator<'a> {
                 }
 
                 error!("Did not find type parameter {name}");
-                return python_type.clone();
+                python_type.clone()
             }
-        };
+        }
     }
 }

typechecker/src/types.rs

@@ -103,7 +103,7 @@ impl Display for CallableType {
             "(function) Callable ({}): {}",
             signature_str, self.return_type
         );
-        return write!(f, "{}", fmt);
+        write!(f, "{}", fmt)
     }
 }
 
@@ -291,7 +291,7 @@ impl Display for InstanceType {
                 self.class_type.details.qual_name, args_str
             )
         };
-        return write!(f, "{}", fmt);
+        write!(f, "{}", fmt)
     }
 }