[DO NOT MERGE] Rust edition 2024 - clippy fixes

chain/vm/src/host/context/tx_cache.rs

@@ -43,10 +43,10 @@ impl TxCache {
 
     fn load_account_if_necessary(&self, address: &VMAddress) {
         let mut accounts_mut = self.accounts.lock().unwrap();
-        if !accounts_mut.contains_key(address) {
-            if let Some(blockchain_account) = self.source_ref.load_account(address) {
-                accounts_mut.insert(address.clone(), blockchain_account);
-            }
+        if !accounts_mut.contains_key(address)
+            && let Some(blockchain_account) = self.source_ref.load_account(address)
+        {
+            accounts_mut.insert(address.clone(), blockchain_account);
         }
     }
 

chain/vm/src/host/execution/exec_call.rs

@@ -67,16 +67,16 @@ where
 
     // legacy async call
     // the async call also gets reset
-    if tx_result.result_status.is_success() {
-        if let Some(async_data) = pending_calls.async_call {
-            let (async_result, callback_result) =
-                commit_async_call_and_callback(async_data, state, runtime);
+    if tx_result.result_status.is_success()
+        && let Some(async_data) = pending_calls.async_call
+    {
+        let (async_result, callback_result) =
+            commit_async_call_and_callback(async_data, state, runtime);
 
-            tx_result = merge_async_results(tx_result, async_result);
-            tx_result = merge_async_results(tx_result, callback_result);
+        tx_result = merge_async_results(tx_result, async_result);
+        tx_result = merge_async_results(tx_result, callback_result);
 
-            return tx_result;
-        }
+        return tx_result;
     }
 
     // calling all promises

chain/vm/src/host/vm_hooks/vh_handler/vh_blockchain.rs

@@ -410,23 +410,22 @@ impl<C: VMHooksContext> VMHooksHandler<C> {
         let address = VMAddress::from_slice(self.context.m_types_lock().mb_get(address_handle));
         let token_id_bytes = self.context.m_types_lock().mb_get(token_id_handle).to_vec();
 
-        if let Some(account) = self.context.account_data(&address) {
-            if let Some(esdt_data) = account.esdt.get_by_identifier(token_id_bytes.as_slice()) {
-                if let Some(instance) = esdt_data.instances.get_by_nonce(nonce) {
-                    self.set_esdt_data_values(
-                        esdt_data,
-                        instance,
-                        value_handle,
-                        properties_handle,
-                        hash_handle,
-                        name_handle,
-                        attributes_handle,
-                        creator_handle,
-                        royalties_handle,
-                        uris_handle,
-                    )?
-                }
-            }
+        if let Some(account) = self.context.account_data(&address)
+            && let Some(esdt_data) = account.esdt.get_by_identifier(token_id_bytes.as_slice())
+            && let Some(instance) = esdt_data.instances.get_by_nonce(nonce)
+        {
+            self.set_esdt_data_values(
+                esdt_data,
+                instance,
+                value_handle,
+                properties_handle,
+                hash_handle,
+                name_handle,
+                attributes_handle,
+                creator_handle,
+                royalties_handle,
+                uris_handle,
+            )?
         }
 
         // missing account/token identifier/nonce
@@ -496,10 +495,10 @@ impl<C: VMHooksContext> VMHooksHandler<C> {
 
         let address = VMAddress::from_slice(self.context.m_types_lock().mb_get(address_handle));
         let token_id_bytes = self.context.m_types_lock().mb_get(token_id_handle).to_vec();
-        if let Some(account) = self.context.account_data(&address) {
-            if let Some(esdt_data) = account.esdt.get_by_identifier(token_id_bytes.as_slice()) {
-                return Ok(esdt_data.frozen);
-            }
+        if let Some(account) = self.context.account_data(&address)
+            && let Some(esdt_data) = account.esdt.get_by_identifier(token_id_bytes.as_slice())
+        {
+            return Ok(esdt_data.frozen);
         }
 
         // Might be better to return Err and check

chain/vm/src/system_sc/system_sc_issue.rs

@@ -129,14 +129,12 @@ fn generate_token_identifier_from_ticker(
     let new_random = keccak256(&new_random_base);
     let new_random_for_ticker = &new_random[..3];
 
-    let token_identifier = [
+    [
         ticker,
         "-".as_bytes(),
         hex::encode(new_random_for_ticker).as_bytes(),
     ]
-    .concat();
-
-    token_identifier
+    .concat()
 }
 
 #[cfg(test)]

contracts/examples/multisig/src/multisig.rs

@@ -122,10 +122,10 @@ pub trait Multisig:
         let mut result = MultiValueEncoded::new();
         let num_users = self.user_mapper().get_user_count();
         for user_id in 1..=num_users {
-            if self.user_id_to_role(user_id).get() == role {
-                if let Some(address) = self.user_mapper().get_user_address(user_id) {
-                    result.push(address);
-                }
+            if self.user_id_to_role(user_id).get() == role
+                && let Some(address) = self.user_mapper().get_user_address(user_id)
+            {
+                result.push(address);
             }
         }
         result

contracts/feature-tests/composability/forwarder/src/fwd_call_sync.rs

@@ -102,8 +102,7 @@ pub trait ForwarderSyncCallModule {
         let payment = self.call_value().single_esdt();
         let half_gas = self.blockchain().get_gas_left() / 2;
 
-        let result = self
-            .tx()
+        self.tx()
             .to(&to)
             .gas(half_gas)
             .typed(vault_proxy::VaultProxy)
@@ -114,9 +113,7 @@ pub trait ForwarderSyncCallModule {
                 &payment.amount,
             )
             .returns(ReturnsBackTransfersSingleESDT)
-            .sync_call();
-
-        result
+            .sync_call()
     }
 
     #[allow(deprecated)]

data/codec-derive/src/util.rs

@@ -165,15 +165,14 @@
 }
 
 pub fn sanitize_type_path(mut field: syn::Type) -> proc_macro2::TokenStream {
-    if let syn::Type::Path(ref mut p) = field {
-        if p.path
+    if let syn::Type::Path(ref mut p) = field
+        && p.path
             .to_token_stream()
             .to_string()
             .contains(BITFLAGS_INTERNAL_PATH)
-        {
-            let modified_path = p.path.segments.last_mut().unwrap();
-            modified_path.ident = syn::Ident::new(PRIMITIVE, modified_path.ident.span());
-        }
+    {
+        let modified_path = p.path.segments.last_mut().unwrap();
+        modified_path.ident = syn::Ident::new(PRIMITIVE, modified_path.ident.span());
     }
 
     quote! (#field)

framework/derive/src/generate/convert_to_owned_type.rs

@@ -18,15 +18,14 @@
             return quote! {
                 multiversx_sc::types::Box<[#slice_elem]>
             };
-        } else if let syn::Type::Path(syn::TypePath { path, .. }) = &*type_reference.elem {
-            if let Some(ident) = path.get_ident() {
-                if *ident == "str" {
-                    // TODO: generalize for all unsized types using Box
-                    return quote! {
-                        multiversx_sc::types::Box<str>
-                    };
-                }
-            }
+        } else if let syn::Type::Path(syn::TypePath { path, .. }) = &*type_reference.elem
+            && let Some(ident) = path.get_ident()
+            && *ident == "str"
+        {
+            // TODO: generalize for all unsized types using Box
+            return quote! {
+                Box<str>
+            };
         }
 
         let referenced_type = &*type_reference.elem;

framework/derive/src/generate/restricted_caller_gen.rs

@@ -1,34 +1,34 @@
 use crate::model::{Method, PublicRole};
 
 pub fn generate_only_owner_snippet(m: &Method) -> proc_macro2::TokenStream {
-    if let PublicRole::Endpoint(endpoint_metadata) = &m.public_role {
-        if endpoint_metadata.only_owner {
-            return quote! {
-                self.blockchain().check_caller_is_owner();
-            };
-        }
+    if let PublicRole::Endpoint(endpoint_metadata) = &m.public_role
+        && endpoint_metadata.only_owner
+    {
+        return quote! {
+            self.blockchain().check_caller_is_owner();
+        };
     }
     quote! {}
 }
 
 pub fn generate_only_admin_snippet(m: &Method) -> proc_macro2::TokenStream {
-    if let PublicRole::Endpoint(endpoint_metadata) = &m.public_role {
-        if endpoint_metadata.only_admin {
-            return quote! {
-                self.require_caller_is_admin();
-            };
-        }
+    if let PublicRole::Endpoint(endpoint_metadata) = &m.public_role
+        && endpoint_metadata.only_admin
+    {
+        return quote! {
+            self.require_caller_is_admin();
+        };
     }
     quote! {}
 }
 
 pub fn generate_only_user_account_snippet(m: &Method) -> proc_macro2::TokenStream {
-    if let PublicRole::Endpoint(endpoint_metadata) = &m.public_role {
-        if endpoint_metadata.only_user_account {
-            return quote! {
-                self.blockchain().check_caller_is_user_account();
-            };
-        }
+    if let PublicRole::Endpoint(endpoint_metadata) = &m.public_role
+        && endpoint_metadata.only_user_account
+    {
+        return quote! {
+            self.blockchain().check_caller_is_user_account();
+        };
     }
     quote! {}
 }

framework/derive/src/parse/attributes/doc_attr.rs

@@ -49,12 +49,12 @@
     let mut macro_attributes = Vec::new();
 
     for a in attrs {
-        if let syn::Meta::List(list) = &a.meta {
-            if list.path.is_ident("derive") {
-                for token in list.tokens.clone().into_iter() {
-                    if let proc_macro2::TokenTree::Ident(ident) = token {
-                        macro_attributes.push(ident.to_string());
-                    }
+        if let syn::Meta::List(list) = &a.meta
+            && list.path.is_ident("derive")
+        {
+            for token in list.tokens.clone().into_iter() {
+                if let proc_macro2::TokenTree::Ident(ident) = token {
+                    macro_attributes.push(ident.to_string());
                 }
             }
         }

framework/derive/src/parse/attributes/util.rs

@@ -1,14 +1,14 @@
 use crate::model::EsdtAttribute;
 
 pub(super) fn is_attribute_with_no_args(attr: &syn::Attribute, name: &str) -> bool {
-    if let Some(first_seg) = attr.path().segments.first() {
-        if first_seg.ident == name {
-            assert!(
-                attr.meta.require_path_only().is_ok(),
-                "no arguments allowed for attribute `{name}`"
-            );
-            return true;
-        }
+    if let Some(first_seg) = attr.path().segments.first()
+        && first_seg.ident == name
+    {
+        assert!(
+            attr.meta.require_path_only().is_ok(),
+            "no arguments allowed for attribute `{name}`"
+        );
+        return true;
     };
 
     false
@@ -19,61 +19,61 @@
     name: &str,
 ) -> Option<EsdtAttribute> {
     let attr_path = &attr.path();
-    if let Some(first_seg) = attr_path.segments.first() {
-        if first_seg.ident == name {
-            let (ticker, ty) = match attr.meta.clone() {
-                syn::Meta::Path(_) => {
-                    panic!("attribute needs 2 arguments: ticker (string) and type")
-                }
-                syn::Meta::List(list) => {
-                    assert!(
-                        !list.tokens.is_empty(),
-                        "argument can not be empty. attribute needs 2 arguments: ticker (string) and type"
-                    );
+    if let Some(first_seg) = attr_path.segments.first()
+        && first_seg.ident == name
+    {
+        let (ticker, ty) = match attr.meta.clone() {
+            syn::Meta::Path(_) => {
+                panic!("attribute needs 2 arguments: ticker (string) and type")
+            }
+            syn::Meta::List(list) => {
+                assert!(
+                    !list.tokens.is_empty(),
+                    "argument can not be empty. attribute needs 2 arguments: ticker (string) and type"
+                );
+
+                let mut iter = list.tokens.into_iter();
+
+                let first_literal = match iter.next() {
+                    Some(proc_macro2::TokenTree::Literal(literal)) => literal.to_string(),
+                    _ => {
+                        panic!("expected a string as the first token in the attribute argument")
+                    }
+                };
 
-                    let mut iter = list.tokens.into_iter();
+                let ticker = clean_string(first_literal);
 
-                    let first_literal = match iter.next() {
-                        Some(proc_macro2::TokenTree::Literal(literal)) => literal.to_string(),
-                        _ => {
-                            panic!("expected a string as the first token in the attribute argument")
+                let _ = match iter.next() {
+                    Some(proc_macro2::TokenTree::Punct(punct)) => punct,
+                    _ => panic!("expected a punctuation token after the first literal"),
+                };
+
+                let mut ty = proc_macro2::TokenStream::new();
+
+                for token in &mut iter {
+                    match token {
+                        proc_macro2::TokenTree::Punct(punct) => {
+                            ty.extend(quote! { #punct });
                         }
-                    };
-
-                    let ticker = clean_string(first_literal);
-
-                    let _ = match iter.next() {
-                        Some(proc_macro2::TokenTree::Punct(punct)) => punct,
-                        _ => panic!("expected a punctuation token after the first literal"),
-                    };
-
-                    let mut ty = proc_macro2::TokenStream::new();
-
-                    for token in &mut iter {
-                        match token {
-                            proc_macro2::TokenTree::Punct(punct) => {
-                                ty.extend(quote! { #punct });
-                            }
-                            proc_macro2::TokenTree::Ident(ident) => {
-                                ty.extend(quote! { #ident });
-                            }
-                            _ => break,
+                        proc_macro2::TokenTree::Ident(ident) => {
+                            ty.extend(quote! { #ident });
                         }
+                        _ => break,
                     }
+                }
 
-                    if ticker.trim().is_empty() {
-                        panic!("ticker field can't be empty");
-                    }
-
-                    (ticker, ty)
+                if ticker.trim().is_empty() {
+                    panic!("ticker field can't be empty");
                 }
-                syn::Meta::NameValue(_) => panic!("arguments can not be name value"),
-            };
 
-            let esdt_attribute = EsdtAttribute { ticker, ty };
+                (ticker, ty)
+            }
+            syn::Meta::NameValue(_) => panic!("arguments can not be name value"),
+        };
+
+        let esdt_attribute = EsdtAttribute { ticker, ty };
 
-            return Some(esdt_attribute);
-        }
+        return Some(esdt_attribute);
     }
 
     None