Auto merge of #15206 - Veykril:let-else-fmt, r=Veykril

internal: Format let-else

As nightly finally got support for it I went ahead and formatted r-a with the latest nightly, then with the latest stable (in case other stuff changed)

crates/hir-def/src/attr.rs

@@ -137,13 +137,16 @@ impl Attrs {
 
                 let cfg_options = &crate_graph[krate].cfg_options;
 
-                let Some(variant) = enum_.variants.clone().filter(|variant| {
-                    let attrs = item_tree.attrs(db, krate, (*variant).into());
-                    attrs.is_cfg_enabled(cfg_options)
-                })
-                .zip(0u32..)
-                .find(|(_variant, idx)| it.local_id == Idx::from_raw(RawIdx::from(*idx)))
-                .map(|(variant, _idx)| variant)
+                let Some(variant) = enum_
+                    .variants
+                    .clone()
+                    .filter(|variant| {
+                        let attrs = item_tree.attrs(db, krate, (*variant).into());
+                        attrs.is_cfg_enabled(cfg_options)
+                    })
+                    .zip(0u32..)
+                    .find(|(_variant, idx)| it.local_id == Idx::from_raw(RawIdx::from(*idx)))
+                    .map(|(variant, _idx)| variant)
                 else {
                     return Arc::new(res);
                 };

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

@@ -1451,9 +1451,7 @@ impl ExprCollector<'_> {
         &self,
         lifetime: Option<ast::Lifetime>,
     ) -> Result<Option<LabelId>, BodyDiagnostic> {
-        let Some(lifetime) = lifetime else {
-            return Ok(None)
-        };
+        let Some(lifetime) = lifetime else { return Ok(None) };
         let name = Name::new_lifetime(&lifetime);
 
         for (rib_idx, rib) in self.label_ribs.iter().enumerate().rev() {

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

@@ -2235,8 +2235,12 @@ impl ModCollector<'_, '_> {
     }
 
     fn import_all_legacy_macros(&mut self, module_id: LocalModuleId) {
-        let Some((source, target)) = Self::borrow_modules(self.def_collector.def_map.modules.as_mut(), module_id, self.module_id) else {
-            return
+        let Some((source, target)) = Self::borrow_modules(
+            self.def_collector.def_map.modules.as_mut(),
+            module_id,
+            self.module_id,
+        ) else {
+            return;
         };
 
         for (name, macs) in source.scope.legacy_macros() {

crates/hir-def/src/path.rs

@@ -135,10 +135,7 @@ impl Path {
 
     pub fn segments(&self) -> PathSegments<'_> {
         let Path::Normal { mod_path, generic_args, .. } = self else {
-            return PathSegments {
-                segments: &[],
-                generic_args: None,
-            };
+            return PathSegments { segments: &[], generic_args: None };
         };
         let s =
             PathSegments { segments: mod_path.segments(), generic_args: generic_args.as_deref() };

crates/hir-def/src/path/lower.rs

@@ -74,8 +74,8 @@ pub(super) fn lower_path(mut path: ast::Path, ctx: &LowerCtx<'_>) -> Option<Path
                     // <T as Trait<A>>::Foo desugars to Trait<Self=T, A>::Foo
                     Some(trait_ref) => {
                         let Path::Normal { mod_path, generic_args: path_generic_args, .. } =
-                            Path::from_src(trait_ref.path()?, ctx)? else
-                        {
+                            Path::from_src(trait_ref.path()?, ctx)?
+                        else {
                             return None;
                         };
                         let num_segments = mod_path.segments().len();

crates/hir-expand/src/builtin_fn_macro.rs

@@ -692,7 +692,7 @@ pub(crate) fn include_arg_to_tt(
     arg_id: MacroCallId,
 ) -> Result<(triomphe::Arc<(::tt::Subtree<::tt::TokenId>, TokenMap)>, FileId), ExpandError> {
     let loc = db.lookup_intern_macro_call(arg_id);
-    let Some(EagerCallInfo {arg, arg_id: Some(arg_id), .. }) = loc.eager.as_deref() else {
+    let Some(EagerCallInfo { arg, arg_id: Some(arg_id), .. }) = loc.eager.as_deref() else {
         panic!("include_arg_to_tt called on non include macro call: {:?}", &loc.eager);
     };
     let path = parse_string(&arg.0)?;

crates/hir-expand/src/db.rs

@@ -471,17 +471,13 @@ fn macro_expand(db: &dyn ExpandDatabase, id: MacroCallId) -> ExpandResult<Arc<tt
     };
     let Some(macro_arg) = db.macro_arg(id) else {
         return ExpandResult {
-            value: Arc::new(
-                tt::Subtree {
-                    delimiter: tt::Delimiter::UNSPECIFIED,
-                    token_trees: Vec::new(),
-                },
-            ),
+            value: Arc::new(tt::Subtree {
+                delimiter: tt::Delimiter::UNSPECIFIED,
+                token_trees: Vec::new(),
+            }),
             // FIXME: We should make sure to enforce an invariant that invalid macro
             // calls do not reach this call path!
-            err: Some(ExpandError::other(
-                "invalid token tree"
-            )),
+            err: Some(ExpandError::other("invalid token tree")),
         };
     };
     let (arg_tt, arg_tm, undo_info) = &*macro_arg;
@@ -510,9 +506,7 @@ fn expand_proc_macro(db: &dyn ExpandDatabase, id: MacroCallId) -> ExpandResult<A
                 delimiter: tt::Delimiter::UNSPECIFIED,
                 token_trees: Vec::new(),
             }),
-            err: Some(ExpandError::other(
-                "invalid token tree"
-            )),
+            err: Some(ExpandError::other("invalid token tree")),
         };
     };
     let (arg_tt, arg_tm, undo_info) = &*macro_arg;

crates/hir-expand/src/eager.rs

@@ -42,10 +42,9 @@ pub fn expand_eager_macro_input(
     let token_tree = macro_call.value.token_tree();
 
     let Some(token_tree) = token_tree else {
-        return Ok(ExpandResult { value: None, err:
-            Some(ExpandError::other(
-                "invalid token tree"
-            )),
+        return Ok(ExpandResult {
+            value: None,
+            err: Some(ExpandError::other("invalid token tree")),
         });
     };
     let (parsed_args, arg_token_map) = mbe::syntax_node_to_token_tree(token_tree.syntax());
@@ -85,7 +84,7 @@ pub fn expand_eager_macro_input(
         resolver,
     )?;
     let Some(expanded_eager_input) = expanded_eager_input else {
-        return Ok(ExpandResult { value: None, err })
+        return Ok(ExpandResult { value: None, err });
     };
     let (mut subtree, token_map) = mbe::syntax_node_to_token_tree(&expanded_eager_input);
     subtree.delimiter = crate::tt::Delimiter::unspecified();

crates/hir-ty/src/chalk_ext.rs

@@ -343,7 +343,8 @@ impl TyExt for Ty {
 
     fn is_copy(self, db: &dyn HirDatabase, owner: DefWithBodyId) -> bool {
         let crate_id = owner.module(db.upcast()).krate();
-        let Some(copy_trait) = db.lang_item(crate_id, LangItem::Copy).and_then(|x| x.as_trait()) else {
+        let Some(copy_trait) = db.lang_item(crate_id, LangItem::Copy).and_then(|x| x.as_trait())
+        else {
             return false;
         };
         let trait_ref = TyBuilder::trait_ref(db, copy_trait).push(self).build();

crates/hir-ty/src/display.rs

@@ -636,7 +636,8 @@ fn render_const_scalar(
                 }
                 hir_def::AdtId::EnumId(e) => {
                     let Some((var_id, var_layout)) =
-                            detect_variant_from_bytes(&layout, f.db, krate, b, e) else {
+                        detect_variant_from_bytes(&layout, f.db, krate, b, e)
+                    else {
                         return f.write_str("<failed-to-detect-variant>");
                     };
                     let data = &f.db.enum_data(e).variants[var_id];

crates/hir-ty/src/infer.rs

@@ -1232,7 +1232,9 @@ impl<'a> InferenceContext<'a> {
             .as_function()?
             .lookup(self.db.upcast())
             .container
-        else { return None };
+        else {
+            return None;
+        };
         self.resolve_output_on(trait_)
     }
 

crates/hir-ty/src/layout.rs

@@ -154,7 +154,9 @@ pub fn layout_of_ty_query(
     ty: Ty,
     krate: CrateId,
 ) -> Result<Arc<Layout>, LayoutError> {
-    let Some(target) = db.target_data_layout(krate) else { return Err(LayoutError::TargetLayoutNotAvailable) };
+    let Some(target) = db.target_data_layout(krate) else {
+        return Err(LayoutError::TargetLayoutNotAvailable);
+    };
     let cx = LayoutCx { krate, target: &target };
     let dl = &*cx.current_data_layout();
     let trait_env = Arc::new(TraitEnvironment::empty(krate));

crates/hir-ty/src/layout/adt.rs

@@ -31,7 +31,9 @@ pub fn layout_of_adt_query(
     subst: Substitution,
     krate: CrateId,
 ) -> Result<Arc<Layout>, LayoutError> {
-    let Some(target) = db.target_data_layout(krate) else { return Err(LayoutError::TargetLayoutNotAvailable) };
+    let Some(target) = db.target_data_layout(krate) else {
+        return Err(LayoutError::TargetLayoutNotAvailable);
+    };
     let cx = LayoutCx { krate, target: &target };
     let dl = cx.current_data_layout();
     let handle_variant = |def: VariantId, var: &VariantData| {

crates/hir-ty/src/method_resolution.rs

@@ -689,7 +689,7 @@ pub fn lookup_impl_method(
     fn_subst: Substitution,
 ) -> (FunctionId, Substitution) {
     let ItemContainerId::TraitId(trait_id) = func.lookup(db.upcast()).container else {
-        return (func, fn_subst)
+        return (func, fn_subst);
     };
     let trait_params = db.generic_params(trait_id.into()).type_or_consts.len();
     let fn_params = fn_subst.len(Interner) - trait_params;
@@ -699,8 +699,8 @@ pub fn lookup_impl_method(
     };
 
     let name = &db.function_data(func).name;
-    let Some((impl_fn, impl_subst)) = lookup_impl_assoc_item_for_trait_ref(trait_ref, db, env, name)
-        .and_then(|assoc| {
+    let Some((impl_fn, impl_subst)) =
+        lookup_impl_assoc_item_for_trait_ref(trait_ref, db, env, name).and_then(|assoc| {
             if let (AssocItemId::FunctionId(id), subst) = assoc {
                 Some((id, subst))
             } else {

crates/hir-ty/src/mir/borrowck.rs

@@ -271,7 +271,10 @@ fn ever_initialized_map(
             }
         }
         let Some(terminator) = &block.terminator else {
-            never!("Terminator should be none only in construction.\nThe body:\n{}", body.pretty_print(db));
+            never!(
+                "Terminator should be none only in construction.\nThe body:\n{}",
+                body.pretty_print(db)
+            );
             return;
         };
         let targets = match &terminator.kind {

crates/hir-ty/src/mir/eval.rs

@@ -1226,8 +1226,8 @@ impl Evaluator<'_> {
             }
             Variants::Multiple { tag, tag_encoding, variants, .. } => {
                 let Some(target_data_layout) = self.db.target_data_layout(self.crate_id) else {
-                            not_supported!("missing target data layout");
-                        };
+                    not_supported!("missing target data layout");
+                };
                 let size = tag.size(&*target_data_layout).bytes_usize();
                 let offset = layout.fields.offset(0).bytes_usize(); // The only field on enum variants is the tag field
                 match tag_encoding {
@@ -1344,7 +1344,9 @@ impl Evaluator<'_> {
                         AdtId::UnionId(_) => not_supported!("unsizing unions"),
                         AdtId::EnumId(_) => not_supported!("unsizing enums"),
                     };
-                    let Some((last_field, _)) = self.db.struct_data(id).variant_data.fields().iter().rev().next() else {
+                    let Some((last_field, _)) =
+                        self.db.struct_data(id).variant_data.fields().iter().rev().next()
+                    else {
                         not_supported!("unsizing struct without field");
                     };
                     let target_last_field = self.db.field_types(id.into())[last_field]