Fix clippy warnings for Rust 1.84.0 (#6877)

tritao · web-flow · commit 9df66cea21d6 · 2025-02-03T21:55:35.000Z
## Description

Fix clippy warnings for Rust 1.84.0
diff --git a/forc-plugins/forc-debug/src/server/handlers/handle_set_breakpoints.rs b/forc-plugins/forc-debug/src/server/handlers/handle_set_breakpoints.rs
@@ -61,7 +61,7 @@ impl DapServer {
                 });
                 if let Some(existing_bp) = existing_breakpoints
                     .iter()
-                    .find(|bp| bp.line.map_or(false, |line| line == source_bp.line))
+                    .find(|bp| (bp.line == Some(source_bp.line)))
                 {
                     Breakpoint {
                         verified,
diff --git a/forc-plugins/forc-migrate/src/migrations/mod.rs b/forc-plugins/forc-migrate/src/migrations/mod.rs
@@ -43,7 +43,7 @@ pub(crate) struct MutProgramInfo<'a> {
     pub engines: &'a Engines,
 }
 
-impl<'a> ProgramInfo<'a> {
+impl ProgramInfo<'_> {
     pub(crate) fn as_mut(&mut self) -> MutProgramInfo {
         MutProgramInfo {
             lexed_program: &mut self.lexed_program,
diff --git a/forc-plugins/forc-migrate/src/modifying/storage_field.rs b/forc-plugins/forc-migrate/src/modifying/storage_field.rs
@@ -34,7 +34,7 @@ impl ToInKey for Expr {
     }
 }
 
-impl<'a> Modifier<'a, StorageField> {
+impl Modifier<'_, StorageField> {
     pub(crate) fn with_in_key<K: ToInKey>(&mut self, key: K) -> &mut Self {
         // If the `in` token already exists, just replace the key and leave the `in`
         // token as is. Place the key after the `in` token.
diff --git a/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs b/sway-core/src/asm_generation/fuel/fuel_asm_builder.rs
@@ -1868,7 +1868,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
         if !val
             .get_type(self.context)
             .and_then(|val_ty| key.get_type(self.context).map(|key_ty| (val_ty, key_ty)))
-            .map_or(false, |(val_ty, key_ty)| {
+            .is_some_and(|(val_ty, key_ty)| {
                 val_ty.is_ptr(self.context) && key_ty.is_ptr(self.context)
             })
         {
@@ -1958,7 +1958,7 @@ impl<'ir, 'eng> FuelAsmBuilder<'ir, 'eng> {
         if !store_val
             .get_type(self.context)
             .and_then(|val_ty| key.get_type(self.context).map(|key_ty| (val_ty, key_ty)))
-            .map_or(false, |(val_ty, key_ty)| {
+            .is_some_and(|(val_ty, key_ty)| {
                 val_ty.is_uint64(self.context) && key_ty.is_ptr(self.context)
             })
         {
diff --git a/sway-core/src/asm_generation/fuel/functions.rs b/sway-core/src/asm_generation/fuel/functions.rs
@@ -474,7 +474,7 @@ impl FuelAsmBuilder<'_, '_> {
                         // XXX val.get_type() should be a pointer if it's not meant to be loaded.
                         if val
                             .get_type(self.context)
-                            .map_or(false, |t| self.is_copy_type(&t))
+                            .is_some_and(|t| self.is_copy_type(&t))
                         {
                             self.cur_bytecode.push(Op {
                                 opcode: either::Either::Left(VirtualOp::LW(
diff --git a/sway-core/src/control_flow_analysis/dead_code_analysis.rs b/sway-core/src/control_flow_analysis/dead_code_analysis.rs
@@ -174,7 +174,7 @@ impl<'cfg> ControlFlowGraph<'cfg> {
                         connections_count
                             .get(n)
                             .cloned()
-                            .map_or(false, |count| count > 1)
+                            .is_some_and(|count| count > 1)
                     }
                 }
                 ControlFlowGraphNode::FunctionParameter {
@@ -216,7 +216,7 @@ impl<'cfg> ControlFlowGraph<'cfg> {
                     connections_count
                         .get(n)
                         .cloned()
-                        .map_or(false, |count| count > 0)
+                        .is_some_and(|count| count > 0)
                 }
                 _ => false,
             }
diff --git a/sway-core/src/ir_generation/function.rs b/sway-core/src/ir_generation/function.rs
@@ -329,7 +329,7 @@ impl<'eng> FnCompiler<'eng> {
                 if val
                     .value
                     .get_type(context)
-                    .map_or(false, |ty| ty.is_ptr(context))
+                    .is_some_and(|ty| ty.is_ptr(context))
                 {
                     let load_val = self.current_block.append(context).load(val.value);
                     TerminatorValue::new(load_val, context)
@@ -2540,7 +2540,7 @@ impl<'eng> FnCompiler<'eng> {
 
         let ptr_as_int = if ref_value
             .get_type(context)
-            .map_or(false, |ref_value_type| ref_value_type.is_ptr(context))
+            .is_some_and(|ref_value_type| ref_value_type.is_ptr(context))
         {
             // We are dereferencing a reference variable and we got a pointer to it.
             // To get the address the reference is pointing to we need to load the value.
@@ -4262,7 +4262,7 @@ impl<'eng> FnCompiler<'eng> {
                     let init_type = self.engines.te().get_unaliased(init_expr.return_type);
                     if initializer_val
                         .get_type(context)
-                        .map_or(false, |ty| ty.is_ptr(context))
+                        .is_some_and(|ty| ty.is_ptr(context))
                         && (init_type.is_copy_type() || init_type.is_reference())
                     {
                         // It's a pointer to a copy type, or a reference behind a pointer. We need to dereference it.
diff --git a/sway-core/src/lib.rs b/sway-core/src/lib.rs
@@ -441,14 +441,14 @@ pub(crate) fn is_ty_module_cache_up_to_date(
 ) -> bool {
     let cache = engines.qe().module_cache.read();
     let key = ModuleCacheKey::new(path.clone(), include_tests);
-    cache.get(&key).map_or(false, |entry| {
-        entry.typed.as_ref().map_or(false, |typed| {
+    cache.get(&key).is_some_and(|entry| {
+        entry.typed.as_ref().is_some_and(|typed| {
             // Check if the cache is up to date based on file versions
             let cache_up_to_date = build_config
                 .and_then(|x| x.lsp_mode.as_ref())
                 .and_then(|lsp| lsp.file_versions.get(path.as_ref()))
                 .map_or(true, |version| {
-                    version.map_or(true, |v| typed.version.map_or(false, |tv| v <= tv))
+                    version.map_or(true, |v| typed.version.is_some_and(|tv| v <= tv))
                 });
 
             // If the cache is up to date, recursively check all dependencies
@@ -472,7 +472,7 @@ pub(crate) fn is_parse_module_cache_up_to_date(
 ) -> bool {
     let cache = engines.qe().module_cache.read();
     let key = ModuleCacheKey::new(path.clone(), include_tests);
-    cache.get(&key).map_or(false, |entry| {
+    cache.get(&key).is_some_and(|entry| {
         // Determine if the cached dependency information is still valid
         let cache_up_to_date = build_config
             .and_then(|x| x.lsp_mode.as_ref())
@@ -498,7 +498,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.map_or(false, |ev| v <= ev))
+                    version.map_or(true, |v| entry.parsed.version.is_some_and(|ev| v <= ev))
                 },
             );
 
@@ -601,10 +601,7 @@ pub fn parsed_to_ast(
         experimental,
     );
 
-    let mut typed_program = match typed_program_opt {
-        Ok(typed_program) => typed_program,
-        Err(e) => return Err(e),
-    };
+    let mut typed_program = typed_program_opt?;
 
     check_should_abort(handler, retrigger_compilation.clone()).map_err(|error| {
         TypeCheckFailed {
diff --git a/sway-core/src/query_engine/mod.rs b/sway-core/src/query_engine/mod.rs
@@ -211,7 +211,7 @@ impl QueryEngine {
     pub fn clear_module(&mut self, source_id: &SourceId) {
         self.function_cache
             .write()
-            .retain(|(ident, _), _| ident.span().source_id().map_or(true, |id| id != source_id));
+            .retain(|(ident, _), _| (ident.span().source_id() != Some(source_id)));
     }
 
     /// Removes all data associated with the `program_id` from the function cache.
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/range.rs b/sway-core/src/semantic_analysis/ast_node/expression/match_expression/analysis/range.rs
@@ -493,10 +493,7 @@ where
     }
 
     fn encompasses_all(&self, others: &[Range<T>]) -> bool {
-        others
-            .iter()
-            .map(|other| self.encompasses(other))
-            .all(|x| x)
+        others.iter().all(|other| self.encompasses(other))
     }
 
     /// Checks to see if two ranges are within ± 1 of one another. There are 2
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs
@@ -577,10 +577,7 @@ impl ty::TyExpression {
                 Self::type_check_deref(handler, ctx.by_ref(), expr, span)
             }
         };
-        let mut typed_expression = match res {
-            Ok(r) => r,
-            Err(e) => return Err(e),
-        };
+        let mut typed_expression = res?;
 
         // if the return type cannot be cast into the annotation type then it is a type error
         ctx.unify_with_type_annotation(handler, typed_expression.return_type, &expr_span);
diff --git a/sway-core/src/semantic_analysis/module.rs b/sway-core/src/semantic_analysis/module.rs
@@ -270,7 +270,7 @@ impl ty::TyModule {
 
         // Create a cache key and get the module cache
         let path = engines.se().get_path(source_id);
-        let include_tests = build_config.map_or(false, |x| x.include_tests);
+        let include_tests = build_config.is_some_and(|x| x.include_tests);
         let key = ModuleCacheKey::new(path.clone().into(), include_tests);
         let cache = engines.qe().module_cache.read();
         cache.get(&key).and_then(|entry| {
@@ -475,7 +475,7 @@ impl ty::TyModule {
                 .and_then(|lsp| lsp.file_versions.get(&path).copied())
                 .flatten();
 
-            let include_tests = build_config.map_or(false, |x| x.include_tests);
+            let include_tests = build_config.is_some_and(|x| x.include_tests);
             let key = ModuleCacheKey::new(path.clone().into(), include_tests);
             engines.qe().update_typed_module_cache_entry(
                 &key,
diff --git a/sway-core/src/semantic_analysis/namespace/trait_map.rs b/sway-core/src/semantic_analysis/namespace/trait_map.rs
@@ -640,12 +640,7 @@ impl TraitMap {
         for key in keys {
             let vec = &self.trait_impls[key];
             for entry in vec {
-                if entry
-                    .key
-                    .trait_decl_span
-                    .as_ref()
-                    .map_or(false, |span| span == &trait_decl_span)
-                {
+                if entry.key.trait_decl_span.as_ref() == Some(&trait_decl_span) {
                     let trait_map_vec =
                         if let Some(trait_map_vec) = trait_map.trait_impls.get_mut(key) {
                             trait_map_vec
diff --git a/sway-core/src/type_system/info.rs b/sway-core/src/type_system/info.rs
@@ -1009,10 +1009,7 @@ impl TypeInfo {
                     engines,
                     error_msg_span,
                 );
-                let name = match name {
-                    Ok(name) => name,
-                    Err(e) => return Err(e),
-                };
+                let name = name?;
                 format!("a[{};{}]", name, length.val())
             }
             RawUntypedPtr => "rawptr".to_string(),
diff --git a/sway-ir/src/analysis/dominator.rs b/sway-ir/src/analysis/dominator.rs
@@ -140,7 +140,7 @@ fn compute_dom_tree(
                     // "p" may not be reachable, and hence not in dom_tree.
                     po.block_to_po
                         .get(p)
-                        .map_or(false, |p_po| *p_po > po.block_to_po[b])
+                        .is_some_and(|p_po| *p_po > po.block_to_po[b])
                 })
                 .cloned()
                 .unwrap();
diff --git a/sway-ir/src/analysis/memory_utils.rs b/sway-ir/src/analysis/memory_utils.rs
@@ -326,7 +326,7 @@ fn get_symbols(context: &Context, val: Value, gep_only: bool) -> ReferredSymbols
         }
     }
 
-    if !val.get_type(context).map_or(false, |t| t.is_ptr(context)) {
+    if !val.get_type(context).is_some_and(|t| t.is_ptr(context)) {
         return ReferredSymbols::new(true, IndexSet::default());
     }
 
diff --git a/sway-ir/src/block.rs b/sway-ir/src/block.rs
@@ -374,7 +374,7 @@ impl Block {
     /// Those instructions are: [InstOp::Ret], [FuelVmInstruction::Retd],
     /// [FuelVmInstruction::JmpMem], and [FuelVmInstruction::Revert]).
     pub fn is_terminated_by_return_or_revert(&self, context: &Context) -> bool {
-        self.get_terminator(context).map_or(false, |i| {
+        self.get_terminator(context).is_some_and(|i| {
             matches!(
                 i,
                 Instruction {
diff --git a/sway-ir/src/optimize/constants.rs b/sway-ir/src/optimize/constants.rs
@@ -173,7 +173,7 @@ fn combine_cmp(context: &mut Context, function: &Function) -> bool {
             },
         );
 
-    candidate.map_or(false, |(inst_val, block, cn_replace)| {
+    candidate.is_some_and(|(inst_val, block, cn_replace)| {
         // Replace this `cmp` instruction with a constant.
         inst_val.replace(
             context,
@@ -240,7 +240,7 @@ fn combine_binary_op(context: &mut Context, function: &Function) -> bool {
         );
 
     // Replace this binary op instruction with a constant.
-    candidate.map_or(false, |(inst_val, block, new_value)| {
+    candidate.is_some_and(|(inst_val, block, new_value)| {
         inst_val.replace(context, ValueDatum::Constant(new_value));
         block.remove_instruction(context, inst_val);
         true
@@ -282,7 +282,7 @@ fn remove_useless_binary_op(context: &mut Context, function: &Function) -> bool
                 },
             );
 
-    candidate.map_or(false, |(block, old_value, new_value)| {
+    candidate.is_some_and(|(block, old_value, new_value)| {
         let replace_map = FxHashMap::from_iter([(old_value, new_value)]);
         function.replace_values(context, &replace_map, None);
 
@@ -324,7 +324,7 @@ fn combine_unary_op(context: &mut Context, function: &Function) -> bool {
         );
 
     // Replace this unary op instruction with a constant.
-    candidate.map_or(false, |(inst_val, block, new_value)| {
+    candidate.is_some_and(|(inst_val, block, new_value)| {
         inst_val.replace(context, ValueDatum::Constant(new_value));
         block.remove_instruction(context, inst_val);
         true
diff --git a/sway-ir/src/optimize/sroa.rs b/sway-ir/src/optimize/sroa.rs
@@ -479,12 +479,13 @@ fn candidate_symbols(context: &Context, function: Function) -> FxHashSet<Symbol>
                 }
                 continue;
             }
-            if combine_indices(context, *ptr).map_or(false, |indices| {
-                indices.iter().any(|idx| !idx.is_constant(context))
-            }) || ptr.match_ptr_type(context).is_some_and(|pointee_ty| {
-                super::target_fuel::is_demotable_type(context, &pointee_ty)
-                    && !matches!(inst.op, InstOp::MemCopyVal { .. })
-            }) {
+            if combine_indices(context, *ptr)
+                .is_some_and(|indices| indices.iter().any(|idx| !idx.is_constant(context)))
+                || ptr.match_ptr_type(context).is_some_and(|pointee_ty| {
+                    super::target_fuel::is_demotable_type(context, &pointee_ty)
+                        && !matches!(inst.op, InstOp::MemCopyVal { .. })
+                })
+            {
                 candidates.remove(syms.iter().next().unwrap());
             }
         }
diff --git a/sway-ir/src/verify.rs b/sway-ir/src/verify.rs
@@ -362,8 +362,8 @@ impl InstructionVerifier<'_, '_> {
         let val_ty = value
             .get_type(self.context)
             .ok_or(IrError::VerifyBitcastUnknownSourceType)?;
-        if self.type_bit_size(&val_ty).map_or(false, |sz| sz > 64)
-            || self.type_bit_size(ty).map_or(false, |sz| sz > 64)
+        if self.type_bit_size(&val_ty).is_some_and(|sz| sz > 64)
+            || self.type_bit_size(ty).is_some_and(|sz| sz > 64)
         {
             Err(IrError::VerifyBitcastBetweenInvalidTypes(
                 val_ty.as_string(self.context),
diff --git a/sway-lsp/src/core/session.rs b/sway-lsp/src/core/session.rs
@@ -527,7 +527,7 @@ pub fn parse_lexed_program(
             .map(|path| {
                 item.span()
                     .source_id()
-                    .map_or(false, |id| ctx.engines.se().get_path(id) == *path)
+                    .is_some_and(|id| ctx.engines.se().get_path(id) == *path)
             })
             .unwrap_or(true)
     };
@@ -562,7 +562,7 @@ fn parse_ast_to_tokens(
             .map(|path| {
                 node.span
                     .source_id()
-                    .map_or(false, |id| ctx.engines.se().get_path(id) == *path)
+                    .is_some_and(|id| ctx.engines.se().get_path(id) == *path)
             })
             .unwrap_or(true)
     };
@@ -597,7 +597,7 @@ fn parse_ast_to_typed_tokens(
             .map(|path| {
                 node.span
                     .source_id()
-                    .map_or(false, |id| ctx.engines.se().get_path(id) == *path)
+                    .is_some_and(|id| ctx.engines.se().get_path(id) == *path)
             })
             .unwrap_or(true)
     };
diff --git a/sway-lsp/src/core/token_map.rs b/sway-lsp/src/core/token_map.rs
@@ -239,11 +239,8 @@ impl<'a> TokenMap {
 
     /// Remove all tokens for the given file from the token map.
     pub fn remove_tokens_for_file(&self, path_to_remove: &PathBuf) {
-        self.0.retain(|key, _value| {
-            key.path
-                .as_ref()
-                .map_or(true, |path| path != path_to_remove)
-        });
+        self.0
+            .retain(|key, _value| (key.path.as_ref() != Some(path_to_remove)));
     }
 }
 
diff --git a/sway-parse/src/token.rs b/sway-parse/src/token.rs
@@ -224,7 +224,7 @@ pub fn lex_commented(
             let not_is_single_underscore = character != '_'
                 || l.stream
                     .peek()
-                    .map_or(false, |(_, next)| next.is_xid_continue());
+                    .is_some_and(|(_, next)| next.is_xid_continue());
             if not_is_single_underscore {
                 // Consume until we hit other than `XID_CONTINUE`.
                 while l.stream.next_if(|(_, c)| c.is_xid_continue()).is_some() {}
diff --git a/test/src/test_consistency.rs b/test/src/test_consistency.rs
@@ -113,7 +113,7 @@ fn check_test_forc_tomls(all_tests_dir: &Path) -> Result<()> {
                 .and_then(|t| {
                     t.values().find(|v| {
                         v.get("package")
-                            .map_or(false, |p| p.as_str().unwrap_or_default() == lib_name)
+                            .is_some_and(|p| p.as_str().unwrap_or_default() == lib_name)
                     })
                 })
             {
@@ -216,7 +216,7 @@ fn check_test_forc_tomls(all_tests_dir: &Path) -> Result<()> {
         } else if path.is_file()
             && path
                 .file_name()
-                .map(|f| f.to_ascii_lowercase() == "forc.toml")
+                .map(|f| f.eq_ignore_ascii_case("forc.toml"))
                 .unwrap_or(false)
         {
             forc_tomls.push(path.to_path_buf());

Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ impl DapServer {`
`61`	`61`	`});`
`62`	`62`	`if let Some(existing_bp) = existing_breakpoints`
`63`	`63`	`.iter()`
`64`		`- .find(\|bp\| bp.line.map_or(false, \|line\| line == source_bp.line))`
	`64`	`+ .find(\|bp\| (bp.line == Some(source_bp.line)))`
`65`	`65`	`{`
`66`	`66`	`Breakpoint {`
`67`	`67`	`verified,`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ pub(crate) struct MutProgramInfo<'a> {`
`43`	`43`	`pub engines: &'a Engines,`
`44`	`44`	`}`
`45`	`45`
`46`		`-impl<'a> ProgramInfo<'a> {`
	`46`	`+impl ProgramInfo<'_> {`
`47`	`47`	`pub(crate) fn as_mut(&mut self) -> MutProgramInfo {`
`48`	`48`	`MutProgramInfo {`
`49`	`49`	`lexed_program: &mut self.lexed_program,`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ impl ToInKey for Expr {`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`		`-impl<'a> Modifier<'a, StorageField> {`
	`37`	`+impl Modifier<'_, StorageField> {`
`38`	`38`	`pub(crate) fn with_in_key<K: ToInKey>(&mut self, key: K) -> &mut Self {`
`39`	`39`	// If the `in` token already exists, just replace the key and leave the `in`
`40`	`40`	// token as is. Place the key after the `in` token.
Original file line number	Diff line number	Diff line change
`@@ -474,7 +474,7 @@ impl FuelAsmBuilder<'_, '_> {`
`474`	`474`	`// XXX val.get_type() should be a pointer if it's not meant to be loaded.`
`475`	`475`	`if val`
`476`	`476`	`.get_type(self.context)`
`477`		`- .map_or(false, \|t\| self.is_copy_type(&t))`
	`477`	`+ .is_some_and(\|t\| self.is_copy_type(&t))`
`478`	`478`	`{`
`479`	`479`	`self.cur_bytecode.push(Op {`
`480`	`480`	`opcode: either::Either::Left(VirtualOp::LW(`
Original file line number	Diff line number	Diff line change
`@@ -174,7 +174,7 @@ impl<'cfg> ControlFlowGraph<'cfg> {`
`174`	`174`	`connections_count`
`175`	`175`	`.get(n)`
`176`	`176`	`.cloned()`
`177`		`- .map_or(false, \|count\| count > 1)`
	`177`	`+ .is_some_and(\|count\| count > 1)`
`178`	`178`	`}`
`179`	`179`	`}`
`180`	`180`	`ControlFlowGraphNode::FunctionParameter {`
`@@ -216,7 +216,7 @@ impl<'cfg> ControlFlowGraph<'cfg> {`
`216`	`216`	`connections_count`
`217`	`217`	`.get(n)`
`218`	`218`	`.cloned()`
`219`		`- .map_or(false, \|count\| count > 0)`
	`219`	`+ .is_some_and(\|count\| count > 0)`
`220`	`220`	`}`
`221`	`221`	`_ => false,`
`222`	`222`	`}`
Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,7 @@ impl QueryEngine {`
`211`	`211`	`pub fn clear_module(&mut self, source_id: &SourceId) {`
`212`	`212`	`self.function_cache`
`213`	`213`	`.write()`
`214`		`- .retain(\|(ident, _), _\| ident.span().source_id().map_or(true, \|id\| id != source_id));`
	`214`	`+ .retain(\|(ident, _), _\| (ident.span().source_id() != Some(source_id)));`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	/// Removes all data associated with the `program_id` from the function cache.
Original file line number	Diff line number	Diff line change
`@@ -493,10 +493,7 @@ where`
`493`	`493`	`}`
`494`	`494`
`495`	`495`	`fn encompasses_all(&self, others: &[Range<T>]) -> bool {`
`496`		`- others`
`497`		`- .iter()`
`498`		`- .map(\|other\| self.encompasses(other))`
`499`		`- .all(\|x\| x)`
	`496`	`+ others.iter().all(\|other\| self.encompasses(other))`
`500`	`497`	`}`
`501`	`498`
`502`	`499`	`/// Checks to see if two ranges are within ± 1 of one another. There are 2`