Merge branch 'master' into davxy-secp256-static-context

Author: davxy

crates/env/src/engine/off_chain/chain_extension.rs

@@ -50,6 +50,7 @@ pub trait ChainExtension {
     /// Calls the chain extension with the given input.
     ///
     /// Returns an error code and may fill the `output` buffer with a SCALE encoded result.
+    #[allow(clippy::ptr_arg)]
     fn call(&mut self, input: &[u8], output: &mut Vec<u8>) -> u32;
 }
 

crates/lang/codegen/src/generator/events.rs

@@ -77,6 +77,11 @@ impl<'a> Events<'a> {
     /// Generates the base event enum that comprises all user defined events.
     /// All emitted events are converted into a variant of this enum before being
     /// serialized and emitted to apply their unique event discriminant (ID).
+    ///
+    /// # Developer Note
+    ///
+    /// The `__ink_dylint_EventBase` config attribute is used here to convey the
+    /// information that the generated enum is an ink! event to `dylint`.
     fn generate_event_base(&self) -> TokenStream2 {
         let storage_ident = &self.contract.module().storage().ident();
         let event_idents = self
@@ -90,6 +95,7 @@ impl<'a> Events<'a> {
         quote! {
             #[allow(non_camel_case_types)]
             #[derive(::scale::Encode, ::scale::Decode)]
+            #[cfg(not(feature = "__ink_dylint_EventBase"))]
             pub enum #base_event_ident {
                 #( #event_idents(#event_idents), )*
             }

crates/lang/codegen/src/generator/item_impls.rs

@@ -227,6 +227,11 @@ impl ItemImpls<'_> {
     }
 
     /// Generates the code for the given ink! constructor within an inherent implementation block.
+    ///
+    /// # Developer Note
+    ///
+    /// The `__ink_dylint_Constructor` config attribute is used here to convey the
+    /// information that the generated function is an ink! constructor to `dylint`.
     fn generate_inherent_constructor(constructor: &ir::Constructor) -> TokenStream2 {
         let span = constructor.span();
         let attrs = constructor.attrs();
@@ -236,6 +241,7 @@ impl ItemImpls<'_> {
         let statements = constructor.statements();
         quote_spanned!(span =>
             #( #attrs )*
+            #[cfg(not(feature = "__ink_dylint_Constructor"))]
             #vis fn #ident( #( #inputs ),* ) -> Self {
                 #( #statements )*
             }

crates/lang/codegen/src/generator/storage.rs

@@ -84,6 +84,11 @@ impl Storage<'_> {
     }
 
     /// Generates the storage struct definition.
+    ///
+    /// # Developer Note
+    ///
+    /// The `__ink_dylint_Storage` config attribute is used here to convey the
+    /// information that the generated struct is an ink! storage struct to `dylint`.
     fn generate_storage_struct(&self) -> TokenStream2 {
         let storage = self.contract.module().storage();
         let span = storage.span();
@@ -98,6 +103,7 @@ impl Storage<'_> {
             )]
             #[derive(::ink_storage::traits::SpreadLayout)]
             #[cfg_attr(test, derive(::core::fmt::Debug))]
+            #[cfg(not(feature = "__ink_dylint_Storage"))]
             pub struct #ident {
                 #( #fields ),*
             }

crates/lang/tests/unique_topics.rs

@@ -115,7 +115,7 @@ mod my_contract {
         ///
         /// This function has complexity of `O(n * log n)` and no additional memory
         /// is required, although the order of items is not preserved.
-        fn has_duplicates<T: PartialEq + AsRef<[u8]>>(items: &mut Vec<T>) -> bool {
+        fn has_duplicates<T: PartialEq + AsRef<[u8]>>(items: &mut [T]) -> bool {
             // Sort the vector
             items.sort_by(|a, b| Ord::cmp(a.as_ref(), b.as_ref()));
             // And then find any two consecutive equal elements.

crates/storage/src/lazy/lazy_array.rs

@@ -264,7 +264,7 @@ impl<T, const N: usize> EntryArray<T, N> {
         if at >= Self::capacity() {
             return None
         }
-        (&mut *CacheCell::get_ptr(&self.entries[at as usize]).as_ptr()).as_mut()
+        (*CacheCell::get_ptr(&self.entries[at as usize]).as_ptr()).as_mut()
     }
 
     /// Returns an iterator that yields shared references to all cached entries.