Merge branch 'master' into ironcev/panic-expression

Author: ironcev

.github/workflows/ci.yml

@@ -15,7 +15,7 @@ concurrency:
 env:
   CARGO_TERM_COLOR: always
   REGISTRY: ghcr.io
-  RUST_VERSION: 1.85.0
+  RUST_VERSION: 1.86.0
   NIGHTLY_RUST_VERSION: nightly-2025-03-20
 
 jobs:

forc-pkg/src/manifest/mod.rs

@@ -881,7 +881,7 @@ fn implicit_std_dep() -> Dependency {
 
     if let Some((_, build_metadata)) = det.tag.as_ref().and_then(|tag| tag.split_once('+')) {
         // Nightlies are in the format v<version>+nightly.<date>.<hash>
-        let rev = build_metadata.split('.').last().map(|r| r.to_string());
+        let rev = build_metadata.split('.').next_back().map(|r| r.to_string());
 
         // If some revision is available and parsed from the 'nightly' build metadata,
         // we always prefer the revision over the tag.

forc-pkg/src/pkg.rs

@@ -397,7 +397,7 @@ impl MemberFilter {
                         TreeType::Predicate => self.build_predicates,
                         TreeType::Script => self.build_scripts,
                         TreeType::Contract => self.build_contracts,
-                        TreeType::Library { .. } => self.build_libraries,
+                        TreeType::Library => self.build_libraries,
                     },
                     Err(_) => true,
                 }
@@ -1035,7 +1035,7 @@ fn validate_dep_manifest(
     // Check if the dependency is either a library or a contract declared as a contract dependency
     match (&dep_program_type, &dep_edge.kind) {
         (TreeType::Contract, DepKind::Contract { salt: _ })
-        | (TreeType::Library { .. }, DepKind::Library) => {}
+        | (TreeType::Library, DepKind::Library) => {}
         _ => bail!(
             "\"{}\" is declared as a {} dependency, but is actually a {}",
             dep.name,

forc-util/src/lib.rs

@@ -379,10 +379,10 @@ pub fn path_lock<X: AsRef<Path>>(path: X) -> Result<fd_lock::RwLock<File>> {
 
 pub fn program_type_str(ty: &TreeType) -> &'static str {
     match ty {
-        TreeType::Script {} => "script",
-        TreeType::Contract {} => "contract",
-        TreeType::Predicate {} => "predicate",
-        TreeType::Library { .. } => "library",
+        TreeType::Script => "script",
+        TreeType::Contract => "contract",
+        TreeType::Predicate => "predicate",
+        TreeType::Library => "library",
     }
 }
 

sway-ast/src/path.rs

@@ -22,15 +22,15 @@ impl PathExpr {
         self.suffix
             .iter()
             .map(|s| &s.1)
-            .last()
+            .next_back()
             .unwrap_or(&self.prefix)
     }
 
     pub fn last_segment_mut(&mut self) -> &mut PathExprSegment {
         self.suffix
             .iter_mut()
             .map(|s| &mut s.1)
-            .last()
+            .next_back()
             .unwrap_or(&mut self.prefix)
     }
 }
@@ -87,15 +87,15 @@ impl PathType {
         self.suffix
             .iter()
             .map(|s| &s.1)
-            .last()
+            .next_back()
             .unwrap_or(&self.prefix)
     }
 
     pub fn last_segment_mut(&mut self) -> &mut PathTypeSegment {
         self.suffix
             .iter_mut()
             .map(|s| &mut s.1)
-            .last()
+            .next_back()
             .unwrap_or(&mut self.prefix)
     }
 }

sway-core/src/asm_generation/fuel/data_section.rs

@@ -3,7 +3,7 @@ use sway_ir::{
     size_bytes_round_up_to_word_alignment, ConstantContent, ConstantValue, Context, Padding,
 };
 
-use std::{fmt, iter::repeat};
+use std::fmt;
 
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize)]
 pub enum EntryName {
@@ -178,8 +178,12 @@ impl Entry {
 
         let final_padding = self.padding.target_size().saturating_sub(bytes.len());
         match self.padding {
-            Padding::Left { .. } => [repeat(0u8).take(final_padding).collect(), bytes].concat(),
-            Padding::Right { .. } => [bytes, repeat(0u8).take(final_padding).collect()].concat(),
+            Padding::Left { .. } => {
+                [std::iter::repeat_n(0u8, final_padding).collect(), bytes].concat()
+            }
+            Padding::Right { .. } => {
+                [bytes, std::iter::repeat_n(0u8, final_padding).collect()].concat()
+            }
         }
     }
 

sway-core/src/asm_generation/fuel/register_allocator.rs

@@ -118,9 +118,9 @@ impl RegisterPool {
 /// ===============================================================================================
 /// 1. create a graph node for every virtual register used.
 /// 2. for a MOVE "v <= c" with live_out virtual registers b1, ... bn for v:
-///        add edges (v, b_1), ..., (v, b_n) for any b_i different from c.
+///    add edges (v, b_1), ..., (v, b_n) for any b_i different from c.
 /// 3. for non-MOVE def of virtual register v with live_out virtual registers b_1, ..., b_n:
-///        add edges (v, b_1), ..., (v, b_n)
+///    add edges (v, b_1), ..., (v, b_n)
 ///
 /// ===============================================================================================
 pub(crate) fn create_interference_graph(
@@ -384,8 +384,8 @@ fn compute_def_use_points(ops: &[Op]) -> FxHashMap<VirtualRegister, (Vec<usize>,
 /// 2. Remove node n and all its edges from the graph
 ///    - This may make some new nodes have fewer than k neighbours which is nice.
 /// 3. If some vertex n still has k or more neighbors, then the graph may not be k colorable.
-///     We still add it to the stack as is, as a potential spill. When popping, if we still
-///     can't colour it, then it becomes an actual spill.
+///    We still add it to the stack as is, as a potential spill. When popping, if we still
+///    can't colour it, then it becomes an actual spill.
 ///
 /// ===============================================================================================
 ///

sway-core/src/asm_lang/allocated_ops.rs

@@ -793,9 +793,7 @@ impl AllocatedOp {
             /* Non-VM Instructions */
             BLOB(a) => {
                 return FuelAsmData::Instructions(
-                    std::iter::repeat(op::NOOP::new().into())
-                        .take(a.value() as usize)
-                        .collect(),
+                    std::iter::repeat_n(op::NOOP::new().into(), a.value() as usize).collect(),
                 )
             }
             ConfigurablesOffsetPlaceholder => {

sway-core/src/control_flow_analysis/dead_code_analysis.rs

@@ -44,7 +44,7 @@ fn is_entry_point(node: &TyAstNode, decl_engine: &DeclEngine, tree_type: &TreeTy
                 _ => false,
             }
         }
-        TreeType::Contract | TreeType::Library { .. } => match node {
+        TreeType::Contract | TreeType::Library => match node {
             TyAstNode {
                 content:
                     TyAstNodeContent::Declaration(TyDecl::FunctionDecl(FunctionDecl { decl_id })),
@@ -707,7 +707,7 @@ fn connect_struct_declaration<'eng: 'cfg, 'cfg>(
     //
     // this is important because if the struct is public, you want to be able to signal that all
     // fields are accessible by just adding an edge to the struct declaration node
-    if matches!(tree_type, TreeType::Contract | TreeType::Library { .. })
+    if matches!(tree_type, TreeType::Contract | TreeType::Library)
         && *visibility == Visibility::Public
     {
         for (_name, node) in &field_nodes {
@@ -791,7 +791,7 @@ fn connect_impl_trait<'eng: 'cfg, 'cfg>(
                         if let Some(trait_entry) = trait_entry.clone() {
                             matches!(
                                 trait_entry.module_tree_type,
-                                TreeType::Library { .. } | TreeType::Contract
+                                TreeType::Library | TreeType::Contract
                             )
                         } else {
                             // trait_entry not found which means it is an external trait.
@@ -800,7 +800,7 @@ fn connect_impl_trait<'eng: 'cfg, 'cfg>(
                             true
                         }
                     } else {
-                        matches!(tree_type, TreeType::Library { .. } | TreeType::Contract)
+                        matches!(tree_type, TreeType::Library | TreeType::Contract)
                     };
                 if add_edge_to_fn_decl {
                     graph.add_edge(entry_node, fn_decl_entry_node, "".into());

sway-core/src/ir_generation/compile.rs

@@ -591,10 +591,11 @@ fn compile_fn(
                     // Convert the name.
                     param.name.as_str().into(),
                     // Convert the type further to a pointer if it's a reference.
-                    param
-                        .is_reference
-                        .then(|| Type::new_ptr(context, ty))
-                        .unwrap_or(ty),
+                    if param.is_reference {
+                        Type::new_ptr(context, ty)
+                    } else {
+                        ty
+                    },
                     // Convert the span to a metadata index.
                     md_mgr.span_to_md(context, &param.name.span()),
                 )

sway-core/src/ir_generation/function.rs

@@ -729,7 +729,7 @@ impl<'eng> FnCompiler<'eng> {
                     }),
                 }
             }
-            ty::TyExpressionVariant::Continue { .. } => match self.block_to_continue_to {
+            ty::TyExpressionVariant::Continue => match self.block_to_continue_to {
                 // If `self.block_to_continue_to` is not None, then it has been set inside
                 // a loop and the use of `continue` here is legal, so create a branch
                 // instruction. Error out otherwise.

sway-core/src/ir_generation/storage.rs

@@ -100,9 +100,10 @@ fn hash_storage_key_string(storage_key_string: String) -> Bytes32 {
 use uint::construct_uint;
 
 #[allow(
-// These two warnings are generated by the `construct_uint!()` macro below.
+// These warnings are generated by the `construct_uint!()` macro below.
     clippy::assign_op_pattern,
-    clippy::ptr_offset_with_cast
+    clippy::ptr_offset_with_cast,
+    clippy::manual_div_ceil
 )]
 pub(super) fn add_to_b256(x: Bytes32, y: u64) -> Bytes32 {
     construct_uint! {
@@ -228,7 +229,7 @@ pub fn serialize_to_storage_slots(
             );
             packed.extend(vec![
                 Bytes8::new([0; 8]);
-                ((packed.len() + 3) / 4) * 4 - packed.len()
+                packed.len().div_ceil(4) * 4 - packed.len()
             ]);
 
             assert!(packed.len() % 4 == 0);
@@ -251,7 +252,7 @@ pub fn serialize_to_storage_slots(
             );
 
             let storage_key = get_storage_key(storage_field_names, key);
-            (0..(type_size_in_bytes + 31) / 32)
+            (0..type_size_in_bytes.div_ceil(32))
                 .map(|i| add_to_b256(storage_key, i))
                 .zip((0..packed.len() / 4).map(|i| {
                     Bytes32::new(
@@ -304,7 +305,7 @@ fn serialize_to_words(
         ConstantValue::String(s) if ty.is_string_array(context) => {
             // Turn the bytes into serialized words (Bytes8) and right pad it to the word boundary.
             let mut s = s.clone();
-            s.extend(vec![0; ((s.len() + 7) / 8) * 8 - s.len()]);
+            s.extend(vec![0; s.len().div_ceil(8) * 8 - s.len()]);
 
             assert!(s.len() % 8 == 0);
 

sway-core/src/language/ty/program.rs

@@ -240,7 +240,7 @@ impl TyProgram {
         // Some checks that are specific to non-contracts
         if kind != parsed::TreeType::Contract {
             // impure functions are disallowed in non-contracts
-            if !matches!(kind, parsed::TreeType::Library { .. }) {
+            if !matches!(kind, parsed::TreeType::Library) {
                 for err in disallow_impure_functions(decl_engine, &declarations, &entries) {
                     handler.emit_err(err);
                 }

sway-core/src/lib.rs

@@ -645,7 +645,7 @@ pub(crate) fn is_ty_module_cache_up_to_date(
                 .and_then(|x| x.lsp_mode.as_ref())
                 .and_then(|lsp| lsp.file_versions.get(path.as_ref()))
                 .is_none_or(|version| {
-                    version.map_or(true, |v| typed.version.is_some_and(|tv| v <= tv))
+                    version.is_none_or(|v| typed.version.is_some_and(|tv| v <= tv))
                 });
 
             // If the cache is up to date, recursively check all dependencies
@@ -695,7 +695,7 @@ pub(crate) fn is_parse_module_cache_up_to_date(
                     //   - If there's no cached version (entry.parsed.version is None), the cache is outdated.
                     //   - If there's a cached version, compare them: cache is up-to-date if the LSP file version
                     //     is not greater than the cached version.
-                    version.map_or(true, |v| entry.parsed.version.is_some_and(|ev| v <= ev))
+                    version.is_none_or(|v| entry.parsed.version.is_some_and(|ev| v <= ev))
                 },
             );
 

sway-core/src/semantic_analysis/ast_node/declaration/impl_trait.rs

@@ -757,12 +757,9 @@ impl TyImplSelfOrTrait {
             );
 
             // Do a topological sort to compute an ordered list of nodes (by function calls).
-            let sorted = match petgraph::algo::toposort(&sub_graph, None) {
-                Ok(value) => Some(value),
-                // If the dependency graph contains cycles, then this means there are recursive
-                // function calls, which we will report later.
-                Err(_) => None,
-            };
+            // If the dependency graph contains cycles, then this means there are recursive
+            // function calls, which we will report later.
+            let sorted = petgraph::algo::toposort(&sub_graph, None).ok();
 
             Ok(sorted)
         })

sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/range.rs

@@ -281,11 +281,11 @@ where
     /// 1. Sort the intervals based on increasing order of starting time.
     /// 2. Push the first interval on to a stack.
     /// 3. For each interval do the following
-    ///     3a. If the current interval does not overlap with the stack
-    ///         top, push it.
-    ///     3b. If the current interval overlaps with stack top (or is within ± 1)
-    ///         and ending time of current interval is more than that of stack top,
-    ///         update stack top with the ending time of current interval.
+    ///    3a. If the current interval does not overlap with the stack
+    ///    top, push it.
+    ///    3b. If the current interval overlaps with stack top (or is within ± 1)
+    ///    and ending time of current interval is more than that of stack top,
+    ///    update stack top with the ending time of current interval.
     /// 4. At the end stack contains the merged intervals.
     fn condense_ranges(
         handler: &Handler,

sway-core/src/semantic_analysis/namespace/trait_map.rs

@@ -839,11 +839,11 @@ impl TraitMap {
     ///
     /// Notes:
     /// - equivalency is defined (1) based on whether the types contains types
-    ///     that are dynamic and can change and (2) whether the types hold
-    ///     equivalency after (1) is fulfilled
+    ///   that are dynamic and can change and (2) whether the types hold
+    ///   equivalency after (1) is fulfilled
     /// - this method does not translate types from the found entries to the
-    ///     `type_id` (like in `filter_by_type()`). This is because the only
-    ///     entries that qualify as hits are equivalents of `type_id`
+    ///   `type_id` (like in `filter_by_type()`). This is because the only
+    ///   entries that qualify as hits are equivalents of `type_id`
     pub(crate) fn get_items_for_type(
         module: &Module,
         engines: &Engines,
@@ -901,11 +901,11 @@ impl TraitMap {
     ///
     /// Notes:
     /// - equivalency is defined (1) based on whether the types contains types
-    ///     that are dynamic and can change and (2) whether the types hold
-    ///     equivalency after (1) is fulfilled
+    ///   that are dynamic and can change and (2) whether the types hold
+    ///   equivalency after (1) is fulfilled
     /// - this method does not translate types from the found entries to the
-    ///     `type_id` (like in `filter_by_type()`). This is because the only
-    ///     entries that qualify as hits are equivalents of `type_id`
+    ///   `type_id` (like in `filter_by_type()`). This is because the only
+    ///   entries that qualify as hits are equivalents of `type_id`
     pub fn get_impl_spans_for_type(
         module: &Module,
         engines: &Engines,
@@ -994,11 +994,11 @@ impl TraitMap {
     ///
     /// Notes:
     /// - equivalency is defined (1) based on whether the types contains types
-    ///     that are dynamic and can change and (2) whether the types hold
-    ///     equivalency after (1) is fulfilled
+    ///   that are dynamic and can change and (2) whether the types hold
+    ///   equivalency after (1) is fulfilled
     /// - this method does not translate types from the found entries to the
-    ///     `type_id` (like in `filter_by_type()`). This is because the only
-    ///     entries that qualify as hits are equivalents of `type_id`
+    ///   `type_id` (like in `filter_by_type()`). This is because the only
+    ///   entries that qualify as hits are equivalents of `type_id`
     pub(crate) fn get_items_for_type_and_trait_name_and_trait_type_arguments(
         module: &Module,
         engines: &Engines,
@@ -1066,11 +1066,11 @@ impl TraitMap {
     ///
     /// Notes:
     /// - equivalency is defined (1) based on whether the types contains types
-    ///     that are dynamic and can change and (2) whether the types hold
-    ///     equivalency after (1) is fulfilled
+    ///   that are dynamic and can change and (2) whether the types hold
+    ///   equivalency after (1) is fulfilled
     /// - this method does not translate types from the found entries to the
-    ///     `type_id` (like in `filter_by_type()`). This is because the only
-    ///     entries that qualify as hits are equivalents of `type_id`
+    ///   `type_id` (like in `filter_by_type()`). This is because the only
+    //    entries that qualify as hits are equivalents of `type_id`
     pub(crate) fn get_items_for_type_and_trait_name_and_trait_type_arguments_typed(
         module: &Module,
         engines: &Engines,

sway-core/src/type_system/ast_elements/binding.rs

@@ -70,16 +70,16 @@ use sway_types::{Span, Spanned};
 /// Each of these 4 examples generates a valid struct expression for `Data`
 /// and passes type checking. But each does so in a unique way:
 /// - `data1` has no type ascription and no type arguments in the `TypeBinding`,
-///     so both are inferred from the value passed to `value`
+///   so both are inferred from the value passed to `value`
 /// - `data2` has no type ascription but does have type arguments in the
-///     `TypeBinding`, so the type ascription and type of the value passed to
-///     `value` are both unified to the `TypeBinding`
+///   `TypeBinding`, so the type ascription and type of the value passed to
+///   `value` are both unified to the `TypeBinding`
 /// - `data3` has a type ascription but no type arguments in the `TypeBinding`,
-///     so the type arguments in the `TypeBinding` and the type of the value
-///     passed to `value` are both unified to the type ascription
+///   so the type arguments in the `TypeBinding` and the type of the value
+///   passed to `value` are both unified to the type ascription
 /// - `data4` has a type ascription and has type arguments in the `TypeBinding`,
-///     so, with the type from the value passed to `value`, all three are unified
-///     together
+///   so, with the type from the value passed to `value`, all three are unified
+///   together
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TypeBinding<T> {
     pub inner: T,