Auto merge of #13929 - danieleades:simplify, r=lnicola

internal: a number of code simplifications

crates/hir-def/src/body/pretty.rs

@@ -80,7 +80,7 @@ impl<'a> Write for Printer<'a> {
     fn write_str(&mut self, s: &str) -> fmt::Result {
         for line in s.split_inclusive('\n') {
             if self.needs_indent {
-                match self.buf.chars().rev().skip_while(|ch| *ch == ' ').next() {
+                match self.buf.chars().rev().find(|ch| *ch != ' ') {
                     Some('\n') | None => {}
                     _ => self.buf.push('\n'),
                 }
@@ -113,7 +113,7 @@ impl<'a> Printer<'a> {
     }
 
     fn newline(&mut self) {
-        match self.buf.chars().rev().skip_while(|ch| *ch == ' ').next() {
+        match self.buf.chars().rev().find(|ch| *ch != ' ') {
             Some('\n') | None => {}
             _ => writeln!(self).unwrap(),
         }

crates/hir-def/src/nameres/collector.rs

@@ -1600,8 +1600,7 @@ impl ModCollector<'_, '_> {
                         FunctionLoc { container, id: ItemTreeId::new(self.tree_id, id) }.intern(db);
 
                     let vis = resolve_vis(def_map, &self.item_tree[it.visibility]);
-                    if self.def_collector.is_proc_macro {
+                    if self.def_collector.is_proc_macro && self.module_id == def_map.root {
-                        if self.module_id == def_map.root {
                         if let Some(proc_macro) = attrs.parse_proc_macro_decl(&it.name) {
                             let crate_root = def_map.module_id(def_map.root);
                             self.def_collector.export_proc_macro(
@@ -1612,7 +1611,6 @@ impl ModCollector<'_, '_> {
                             );
                         }
                     }
-                    }
 
                     update_def(self.def_collector, fn_id.into(), &it.name, vis, false);
                 }

crates/hir-ty/src/infer/expr.rs

@@ -1136,8 +1136,7 @@ impl<'a> InferenceContext<'a> {
             if self.diverges.is_always() {
                 // we don't even make an attempt at coercion
                 self.table.new_maybe_never_var()
-            } else {
+            } else if let Some(t) = expected.only_has_type(&mut self.table) {
-                if let Some(t) = expected.only_has_type(&mut self.table) {
                 if self.coerce(Some(expr), &TyBuilder::unit(), &t).is_err() {
                     self.result.type_mismatches.insert(
                         expr.into(),
@@ -1150,7 +1149,6 @@ impl<'a> InferenceContext<'a> {
             }
         }
     }
-    }
 
     fn infer_method_call(
         &mut self,
@@ -1314,8 +1312,9 @@ impl<'a> InferenceContext<'a> {
                 } else {
                     param_ty
                 };
-                if !coercion_target.is_unknown() {
+                if !coercion_target.is_unknown()
-                    if self.coerce(Some(arg), &ty, &coercion_target).is_err() {
+                    && self.coerce(Some(arg), &ty, &coercion_target).is_err()
+                {
                     self.result.type_mismatches.insert(
                         arg.into(),
                         TypeMismatch { expected: coercion_target, actual: ty.clone() },
@@ -1324,7 +1323,6 @@ impl<'a> InferenceContext<'a> {
             }
         }
     }
-    }
 
     fn substs_for_method_call(
         &mut self,

crates/hir-ty/src/layout.rs

@@ -251,18 +251,15 @@ fn layout_of_unit(cx: &LayoutCx<'_>, dl: &TargetDataLayout) -> Result<Layout, La
 
 fn struct_tail_erasing_lifetimes(db: &dyn HirDatabase, pointee: Ty) -> Ty {
     match pointee.kind(Interner) {
-        TyKind::Adt(AdtId(adt), subst) => match adt {
+        TyKind::Adt(AdtId(hir_def::AdtId::StructId(i)), subst) => {
-            &hir_def::AdtId::StructId(i) => {
+            let data = db.struct_data(*i);
-                let data = db.struct_data(i);
             let mut it = data.variant_data.fields().iter().rev();
             match it.next() {
-                    Some((f, _)) => field_ty(db, i.into(), f, subst),
+                Some((f, _)) => field_ty(db, (*i).into(), f, subst),
                 None => pointee,
             }
         }
         _ => pointee,
-        },
-        _ => pointee,
     }
 }
 

crates/hir/src/lib.rs

@@ -472,8 +472,8 @@ impl Module {
         let def_map = self.id.def_map(db.upcast());
         let children = def_map[self.id.local_id]
             .children
-            .iter()
+            .values()
-            .map(|(_, module_id)| Module { id: def_map.module_id(*module_id) })
+            .map(|module_id| Module { id: def_map.module_id(*module_id) })
             .collect::<Vec<_>>();
         children.into_iter()
     }

crates/ide-assists/src/handlers/extract_type_alias.rs

@@ -161,8 +161,7 @@ fn collect_used_generics<'gp>(
                     .and_then(|lt| known_generics.iter().find(find_lifetime(&lt.text()))),
             ),
             ast::Type::ArrayType(ar) => {
-                if let Some(expr) = ar.expr() {
+                if let Some(ast::Expr::PathExpr(p)) = ar.expr() {
-                    if let ast::Expr::PathExpr(p) = expr {
                     if let Some(path) = p.path() {
                         if let Some(name_ref) = path.as_single_name_ref() {
                             if let Some(param) = known_generics.iter().find(|gp| {
@@ -178,7 +177,6 @@ fn collect_used_generics<'gp>(
                     }
                 }
             }
-            }
             _ => (),
         };
         false

crates/ide-assists/src/handlers/generate_default_from_new.rs

@@ -82,18 +82,18 @@ fn generate_trait_impl_text_from_impl(impl_: &ast::Impl, trait_text: &str, code:
     let generic_params = impl_.generic_param_list().map(|generic_params| {
         let lifetime_params =
             generic_params.lifetime_params().map(ast::GenericParam::LifetimeParam);
-        let ty_or_const_params = generic_params.type_or_const_params().filter_map(|param| {
+        let ty_or_const_params = generic_params.type_or_const_params().map(|param| {
             // remove defaults since they can't be specified in impls
             match param {
                 ast::TypeOrConstParam::Type(param) => {
                     let param = param.clone_for_update();
                     param.remove_default();
-                    Some(ast::GenericParam::TypeParam(param))
+                    ast::GenericParam::TypeParam(param)
                 }
                 ast::TypeOrConstParam::Const(param) => {
                     let param = param.clone_for_update();
                     param.remove_default();
-                    Some(ast::GenericParam::ConstParam(param))
+                    ast::GenericParam::ConstParam(param)
                 }
             }
         });

crates/ide-assists/src/handlers/merge_imports.rs

@@ -92,7 +92,7 @@ trait Merge: AstNode + Clone {
     fn try_merge_from(self, items: &mut dyn Iterator<Item = Self>) -> Option<Vec<Edit>> {
         let mut edits = Vec::new();
         let mut merged = self.clone();
-        while let Some(item) = items.next() {
+        for item in items {
             merged = merged.try_merge(&item)?;
             edits.push(Edit::Remove(item.into_either()));
         }

crates/ide-assists/src/handlers/unmerge_match_arm.rs

@@ -86,8 +86,7 @@ pub(crate) fn unmerge_match_arm(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
                     it.prev_sibling_or_token()
                 })
                 .map(|it| it.kind())
-                .skip_while(|it| it.is_trivia())
+                .find(|it| !it.is_trivia())
-                .next()
                     == Some(T![,]);
             let has_arms_after = neighbor(&match_arm, Direction::Next).is_some();
             if !has_comma_after && !has_arms_after {

crates/ide-db/src/rename.rs

@@ -334,13 +334,11 @@ pub fn source_edit_from_references(
             }
             _ => false,
         };
-        if !has_emitted_edit {
+        if !has_emitted_edit && !edited_ranges.contains(&range.start()) {
-            if !edited_ranges.contains(&range.start()) {
             edit.replace(range, new_name.to_string());
             edited_ranges.push(range.start());
         }
     }
-    }
 
     edit.finish()
 }
@@ -391,8 +389,7 @@ fn source_edit_from_name_ref(
                         edit.delete(TextRange::new(s, e));
                         return true;
                     }
-                } else if init == name_ref {
+                } else if init == name_ref && field_name.text() == new_name {
-                    if field_name.text() == new_name {
                     cov_mark::hit!(test_rename_local_put_init_shorthand);
                     // Foo { field: local } -> Foo { field }
                     //            ^^^^^^^ delete this
@@ -405,7 +402,6 @@ fn source_edit_from_name_ref(
                     return true;
                 }
             }
-            }
             // init shorthand
             (None, Some(_)) if matches!(def, Definition::Field(_)) => {
                 cov_mark::hit!(test_rename_field_in_field_shorthand);

crates/ide-db/src/search.rs

@@ -494,13 +494,11 @@ impl<'a> FindUsages<'a> {
         }
 
         // Search for `super` and `crate` resolving to our module
-        match self.def {
+        if let Definition::Module(module) = self.def {
-            Definition::Module(module) => {
+            let scope =
-                let scope = search_scope
+                search_scope.intersection(&SearchScope::module_and_children(self.sema.db, module));
-                    .intersection(&SearchScope::module_and_children(self.sema.db, module));
 
-                let is_crate_root =
+            let is_crate_root = module.is_crate_root(self.sema.db).then(|| Finder::new("crate"));
-                    module.is_crate_root(self.sema.db).then(|| Finder::new("crate"));
             let finder = &Finder::new("super");
 
             for (text, file_id, search_range) in scope_files(sema, &scope) {
@@ -528,8 +526,6 @@ impl<'a> FindUsages<'a> {
                 }
             }
         }
-            _ => (),
-        }
 
         // search for module `self` references in our module's definition source
         match self.def {

crates/ide-db/src/symbol_index.rs

@@ -323,11 +323,11 @@ impl Query {
                         if symbol.name != self.query {
                             continue;
                         }
-                    } else if self.case_sensitive {
+                    } else if self.case_sensitive
-                        if self.query.chars().any(|c| !symbol.name.contains(c)) {
+                        && self.query.chars().any(|c| !symbol.name.contains(c))
+                    {
                         continue;
                     }
-                    }
 
                     res.push(symbol.clone());
                     if res.len() >= self.limit {

crates/ide-diagnostics/src/handlers/json_is_not_rust.rs

@@ -99,8 +99,7 @@ pub(crate) fn json_in_items(
             && node.last_token().map(|x| x.kind()) == Some(SyntaxKind::R_CURLY)
         {
             let node_string = node.to_string();
-            if let Ok(it) = serde_json::from_str(&node_string) {
+            if let Ok(serde_json::Value::Object(it)) = serde_json::from_str(&node_string) {
-                if let serde_json::Value::Object(it) = it {
                 let import_scope = ImportScope::find_insert_use_container(node, sema)?;
                 let range = node.text_range();
                 let mut edit = TextEdit::builder();
@@ -139,11 +138,7 @@ pub(crate) fn json_in_items(
                                     config.insert_use.prefix_kind,
                                     config.prefer_no_std,
                                 ) {
-                                        insert_use(
+                                    insert_use(&scope, mod_path_to_ast(&it), &config.insert_use);
-                                            &scope,
-                                            mod_path_to_ast(&it),
-                                            &config.insert_use,
-                                        );
                                 }
                             }
                         }
@@ -155,11 +150,7 @@ pub(crate) fn json_in_items(
                                     config.insert_use.prefix_kind,
                                     config.prefer_no_std,
                                 ) {
-                                        insert_use(
+                                    insert_use(&scope, mod_path_to_ast(&it), &config.insert_use);
-                                            &scope,
-                                            mod_path_to_ast(&it),
-                                            &config.insert_use,
-                                        );
                                 }
                             }
                         }
@@ -170,7 +161,6 @@ pub(crate) fn json_in_items(
                 );
             }
         }
-        }
         Some(())
     })();
 }

crates/ide-diagnostics/src/handlers/private_assoc_item.rs

@@ -11,10 +11,7 @@ pub(crate) fn private_assoc_item(
     d: &hir::PrivateAssocItem,
 ) -> Diagnostic {
     // FIXME: add quickfix
-    let name = match d.item.name(ctx.sema.db) {
+    let name = d.item.name(ctx.sema.db).map(|name| format!("`{name}` ")).unwrap_or_default();
-        Some(name) => format!("`{}` ", name),
-        None => String::new(),
-    };
     Diagnostic::new(
         "private-assoc-item",
         format!(

crates/ide-diagnostics/src/handlers/unresolved_proc_macro.rs

@@ -34,10 +34,7 @@ pub(crate) fn unresolved_proc_macro(
     let message = format!(
         "{message}: {}",
         if config_enabled {
-            match def_map.proc_macro_loading_error() {
+            def_map.proc_macro_loading_error().unwrap_or("proc macro not found in the built dylib")
-                Some(e) => e,
-                None => "proc macro not found in the built dylib",
-            }
         } else {
             match d.kind {
                 hir::MacroKind::Attr if proc_macros_enabled => {

crates/ide/src/hover/render.rs

@@ -64,12 +64,10 @@ pub(super) fn type_info(
             bt_end = if config.markdown() { "```\n" } else { "" }
         )
         .into()
-    } else {
+    } else if config.markdown() {
-        if config.markdown() {
         Markup::fenced_block(&original.display(sema.db))
     } else {
         original.display(sema.db).to_string().into()
-        }
     };
     res.actions.push(HoverAction::goto_type_from_targets(sema.db, targets));
     Some(res)

crates/ide/src/join_lines.rs

@@ -161,11 +161,9 @@ fn remove_newline(
         }
     }
 
-    if config.join_assignments {
+    if config.join_assignments && join_assignments(edit, &prev, &next).is_some() {
-        if join_assignments(edit, &prev, &next).is_some() {
         return;
     }
-    }
 
     if config.unwrap_trivial_blocks {
         // Special case that turns something like:

crates/ide/src/syntax_highlighting.rs

@@ -413,12 +413,11 @@ fn traverse(
                 let string = ast::String::cast(token);
                 let string_to_highlight = ast::String::cast(descended_token.clone());
                 if let Some((string, expanded_string)) = string.zip(string_to_highlight) {
-                    if string.is_raw() {
+                    if string.is_raw()
-                        if inject::ra_fixture(hl, sema, config, &string, &expanded_string).is_some()
+                        && inject::ra_fixture(hl, sema, config, &string, &expanded_string).is_some()
                     {
                         continue;
                     }
-                    }
                     highlight_format_string(hl, &string, &expanded_string, range);
                     highlight_escape_string(hl, &string, range.start());
                 }

crates/ide/src/typing.rs

@@ -205,11 +205,9 @@ fn on_eq_typed(file: &SourceFile, offset: TextSize) -> Option<TextEdit> {
             if expr_stmt.semicolon_token().is_some() {
                 return None;
             }
-        } else {
+        } else if !ast::StmtList::can_cast(binop.syntax().parent()?.kind()) {
-            if !ast::StmtList::can_cast(binop.syntax().parent()?.kind()) {
             return None;
         }
-        }
 
         let expr = binop.rhs()?;
         let expr_range = expr.syntax().text_range();

crates/mbe/src/expander/transcriber.rs

@@ -212,7 +212,7 @@ fn expand_var(ctx: &mut ExpandCtx<'_>, v: &SmolStr, id: tt::TokenId) -> ExpandRe
     } else {
         ctx.bindings.get(v, &mut ctx.nesting).map_or_else(
             |e| ExpandResult { value: Fragment::Tokens(tt::TokenTree::empty()), err: Some(e) },
-            |it| ExpandResult::ok(it),
+            ExpandResult::ok,
         )
     }
 }

crates/project-model/src/workspace.rs

@@ -366,7 +366,7 @@ impl ProjectWorkspace {
                 _ => None,
             })
             .collect();
-        let ref mut outputs = match WorkspaceBuildScripts::run_once(config, &cargo_ws, progress) {
+        let outputs = &mut match WorkspaceBuildScripts::run_once(config, &cargo_ws, progress) {
             Ok(it) => Ok(it.into_iter()),
             // io::Error is not Clone?
             Err(e) => Err(Arc::new(e)),

crates/rust-analyzer/src/main_loop.rs

@@ -307,12 +307,12 @@ impl GlobalState {
                 }
             }
 
-            if !was_quiescent || state_changed || memdocs_added_or_removed {
+            if (!was_quiescent || state_changed || memdocs_added_or_removed)
-                if self.config.publish_diagnostics() {
+                && self.config.publish_diagnostics()
+            {
                 self.update_diagnostics()
             }
         }
-        }
 
         if let Some(diagnostic_changes) = self.diagnostics.take_changes() {
             for file_id in diagnostic_changes {