Rollup of 10 pull requests

compiler/rustc_ast_lowering/src/item.rs

@@ -26,7 +26,7 @@ pub(super) struct ItemLowerer<'a, 'lowering, 'hir> {
 }
 
 /// When we have a ty alias we *may* have two where clauses. To give the best diagnostics, we set the span
-/// to the where clause that is prefered, if it exists. Otherwise, it sets the span to the other where
+/// to the where clause that is preferred, if it exists. Otherwise, it sets the span to the other where
 /// clause if it exists.
 fn add_ty_alias_where_clause(
     generics: &mut ast::Generics,

compiler/rustc_ast_lowering/src/lib.rs

@@ -952,7 +952,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                                 sess.diagnostic().delay_span_bug(
                                     span,
                                     "unexpected delimiter in key-value attribute's value",
-                                )
+                                );
                             }
                             unwrap_single_token(sess, tokens, span)
                         }

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -440,7 +440,7 @@ impl<'a> AstValidator<'a> {
                         attr.span,
                         "allow, cfg, cfg_attr, deny, \
                 forbid, and warn are the only allowed built-in attributes in function parameters",
-                    )
+                    );
                 }
             });
     }

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -252,11 +252,12 @@ impl<'a> PostExpansionVisitor<'a> {
                     "wasm ABI is experimental and subject to change"
                 );
             }
-            abi => self
-                .sess
-                .parse_sess
-                .span_diagnostic
-                .delay_span_bug(span, &format!("unrecognized ABI not caught in lowering: {}", abi)),
+            abi => {
+                self.sess.parse_sess.span_diagnostic.delay_span_bug(
+                    span,
+                    &format!("unrecognized ABI not caught in lowering: {}", abi),
+                );
+            }
         }
     }
 

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -12,9 +12,7 @@ use rustc_middle::mir::{
     FakeReadCause, LocalDecl, LocalInfo, LocalKind, Location, Operand, Place, PlaceRef,
     ProjectionElem, Rvalue, Statement, StatementKind, Terminator, TerminatorKind, VarBindingForm,
 };
-use rustc_middle::ty::{
-    self, suggest_constraining_type_param, suggest_constraining_type_params, PredicateKind, Ty,
-};
+use rustc_middle::ty::{self, suggest_constraining_type_params, PredicateKind, Ty};
 use rustc_mir_dataflow::move_paths::{InitKind, MoveOutIndex, MovePathIndex};
 use rustc_span::symbol::sym;
 use rustc_span::{BytePos, MultiSpan, Span};
@@ -285,86 +283,63 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                     Some(ref name) => format!("`{}`", name),
                     None => "value".to_owned(),
                 };
-                if let ty::Param(param_ty) = ty.kind() {
-                    let tcx = self.infcx.tcx;
-                    let generics = tcx.generics_of(self.mir_def_id());
-                    let param = generics.type_param(&param_ty, tcx);
-                    if let Some(generics) = tcx
-                        .typeck_root_def_id(self.mir_def_id().to_def_id())
-                        .as_local()
-                        .and_then(|def_id| tcx.hir().get_generics(def_id))
-                    {
-                        suggest_constraining_type_param(
-                            tcx,
-                            generics,
-                            &mut err,
-                            param.name.as_str(),
-                            "Copy",
-                            None,
+
+                // Try to find predicates on *generic params* that would allow copying `ty`
+                let tcx = self.infcx.tcx;
+                let generics = tcx.generics_of(self.mir_def_id());
+                if let Some(hir_generics) = tcx
+                    .typeck_root_def_id(self.mir_def_id().to_def_id())
+                    .as_local()
+                    .and_then(|def_id| tcx.hir().get_generics(def_id))
+                {
+                    let predicates: Result<Vec<_>, _> = tcx.infer_ctxt().enter(|infcx| {
+                        let mut fulfill_cx =
+                            <dyn rustc_infer::traits::TraitEngine<'_>>::new(infcx.tcx);
+
+                        let copy_did = infcx.tcx.lang_items().copy_trait().unwrap();
+                        let cause = ObligationCause::new(
+                            span,
+                            self.mir_hir_id(),
+                            rustc_infer::traits::ObligationCauseCode::MiscObligation,
                         );
-                    }
-                } else {
-                    // Try to find predicates on *generic params* that would allow copying `ty`
-
-                    let tcx = self.infcx.tcx;
-                    let generics = tcx.generics_of(self.mir_def_id());
-                    if let Some(hir_generics) = tcx
-                        .typeck_root_def_id(self.mir_def_id().to_def_id())
-                        .as_local()
-                        .and_then(|def_id| tcx.hir().get_generics(def_id))
-                    {
-                        let predicates: Result<Vec<_>, _> = tcx.infer_ctxt().enter(|infcx| {
-                            let mut fulfill_cx =
-                                <dyn rustc_infer::traits::TraitEngine<'_>>::new(infcx.tcx);
-
-                            let copy_did = infcx.tcx.lang_items().copy_trait().unwrap();
-                            let cause = ObligationCause::new(
-                                span,
-                                self.mir_hir_id(),
-                                rustc_infer::traits::ObligationCauseCode::MiscObligation,
-                            );
-                            fulfill_cx.register_bound(
-                                &infcx,
-                                self.param_env,
-                                // Erase any region vids from the type, which may not be resolved
-                                infcx.tcx.erase_regions(ty),
-                                copy_did,
-                                cause,
-                            );
-                            // Select all, including ambiguous predicates
-                            let errors = fulfill_cx.select_all_or_error(&infcx);
-
-                            // Only emit suggestion if all required predicates are on generic
-                            errors
-                                .into_iter()
-                                .map(|err| match err.obligation.predicate.kind().skip_binder() {
-                                    PredicateKind::Trait(predicate) => {
-                                        match predicate.self_ty().kind() {
-                                            ty::Param(param_ty) => Ok((
-                                                generics.type_param(param_ty, tcx),
-                                                predicate
-                                                    .trait_ref
-                                                    .print_only_trait_path()
-                                                    .to_string(),
-                                            )),
-                                            _ => Err(()),
-                                        }
+                        fulfill_cx.register_bound(
+                            &infcx,
+                            self.param_env,
+                            // Erase any region vids from the type, which may not be resolved
+                            infcx.tcx.erase_regions(ty),
+                            copy_did,
+                            cause,
+                        );
+                        // Select all, including ambiguous predicates
+                        let errors = fulfill_cx.select_all_or_error(&infcx);
+
+                        // Only emit suggestion if all required predicates are on generic
+                        errors
+                            .into_iter()
+                            .map(|err| match err.obligation.predicate.kind().skip_binder() {
+                                PredicateKind::Trait(predicate) => {
+                                    match predicate.self_ty().kind() {
+                                        ty::Param(param_ty) => Ok((
+                                            generics.type_param(param_ty, tcx),
+                                            predicate.trait_ref.print_only_trait_path().to_string(),
+                                        )),
+                                        _ => Err(()),
                                     }
-                                    _ => Err(()),
-                                })
-                                .collect()
-                        });
+                                }
+                                _ => Err(()),
+                            })
+                            .collect()
+                    });
 
-                        if let Ok(predicates) = predicates {
-                            suggest_constraining_type_params(
-                                tcx,
-                                hir_generics,
-                                &mut err,
-                                predicates.iter().map(|(param, constraint)| {
-                                    (param.name.as_str(), &**constraint, None)
-                                }),
-                            );
-                        }
+                    if let Ok(predicates) = predicates {
+                        suggest_constraining_type_params(
+                            tcx,
+                            hir_generics,
+                            &mut err,
+                            predicates.iter().map(|(param, constraint)| {
+                                (param.name.as_str(), &**constraint, None)
+                            }),
+                        );
                     }
                 }
 

compiler/rustc_borrowck/src/lib.rs

@@ -178,7 +178,7 @@ fn do_mir_borrowck<'a, 'tcx>(
 
     // Gather the upvars of a closure, if any.
     let tables = tcx.typeck_opt_const_arg(def);
-    if let Some(ErrorGuaranteed) = tables.tainted_by_errors {
+    if let Some(ErrorGuaranteed { .. }) = tables.tainted_by_errors {
         infcx.set_tainted_by_errors();
         errors.set_tainted_by_errors();
     }
@@ -2274,6 +2274,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
 }
 
 mod error {
+    use rustc_errors::ErrorGuaranteed;
+
     use super::*;
 
     pub struct BorrowckErrors<'tcx> {
@@ -2311,7 +2313,7 @@ mod error {
         // FIXME(eddyb) this is a suboptimal API because `tainted_by_errors` is
         // set before any emission actually happens (weakening the guarantee).
         pub fn buffer_error(&mut self, t: DiagnosticBuilder<'_, ErrorGuaranteed>) {
-            self.tainted_by_errors = Some(ErrorGuaranteed {});
+            self.tainted_by_errors = Some(ErrorGuaranteed::unchecked_claim_error_was_emitted());
             t.buffer(&mut self.buffered);
         }
 
@@ -2320,7 +2322,7 @@ mod error {
         }
 
         pub fn set_tainted_by_errors(&mut self) {
-            self.tainted_by_errors = Some(ErrorGuaranteed {});
+            self.tainted_by_errors = Some(ErrorGuaranteed::unchecked_claim_error_was_emitted());
         }
     }
 

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -1,7 +1,6 @@
 //! Handling of `static`s, `const`s and promoted allocations
 
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_errors::ErrorGuaranteed;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
 use rustc_middle::mir::interpret::{
     read_target_uint, AllocId, ConstAllocation, ConstValue, ErrorHandled, GlobalAlloc, Scalar,
@@ -54,7 +53,7 @@ pub(crate) fn check_constants(fx: &mut FunctionCx<'_, '_, '_>) -> bool {
                 {
                     all_constants_ok = false;
                     match err {
-                        ErrorHandled::Reported(ErrorGuaranteed) | ErrorHandled::Linted => {
+                        ErrorHandled::Reported(_) | ErrorHandled::Linted => {
                             fx.tcx.sess.span_err(constant.span, "erroneous constant encountered");
                         }
                         ErrorHandled::TooGeneric => {

compiler/rustc_codegen_ssa/src/debuginfo/type_names.rs

@@ -74,9 +74,30 @@ fn push_debuginfo_type_name<'tcx>(
         ty::Float(float_ty) => output.push_str(float_ty.name_str()),
         ty::Foreign(def_id) => push_item_name(tcx, def_id, qualified, output),
         ty::Adt(def, substs) => {
-            let ty_and_layout = tcx.layout_of(ParamEnv::reveal_all().and(t)).expect("layout error");
+            // `layout_for_cpp_like_fallback` will be `Some` if we want to use the fallback encoding.
+            let layout_for_cpp_like_fallback = if cpp_like_debuginfo && def.is_enum() {
+                match tcx.layout_of(ParamEnv::reveal_all().and(t)) {
+                    Ok(layout) => {
+                        if !wants_c_like_enum_debuginfo(layout) {
+                            Some(layout)
+                        } else {
+                            // This is a C-like enum so we don't want to use the fallback encoding
+                            // for the name.
+                            None
+                        }
+                    }
+                    Err(e) => {
+                        // Computing the layout can still fail here, e.g. if the target architecture
+                        // cannot represent the type. See https://github.com/rust-lang/rust/issues/94961.
+                        tcx.sess.fatal(&format!("{}", e));
+                    }
+                }
+            } else {
+                // We are not emitting cpp-like debuginfo or this isn't even an enum.
+                None
+            };
 
-            if def.is_enum() && cpp_like_debuginfo && !wants_c_like_enum_debuginfo(ty_and_layout) {
+            if let Some(ty_and_layout) = layout_for_cpp_like_fallback {
                 msvc_enum_fallback(
                     tcx,
                     ty_and_layout,

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -1,5 +1,4 @@
 use crate::traits::*;
-use rustc_errors::ErrorGuaranteed;
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::ErrorHandled;
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, TyAndLayout};
@@ -191,7 +190,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
             all_consts_ok = false;
             match err {
                 // errored or at least linted
-                ErrorHandled::Reported(ErrorGuaranteed) | ErrorHandled::Linted => {}
+                ErrorHandled::Reported(_) | ErrorHandled::Linted => {}
                 ErrorHandled::TooGeneric => {
                     span_bug!(const_.span, "codgen encountered polymorphic constant: {:?}", err)
                 }

compiler/rustc_codegen_ssa/src/target_features.rs

@@ -148,7 +148,7 @@ const AARCH64_TIED_FEATURES: &[&[&str]] = &[
 ];
 
 const X86_ALLOWED_FEATURES: &[(&str, Option<Symbol>)] = &[
-    ("adx", Some(sym::adx_target_feature)),
+    ("adx", None),
     ("aes", None),
     ("avx", None),
     ("avx2", None),

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -1,4 +1,3 @@
-use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::DefKind;
 use rustc_middle::mir;
 use rustc_middle::ty::{self, Ty};
@@ -247,11 +246,11 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
                 if ecx.tcx.is_ctfe_mir_available(def.did) {
                     Ok(ecx.tcx.mir_for_ctfe_opt_const_arg(def))
                 } else if ecx.tcx.def_kind(def.did) == DefKind::AssocConst {
-                    ecx.tcx.sess.delay_span_bug(
+                    let guar = ecx.tcx.sess.delay_span_bug(
                         rustc_span::DUMMY_SP,
                         "This is likely a const item that is missing from its impl",
                     );
-                    throw_inval!(AlreadyReported(ErrorGuaranteed {}));
+                    throw_inval!(AlreadyReported(guar));
                 } else {
                     let path = ecx.tcx.def_path_str(def.did);
                     Err(ConstEvalErrKind::NeedsRfc(format!("calling extern function `{}`", path))

compiler/rustc_const_eval/src/interpret/intern.rs

@@ -406,8 +406,11 @@ pub fn intern_const_alloc_recursive<
         } else if ecx.memory.dead_alloc_map.contains_key(&alloc_id) {
             // Codegen does not like dangling pointers, and generally `tcx` assumes that
             // all allocations referenced anywhere actually exist. So, make sure we error here.
-            ecx.tcx.sess.span_err(ecx.tcx.span, "encountered dangling pointer in final constant");
-            return Err(ErrorGuaranteed);
+            let reported = ecx
+                .tcx
+                .sess
+                .span_err(ecx.tcx.span, "encountered dangling pointer in final constant");
+            return Err(reported);
         } else if ecx.tcx.get_global_alloc(alloc_id).is_none() {
             // We have hit an `AllocId` that is neither in local or global memory and isn't
             // marked as dangling by local memory.  That should be impossible.

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -4,12 +4,11 @@
 use std::convert::TryFrom;
 use std::fmt::Write;
 
-use rustc_errors::ErrorGuaranteed;
 use rustc_hir::def::Namespace;
 use rustc_macros::HashStable;
 use rustc_middle::ty::layout::{LayoutOf, PrimitiveExt, TyAndLayout};
 use rustc_middle::ty::print::{FmtPrinter, PrettyPrinter, Printer};
-use rustc_middle::ty::{ConstInt, Ty};
+use rustc_middle::ty::{ConstInt, DelaySpanBugEmitted, Ty};
 use rustc_middle::{mir, ty};
 use rustc_target::abi::{Abi, HasDataLayout, Size, TagEncoding};
 use rustc_target::abi::{VariantIdx, Variants};
@@ -565,7 +564,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     ) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> {
         match val.val() {
             ty::ConstKind::Param(_) | ty::ConstKind::Bound(..) => throw_inval!(TooGeneric),
-            ty::ConstKind::Error(_) => throw_inval!(AlreadyReported(ErrorGuaranteed)),
+            ty::ConstKind::Error(DelaySpanBugEmitted { reported, .. }) => {
+                throw_inval!(AlreadyReported(reported))
+            }
             ty::ConstKind::Unevaluated(uv) => {
                 let instance = self.resolve(uv.def, uv.substs)?;
                 Ok(self.eval_to_allocation(GlobalId { instance, promoted: uv.promoted })?.into())

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -259,7 +259,7 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
                 self.tcx.sess.diagnostic().emit_diagnostic(&error);
             }
         } else {
-            assert!(self.tcx.sess.has_errors());
+            assert!(self.tcx.sess.has_errors().is_some());
         }
     }
 
@@ -327,8 +327,8 @@ impl<'mir, 'tcx> Checker<'mir, 'tcx> {
 
         match op.importance() {
             ops::DiagnosticImportance::Primary => {
-                self.error_emitted = Some(ErrorGuaranteed);
-                err.emit();
+                let reported = err.emit();
+                self.error_emitted = Some(reported);
             }
 
             ops::DiagnosticImportance::Secondary => err.buffer(&mut self.secondary_errors),