chore: Clippy

Author: volsa

src/builtins.rs

@@ -107,7 +107,7 @@ lazy_static! {
                         // Check if this is a qualified method reference like fb.fbSpecificMethod
                         if let Some(resolver::StatementAnnotation::Function { qualified_name, .. }) = generator.annotations.get(reference) {
                             // This is a qualified method reference - return the function pointer directly
-                            if let Some(fn_value) = generator.llvm_index.find_associated_implementation(&qualified_name) {
+                            if let Some(fn_value) = generator.llvm_index.find_associated_implementation(qualified_name) {
                                 return Ok(ExpressionValue::RValue(fn_value.as_global_value().as_pointer_value().as_basic_value_enum()));
                             }
                         }

src/codegen/generators/data_type_generator.rs

@@ -188,13 +188,10 @@ impl<'ink> DataTypeGenerator<'ink, '_> {
         let mut parameter_types = vec![];
 
         // For methods, we need to add the 'this' parameter as the first parameter
-        if let Some(pou_entry) = self.index.find_pou(name) {
-            if let PouIndexEntry::Method { parent_name, .. } = pou_entry {
-                // Get the owner class type and add it as the first parameter (this pointer)
-                if let Ok(owner_type) = self.types_index.get_associated_type(parent_name) {
-                    parameter_types
-                        .push(owner_type.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into());
-                }
+        if let Some(PouIndexEntry::Method { parent_name, .. }) = self.index.find_pou(name) {
+            // Get the owner class type and add it as the first parameter (this pointer)
+            if let Ok(owner_type) = self.types_index.get_associated_type(parent_name) {
+                parameter_types.push(owner_type.ptr_type(AddressSpace::from(ADDRESS_SPACE_GENERIC)).into());
             }
         }
 

src/codegen/generators/expression_generator.rs

@@ -537,17 +537,18 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
         let parameters_list = parameters.map(flatten_expression_list).unwrap_or_default();
 
         // For method function pointers, we need to handle the instance parameter specially
-        let (method_instance, actual_parameters) = if matches!(function_pou, PouIndexEntry::Method { .. }) && !parameters_list.is_empty() {
-            // For methods, the first parameter is the instance, the rest are method parameters
-            // But if there's only one parameter, it's just the instance and there are no method parameters
-            if parameters_list.len() == 1 {
-                (Some(&parameters_list[0]), [].as_slice())
+        let (method_instance, actual_parameters) =
+            if matches!(function_pou, PouIndexEntry::Method { .. }) && !parameters_list.is_empty() {
+                // For methods, the first parameter is the instance, the rest are method parameters
+                // But if there's only one parameter, it's just the instance and there are no method parameters
+                if parameters_list.len() == 1 {
+                    (Some(&parameters_list[0]), [].as_slice())
+                } else {
+                    (Some(&parameters_list[0]), &parameters_list[1..])
+                }
             } else {
-                (Some(&parameters_list[0]), &parameters_list[1..])
-            }
-        } else {
-            (None, parameters_list.as_slice())
-        };
+                (None, parameters_list.as_slice())
+            };
 
         // For function blocks, we need special handling for parameters
         if matches!(function_pou, PouIndexEntry::FunctionBlock { .. }) {
@@ -1682,7 +1683,7 @@ impl<'ink, 'b> ExpressionCodeGenerator<'ink, 'b> {
                 }
 
                 // For regular functions or when not in a method context, return the function pointer
-                if let Some(fn_value) = self.llvm_index.find_associated_implementation(&qualified_name) {
+                if let Some(fn_value) = self.llvm_index.find_associated_implementation(qualified_name) {
                     return Ok(fn_value.as_global_value().as_pointer_value());
                 }
 

src/codegen/llvm_index.rs

@@ -1,3 +1,6 @@
+// TODO(vosa): Remove this
+#![allow(clippy::wrong_self_convention)]
+
 // Copyright (c) 2020 Ghaith Hachem and Mathias Rieder
 use inkwell::types::{AnyTypeEnum, BasicType, BasicTypeEnum, FunctionType, PointerType};
 use inkwell::values::{BasicValueEnum, FunctionValue, GlobalValue, PointerValue};
@@ -25,20 +28,12 @@ pub struct LlvmTypedIndex<'ink> {
 }
 
 pub trait TypeHelper<'ink> {
-    fn is_basic_type(&self) -> bool;
     fn as_basic_type(self) -> Option<BasicTypeEnum<'ink>>;
-    fn is_function(&self) -> bool;
     fn as_function(self) -> Option<FunctionType<'ink>>;
-    fn is_void(&self) -> bool;
-    // fn as_void(self) -> Option<VoidType<'ink>>;
     fn create_ptr_type(&self, address_space: AddressSpace) -> PointerType<'ink>;
 }
 
 impl<'ink> TypeHelper<'ink> for AnyTypeEnum<'ink> {
-    fn is_function(&self) -> bool {
-        matches!(self, AnyTypeEnum::FunctionType(_))
-    }
-
     fn as_function(self) -> Option<FunctionType<'ink>> {
         if let AnyTypeEnum::FunctionType(function_type) = self {
             Some(function_type)
@@ -47,22 +42,6 @@ impl<'ink> TypeHelper<'ink> for AnyTypeEnum<'ink> {
         }
     }
 
-    fn is_void(&self) -> bool {
-        matches!(self, AnyTypeEnum::VoidType(_))
-    }
-
-    fn is_basic_type(&self) -> bool {
-        matches!(
-            self,
-            AnyTypeEnum::ArrayType(_)
-                | AnyTypeEnum::FloatType(_)
-                | AnyTypeEnum::IntType(_)
-                | AnyTypeEnum::PointerType(_)
-                | AnyTypeEnum::StructType(_)
-                | AnyTypeEnum::VectorType(_)
-        )
-    }
-
     fn as_basic_type(self) -> Option<BasicTypeEnum<'ink>> {
         match self {
             AnyTypeEnum::ArrayType(array_type) => Some(array_type.as_basic_type_enum()),

src/resolver.rs

@@ -850,7 +850,7 @@ pub trait AnnotationMap {
             StatementAnnotation::Program { qualified_name }
             | StatementAnnotation::Super { name: qualified_name, .. } => Some(qualified_name.as_str()),
             StatementAnnotation::Type { type_name } => Some(type_name),
-            StatementAnnotation::Function { qualified_name, .. } => Some(&qualified_name),
+            StatementAnnotation::Function { qualified_name, .. } => Some(qualified_name),
             StatementAnnotation::Label { .. }
             | StatementAnnotation::Override { .. }
             | StatementAnnotation::MethodDeclarations { .. }