Bump rust to 1.90 (#1694)

## Description

- Bumps stable rust `1.86.0` -> `1.90.0`
  - Also aligns with sway repo (essentially making local patches easier)
- Minor code changes (cargo clippy) required by rust `1.90.0` toolchain

Required for
FuelLabs/fuel-core#3110 (comment)

# Checklist

- [x] All **changes** are **covered** by **tests** (or not applicable)
- [x] All **changes** are **documented** (or not applicable)
- [x] I **reviewed** the **entire PR** myself (preferably, on GH UI)
- [x] I **described** all **Breaking Changes** (or there's none)

---------

Co-authored-by: z <[email protected]>

Author: zees-dev

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ env:
   FUEL_CORE_VERSION: 0.46.0
   FUEL_CORE_PATCH_BRANCH: ""
   FUEL_CORE_PATCH_REVISION: ""
-  RUST_VERSION: 1.86.0
+  RUST_VERSION: 1.90.0
   FORC_VERSION: 0.69.1
   FORC_PATCH_BRANCH: ""
   FORC_PATCH_REVISION: ""

Cargo.toml

@@ -38,7 +38,7 @@ homepage = "https://fuel.network/"
 readme = "README.md"
 license = "Apache-2.0"
 repository = "https://github.com/FuelLabs/fuels-rs"
-rust-version = "1.86.0"
+rust-version = "1.90.0"
 version = "0.75.1"
 
 [workspace.dependencies]

examples/macros/src/lib.rs

@@ -34,11 +34,13 @@ mod tests {
         use fuels::macros::{Parameterize, Tokenizable};
 
         #[derive(Parameterize, Tokenizable)]
+        #[allow(dead_code)]
         struct MyStruct {
             field_a: u8,
         }
 
         #[derive(Parameterize, Tokenizable)]
+        #[allow(dead_code)]
         enum SomeEnum {
             A(MyStruct),
             B(Vec<u64>),
@@ -58,6 +60,7 @@ mod tests {
             #[derive(Parameterize, Tokenizable)]
             #[FuelsCorePath = "fuels_core_elsewhere"]
             #[FuelsTypesPath = "fuels_types_elsewhere"]
+            #[allow(dead_code)]
             pub struct SomeStruct {
                 field_a: u64,
             }
@@ -68,6 +71,7 @@ mod tests {
             use fuels::macros::{Parameterize, Tokenizable};
             #[derive(Parameterize, Tokenizable)]
             #[NoStd]
+            #[allow(dead_code)]
             pub struct SomeStruct {
                 field_a: u64,
             }

packages/fuels-accounts/src/provider/cache.rs

@@ -102,20 +102,20 @@ where
     async fn consensus_parameters(&self) -> Result<ConsensusParameters> {
         {
             let read_lock = self.cached_consensus_params.read().await;
-            if let Some(entry) = read_lock.as_ref() {
-                if !entry.is_stale(self.clock.now(), self.ttl_config.consensus_parameters) {
-                    return Ok(entry.value.clone());
-                }
+            if let Some(entry) = read_lock.as_ref()
+                && !entry.is_stale(self.clock.now(), self.ttl_config.consensus_parameters)
+            {
+                return Ok(entry.value.clone());
             }
         }
 
         let mut write_lock = self.cached_consensus_params.write().await;
 
         // because it could have been updated since we last checked
-        if let Some(entry) = write_lock.as_ref() {
-            if !entry.is_stale(self.clock.now(), self.ttl_config.consensus_parameters) {
-                return Ok(entry.value.clone());
-            }
+        if let Some(entry) = write_lock.as_ref()
+            && !entry.is_stale(self.clock.now(), self.ttl_config.consensus_parameters)
+        {
+            return Ok(entry.value.clone());
         }
 
         let fresh_parameters = self.client.consensus_parameters().await?;
@@ -132,20 +132,20 @@ where
         let ttl = self.ttl_config.consensus_parameters;
         {
             let read_lock = self.cached_node_info.read().await;
-            if let Some(entry) = read_lock.as_ref() {
-                if !entry.is_stale(self.clock.now(), ttl) {
-                    return Ok(entry.value.clone());
-                }
+            if let Some(entry) = read_lock.as_ref()
+                && !entry.is_stale(self.clock.now(), ttl)
+            {
+                return Ok(entry.value.clone());
             }
         }
 
         let mut write_lock = self.cached_node_info.write().await;
 
         // because it could have been updated since we last checked
-        if let Some(entry) = write_lock.as_ref() {
-            if !entry.is_stale(self.clock.now(), ttl) {
-                return Ok(entry.value.clone());
-            }
+        if let Some(entry) = write_lock.as_ref()
+            && !entry.is_stale(self.clock.now(), ttl)
+        {
+            return Ok(entry.value.clone());
         }
 
         let fresh_node_info = self.client.node_info().await?;

packages/fuels-core/src/types/token.rs

@@ -24,15 +24,15 @@ impl StaticStringToken {
             return Err(error!(Codec, "string data can only have ascii values"));
         }
 
-        if let Some(expected_len) = self.expected_len {
-            if self.data.len() != expected_len {
-                return Err(error!(
-                    Codec,
-                    "string data has len {}, but the expected len is {}",
-                    self.data.len(),
-                    expected_len
-                ));
-            }
+        if let Some(expected_len) = self.expected_len
+            && self.data.len() != expected_len
+        {
+            return Err(error!(
+                Codec,
+                "string data has len {}, but the expected len is {}",
+                self.data.len(),
+                expected_len
+            ));
         }
 
         Ok(())

packages/fuels-core/src/types/tx_status.rs

@@ -118,33 +118,33 @@ impl TxStatus {
         revert_id: Option<u64>,
         log_decoder: Option<&LogDecoder>,
     ) -> Error {
-        if let (Some(revert_id), Some(log_decoder)) = (revert_id, log_decoder) {
-            if let Some(error_detail) = log_decoder.get_error_codes(&revert_id) {
-                let error_message = if error_detail.log_id.is_some() {
-                    log_decoder
-                        .decode_last_log(&receipts)
-                        .unwrap_or_else(|err| {
-                            format!("failed to decode log from require revert: {err}")
-                        })
-                } else {
-                    error_detail.msg.clone().expect("is there")
-                };
+        if let (Some(revert_id), Some(log_decoder)) = (revert_id, log_decoder)
+            && let Some(error_detail) = log_decoder.get_error_codes(&revert_id)
+        {
+            let error_message = if error_detail.log_id.is_some() {
+                log_decoder
+                    .decode_last_log(&receipts)
+                    .unwrap_or_else(|err| {
+                        format!("failed to decode log from require revert: {err}")
+                    })
+            } else {
+                error_detail.msg.clone().expect("is there")
+            };
 
-                let reason = format!(
-                    "panicked at: `{}` - `{}:{}:{}` with message `{}`",
-                    error_detail.pkg,
-                    error_detail.file,
-                    error_detail.line,
-                    error_detail.column,
-                    error_message
-                );
+            let reason = format!(
+                "panicked at: `{}` - `{}:{}:{}` with message `{}`",
+                error_detail.pkg,
+                error_detail.file,
+                error_detail.line,
+                error_detail.column,
+                error_message
+            );
 
-                return Error::Transaction(Reason::Failure {
-                    reason,
-                    revert_id: Some(revert_id),
-                    receipts,
-                });
-            }
+            return Error::Transaction(Reason::Failure {
+                reason,
+                revert_id: Some(revert_id),
+                receipts,
+            });
         }
 
         let reason = match (revert_id, log_decoder) {

packages/fuels-test-helpers/src/lib.rs

@@ -64,13 +64,12 @@ pub fn setup_multiple_assets_coins(
 
 /// Create a vector of UTXOs with the provided AssetIds, num_coins, and amount_per_coin
 pub fn setup_custom_assets_coins(owner: Address, assets: &[AssetConfig]) -> Vec<Coin> {
-    let coins = assets
+    assets
         .iter()
         .flat_map(|asset| {
             setup_single_asset_coins(owner, asset.id, asset.num_coins, asset.coin_amount)
         })
-        .collect::<Vec<Coin>>();
-    coins
+        .collect::<Vec<Coin>>()
 }
 
 /// Create a vector of `num_coins` UTXOs containing `amount_per_coin` amount of asset `asset_id`.