Auto merge of rust-lang#94477 - matthiaskrgr:rollup-8h29qek, r=matthiaskrgr

Rollup of 3 pull requests

Successful merges:

 - rust-lang#94359 (Fix inconsistent symbol mangling of integers constants with -Zverbose)
 - rust-lang#94465 (6 - Make more use of `let_chains`)
 - rust-lang#94470 (:arrow_up: rust-analyzer)

Failed merges:

r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_mir_build/src/build/expr/stmt.rs

@@ -116,22 +116,20 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 // it is usually better to focus on `the_value` rather
                 // than the entirety of block(s) surrounding it.
                 let adjusted_span = (|| {
-                    if let ExprKind::Block { body } = &expr.kind {
-                        if let Some(tail_expr) = body.expr {
-                            let mut expr = &this.thir[tail_expr];
-                            while let ExprKind::Block {
-                                body: Block { expr: Some(nested_expr), .. },
-                            }
-                            | ExprKind::Scope { value: nested_expr, .. } = expr.kind
-                            {
-                                expr = &this.thir[nested_expr];
-                            }
-                            this.block_context.push(BlockFrame::TailExpr {
-                                tail_result_is_ignored: true,
-                                span: expr.span,
-                            });
-                            return Some(expr.span);
+                    if let ExprKind::Block { body } = &expr.kind && let Some(tail_ex) = body.expr {
+                        let mut expr = &this.thir[tail_ex];
+                        while let ExprKind::Block {
+                            body: Block { expr: Some(nested_expr), .. },
                         }
+                        | ExprKind::Scope { value: nested_expr, .. } = expr.kind
+                        {
+                            expr = &this.thir[nested_expr];
+                        }
+                        this.block_context.push(BlockFrame::TailExpr {
+                            tail_result_is_ignored: true,
+                            span: expr.span,
+                        });
+                        return Some(expr.span);
                     }
                     None
                 })();

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -1597,13 +1597,11 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
 
         // Insert a Shallow borrow of any places that is switched on.
-        if let Some(fb) = fake_borrows {
-            if let Ok(match_place_resolved) =
-                match_place.clone().try_upvars_resolved(self.tcx, self.typeck_results)
-            {
-                let resolved_place = match_place_resolved.into_place(self.tcx, self.typeck_results);
-                fb.insert(resolved_place);
-            }
+        if let Some(fb) = fake_borrows && let Ok(match_place_resolved) =
+            match_place.clone().try_upvars_resolved(self.tcx, self.typeck_results)
+        {
+            let resolved_place = match_place_resolved.into_place(self.tcx, self.typeck_results);
+            fb.insert(resolved_place);
         }
 
         // perform the test, branching to one of N blocks. For each of

compiler/rustc_mir_build/src/build/mod.rs

@@ -877,14 +877,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             let arg_local = self.local_decls.push(LocalDecl::with_source_info(ty, source_info));
 
             // If this is a simple binding pattern, give debuginfo a nice name.
-            if let Some(arg) = arg_opt {
-                if let Some(ident) = arg.pat.simple_ident() {
-                    self.var_debug_info.push(VarDebugInfo {
-                        name: ident.name,
-                        source_info,
-                        value: VarDebugInfoContents::Place(arg_local.into()),
-                    });
-                }
+            if let Some(arg) = arg_opt && let Some(ident) = arg.pat.simple_ident() {
+                self.var_debug_info.push(VarDebugInfo {
+                    name: ident.name,
+                    source_info,
+                    value: VarDebugInfoContents::Place(arg_local.into()),
+                });
             }
         }
 

compiler/rustc_mir_build/src/check_unsafety.rs

@@ -416,23 +416,21 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
             }
             ExprKind::Field { lhs, .. } => {
                 let lhs = &self.thir[lhs];
-                if let ty::Adt(adt_def, _) = lhs.ty.kind() {
-                    if adt_def.is_union() {
-                        if let Some((assigned_ty, assignment_span)) = self.assignment_info {
-                            // To avoid semver hazard, we only consider `Copy` and `ManuallyDrop` non-dropping.
-                            if !(assigned_ty
-                                .ty_adt_def()
-                                .map_or(false, |adt| adt.is_manually_drop())
-                                || assigned_ty
-                                    .is_copy_modulo_regions(self.tcx.at(expr.span), self.param_env))
-                            {
-                                self.requires_unsafe(assignment_span, AssignToDroppingUnionField);
-                            } else {
-                                // write to non-drop union field, safe
-                            }
+                if let ty::Adt(adt_def, _) = lhs.ty.kind() && adt_def.is_union() {
+                    if let Some((assigned_ty, assignment_span)) = self.assignment_info {
+                        // To avoid semver hazard, we only consider `Copy` and `ManuallyDrop` non-dropping.
+                        if !(assigned_ty
+                            .ty_adt_def()
+                            .map_or(false, |adt| adt.is_manually_drop())
+                            || assigned_ty
+                                .is_copy_modulo_regions(self.tcx.at(expr.span), self.param_env))
+                        {
+                            self.requires_unsafe(assignment_span, AssignToDroppingUnionField);
                         } else {
-                            self.requires_unsafe(expr.span, AccessToUnionField);
+                            // write to non-drop union field, safe
                         }
+                    } else {
+                        self.requires_unsafe(expr.span, AccessToUnionField);
                     }
                 }
             }
@@ -476,10 +474,8 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
             }
             ExprKind::Let { expr: expr_id, .. } => {
                 let let_expr = &self.thir[expr_id];
-                if let ty::Adt(adt_def, _) = let_expr.ty.kind() {
-                    if adt_def.is_union() {
-                        self.requires_unsafe(expr.span, AccessToUnionField);
-                    }
+                if let ty::Adt(adt_def, _) = let_expr.ty.kind() && adt_def.is_union() {
+                    self.requires_unsafe(expr.span, AccessToUnionField);
                 }
             }
             _ => {}

compiler/rustc_mir_build/src/lib.rs

@@ -1,15 +1,16 @@
 //! Construction of MIR from HIR.
 //!
 //! This crate also contains the match exhaustiveness and usefulness checking.
+#![allow(rustc::potential_query_instability)]
+#![feature(bool_to_option)]
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
 #![feature(crate_visibility_modifier)]
-#![feature(bool_to_option)]
+#![feature(let_chains)]
 #![feature(let_else)]
-#![feature(once_cell)]
 #![feature(min_specialization)]
+#![feature(once_cell)]
 #![recursion_limit = "256"]
-#![allow(rustc::potential_query_instability)]
 
 #[macro_use]
 extern crate tracing;

compiler/rustc_mir_build/src/thir/pattern/check_match.rs

@@ -315,47 +315,43 @@ fn check_for_bindings_named_same_as_variants(
     rf: RefutableFlag,
 ) {
     pat.walk_always(|p| {
-        if let hir::PatKind::Binding(_, _, ident, None) = p.kind {
-            if let Some(ty::BindByValue(hir::Mutability::Not)) =
+        if let hir::PatKind::Binding(_, _, ident, None) = p.kind
+            && let Some(ty::BindByValue(hir::Mutability::Not)) =
                 cx.typeck_results.extract_binding_mode(cx.tcx.sess, p.hir_id, p.span)
-            {
-                let pat_ty = cx.typeck_results.pat_ty(p).peel_refs();
-                if let ty::Adt(edef, _) = pat_ty.kind() {
-                    if edef.is_enum()
-                        && edef.variants.iter().any(|variant| {
-                            variant.ident(cx.tcx) == ident && variant.ctor_kind == CtorKind::Const
-                        })
-                    {
-                        let variant_count = edef.variants.len();
-                        cx.tcx.struct_span_lint_hir(
-                            BINDINGS_WITH_VARIANT_NAME,
-                            p.hir_id,
+            && let pat_ty = cx.typeck_results.pat_ty(p).peel_refs()
+            && let ty::Adt(edef, _) = pat_ty.kind()
+            && edef.is_enum()
+            && edef.variants.iter().any(|variant| {
+                variant.ident(cx.tcx) == ident && variant.ctor_kind == CtorKind::Const
+            })
+        {
+            let variant_count = edef.variants.len();
+            cx.tcx.struct_span_lint_hir(
+                BINDINGS_WITH_VARIANT_NAME,
+                p.hir_id,
+                p.span,
+                |lint| {
+                    let ty_path = cx.tcx.def_path_str(edef.did);
+                    let mut err = lint.build(&format!(
+                        "pattern binding `{}` is named the same as one \
+                                        of the variants of the type `{}`",
+                        ident, ty_path
+                    ));
+                    err.code(error_code!(E0170));
+                    // If this is an irrefutable pattern, and there's > 1 variant,
+                    // then we can't actually match on this. Applying the below
+                    // suggestion would produce code that breaks on `check_irrefutable`.
+                    if rf == Refutable || variant_count == 1 {
+                        err.span_suggestion(
                             p.span,
-                            |lint| {
-                                let ty_path = cx.tcx.def_path_str(edef.did);
-                                let mut err = lint.build(&format!(
-                                    "pattern binding `{}` is named the same as one \
-                                                    of the variants of the type `{}`",
-                                    ident, ty_path
-                                ));
-                                err.code(error_code!(E0170));
-                                // If this is an irrefutable pattern, and there's > 1 variant,
-                                // then we can't actually match on this. Applying the below
-                                // suggestion would produce code that breaks on `check_irrefutable`.
-                                if rf == Refutable || variant_count == 1 {
-                                    err.span_suggestion(
-                                        p.span,
-                                        "to match on the variant, qualify the path",
-                                        format!("{}::{}", ty_path, ident),
-                                        Applicability::MachineApplicable,
-                                    );
-                                }
-                                err.emit();
-                            },
-                        )
+                            "to match on the variant, qualify the path",
+                            format!("{}::{}", ty_path, ident),
+                            Applicability::MachineApplicable,
+                        );
                     }
-                }
-            }
+                    err.emit();
+                },
+            )
         }
     });
 }
@@ -622,10 +618,8 @@ fn maybe_point_at_variant<'a, 'p: 'a, 'tcx: 'a>(
     let mut covered = vec![];
     for pattern in patterns {
         if let Variant(variant_index) = pattern.ctor() {
-            if let ty::Adt(this_def, _) = pattern.ty().kind() {
-                if this_def.did != def.did {
-                    continue;
-                }
+            if let ty::Adt(this_def, _) = pattern.ty().kind() && this_def.did != def.did {
+                continue;
             }
             let sp = def.variants[*variant_index].ident(cx.tcx).span;
             if covered.contains(&sp) {

compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs

@@ -680,27 +680,23 @@ impl<'tcx> Constructor<'tcx> {
     ///
     /// This means that the variant has a stdlib unstable feature marking it.
     pub(super) fn is_unstable_variant(&self, pcx: PatCtxt<'_, '_, 'tcx>) -> bool {
-        if let Constructor::Variant(idx) = self {
-            if let ty::Adt(adt, _) = pcx.ty.kind() {
-                let variant_def_id = adt.variants[*idx].def_id;
-                // Filter variants that depend on a disabled unstable feature.
-                return matches!(
-                    pcx.cx.tcx.eval_stability(variant_def_id, None, DUMMY_SP, None),
-                    EvalResult::Deny { .. }
-                );
-            }
+        if let Constructor::Variant(idx) = self && let ty::Adt(adt, _) = pcx.ty.kind() {
+            let variant_def_id = adt.variants[*idx].def_id;
+            // Filter variants that depend on a disabled unstable feature.
+            return matches!(
+                pcx.cx.tcx.eval_stability(variant_def_id, None, DUMMY_SP, None),
+                EvalResult::Deny { .. }
+            );
         }
         false
     }
 
     /// Checks if the `Constructor` is a `Constructor::Variant` with a `#[doc(hidden)]`
     /// attribute.
     pub(super) fn is_doc_hidden_variant(&self, pcx: PatCtxt<'_, '_, 'tcx>) -> bool {
-        if let Constructor::Variant(idx) = self {
-            if let ty::Adt(adt, _) = pcx.ty.kind() {
-                let variant_def_id = adt.variants[*idx].def_id;
-                return pcx.cx.tcx.is_doc_hidden(variant_def_id);
-            }
+        if let Constructor::Variant(idx) = self && let ty::Adt(adt, _) = pcx.ty.kind() {
+            let variant_def_id = adt.variants[*idx].def_id;
+            return pcx.cx.tcx.is_doc_hidden(variant_def_id);
         }
         false
     }

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -790,16 +790,14 @@ crate fn compare_const_vals<'tcx>(
         };
     }
 
-    if let ty::Str = ty.kind() {
-        if let (
-            ty::ConstKind::Value(a_val @ ConstValue::Slice { .. }),
-            ty::ConstKind::Value(b_val @ ConstValue::Slice { .. }),
-        ) = (a.val(), b.val())
-        {
-            let a_bytes = get_slice_bytes(&tcx, a_val);
-            let b_bytes = get_slice_bytes(&tcx, b_val);
-            return from_bool(a_bytes == b_bytes);
-        }
+    if let ty::Str = ty.kind() && let (
+        ty::ConstKind::Value(a_val @ ConstValue::Slice { .. }),
+        ty::ConstKind::Value(b_val @ ConstValue::Slice { .. }),
+    ) = (a.val(), b.val())
+    {
+        let a_bytes = get_slice_bytes(&tcx, a_val);
+        let b_bytes = get_slice_bytes(&tcx, b_val);
+        return from_bool(a_bytes == b_bytes);
     }
     fallback()
 }

compiler/rustc_symbol_mangling/src/legacy.rs

@@ -216,14 +216,32 @@ impl<'tcx> Printer<'tcx> for &mut SymbolPrinter<'tcx> {
         Ok(self)
     }
 
-    fn print_type(self, ty: Ty<'tcx>) -> Result<Self::Type, Self::Error> {
+    fn print_type(mut self, ty: Ty<'tcx>) -> Result<Self::Type, Self::Error> {
         match *ty.kind() {
             // Print all nominal types as paths (unlike `pretty_print_type`).
             ty::FnDef(def_id, substs)
             | ty::Opaque(def_id, substs)
             | ty::Projection(ty::ProjectionTy { item_def_id: def_id, substs })
             | ty::Closure(def_id, substs)
             | ty::Generator(def_id, substs, _) => self.print_def_path(def_id, substs),
+
+            // The `pretty_print_type` formatting of array size depends on
+            // -Zverbose flag, so we cannot reuse it here.
+            ty::Array(ty, size) => {
+                self.write_str("[")?;
+                self = self.print_type(ty)?;
+                self.write_str("; ")?;
+                if let Some(size) = size.val().try_to_bits(self.tcx().data_layout.pointer_size) {
+                    write!(self, "{}", size)?
+                } else if let ty::ConstKind::Param(param) = size.val() {
+                    self = param.print(self)?
+                } else {
+                    self.write_str("_")?
+                }
+                self.write_str("]")?;
+                Ok(self)
+            }
+
             _ => self.pretty_print_type(ty),
         }
     }
@@ -245,12 +263,22 @@ impl<'tcx> Printer<'tcx> for &mut SymbolPrinter<'tcx> {
 
     fn print_const(self, ct: ty::Const<'tcx>) -> Result<Self::Const, Self::Error> {
         // only print integers
-        if let ty::ConstKind::Value(ConstValue::Scalar(Scalar::Int { .. })) = ct.val() {
-            if ct.ty().is_integral() {
-                return self.pretty_print_const(ct, true);
+        match (ct.val(), ct.ty().kind()) {
+            (
+                ty::ConstKind::Value(ConstValue::Scalar(Scalar::Int(scalar))),
+                ty::Int(_) | ty::Uint(_),
+            ) => {
+                // The `pretty_print_const` formatting depends on -Zverbose
+                // flag, so we cannot reuse it here.
+                let signed = matches!(ct.ty().kind(), ty::Int(_));
+                write!(
+                    self,
+                    "{:#?}",
+                    ty::ConstInt::new(scalar, signed, ct.ty().is_ptr_sized_integral())
+                )?;
             }
+            _ => self.write_str("_")?,
         }
-        self.write_str("_")?;
         Ok(self)
     }