Rollup of 8 pull requests

compiler/rustc_borrowck/src/lib.rs

@@ -110,14 +110,16 @@ fn mir_borrowck(tcx: TyCtxt<'_>, def: LocalDefId) -> &BorrowCheckResult<'_> {
  let (input_body, promoted) = tcx.mir_promoted(def);
  debug!("run query mir_borrowck: {}", tcx.def_path_str(def));
 
- if input_body.borrow().should_skip() {
- debug!("Skipping borrowck because of injected body");
+ let input_body: &Body<'_> = &input_body.borrow();
+
+ if input_body.should_skip() || input_body.tainted_by_errors.is_some() {
+ debug!("Skipping borrowck because of injected body or tainted body");
  // Let's make up a borrowck result! Fun times!
  let result = BorrowCheckResult {
  concrete_opaque_types: FxIndexMap::default(),
  closure_requirements: None,
  used_mut_upvars: SmallVec::new(),
- tainted_by_errors: None,
+ tainted_by_errors: input_body.tainted_by_errors,
  };
  return tcx.arena.alloc(result);
  }
@@ -126,7 +128,6 @@ fn mir_borrowck(tcx: TyCtxt<'_>, def: LocalDefId) -> &BorrowCheckResult<'_> {
 
  let infcx =
  tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bind(hir_owner.def_id)).build();
- let input_body: &Body<'_> = &input_body.borrow();
  let promoted: &IndexSlice<_, _> = &promoted.borrow();
  let opt_closure_req = do_mir_borrowck(&infcx, input_body, promoted, None).0;
  debug!("mir_borrowck done");

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -15,10 +15,7 @@ use rustc_data_structures::profiling::{SelfProfilerRef, VerboseTimingGuard};
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::Emitter;
 use rustc_errors::translation::Translate;
-use rustc_errors::{
- DiagCtxt, DiagnosticArgName, DiagnosticArgValue, DiagnosticBuilder, DiagnosticMessage, ErrCode,
- FatalError, FluentBundle, Level, Style,
-};
+use rustc_errors::{DiagCtxt, Diagnostic, DiagnosticBuilder, FatalError, FluentBundle, Level};
 use rustc_fs_util::link_or_copy;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc_incremental::{
@@ -997,13 +994,6 @@ pub(crate) enum Message<B: WriteBackendMethods> {
 /// process another codegen unit.
 pub struct CguMessage;
 
-struct Diagnostic {
- msgs: Vec<(DiagnosticMessage, Style)>,
- args: FxHashMap<DiagnosticArgName, DiagnosticArgValue>,
- code: Option<ErrCode>,
- lvl: Level,
-}
-
 #[derive(PartialEq, Clone, Copy, Debug)]
 enum MainThreadState {
  /// Doing nothing.
@@ -1764,7 +1754,6 @@ fn spawn_work<'a, B: ExtraBackendMethods>(
 enum SharedEmitterMessage {
  Diagnostic(Diagnostic),
  InlineAsmError(u32, String, Level, Option<(String, Vec<InnerSpan>)>),
- AbortIfErrors,
  Fatal(String),
 }
 
@@ -1810,24 +1799,8 @@ impl Translate for SharedEmitter {
 }
 
 impl Emitter for SharedEmitter {
- fn emit_diagnostic(&mut self, diag: &rustc_errors::Diagnostic) {
- let args: FxHashMap<DiagnosticArgName, DiagnosticArgValue> =
- diag.args().map(|(name, arg)| (name.clone(), arg.clone())).collect();
- drop(self.sender.send(SharedEmitterMessage::Diagnostic(Diagnostic {
- msgs: diag.messages.clone(),
- args: args.clone(),
- code: diag.code,
- lvl: diag.level(),
- })));
- for child in &diag.children {
- drop(self.sender.send(SharedEmitterMessage::Diagnostic(Diagnostic {
- msgs: child.messages.clone(),
- args: args.clone(),
- code: None,
- lvl: child.level,
- })));
- }
- drop(self.sender.send(SharedEmitterMessage::AbortIfErrors));
+ fn emit_diagnostic(&mut self, diag: rustc_errors::Diagnostic) {
+ drop(self.sender.send(SharedEmitterMessage::Diagnostic(diag)));
  }
 
  fn source_map(&self) -> Option<&Lrc<SourceMap>> {
@@ -1852,13 +1825,8 @@ impl SharedEmitterMain {
 
  match message {
  Ok(SharedEmitterMessage::Diagnostic(diag)) => {
- let dcx = sess.dcx();
- let mut d = rustc_errors::Diagnostic::new_with_messages(diag.lvl, diag.msgs);
- if let Some(code) = diag.code {
- d.code(code);
- }
- d.replace_args(diag.args);
- dcx.emit_diagnostic(d);
+ sess.dcx().emit_diagnostic(diag);
+ sess.dcx().abort_if_errors();
  }
  Ok(SharedEmitterMessage::InlineAsmError(cookie, msg, level, source)) => {
  assert!(matches!(level, Level::Error | Level::Warning | Level::Note));
@@ -1891,9 +1859,6 @@ impl SharedEmitterMain {
 
  err.emit();
  }
- Ok(SharedEmitterMessage::AbortIfErrors) => {
- sess.dcx().abort_if_errors();
- }
  Ok(SharedEmitterMessage::Fatal(msg)) => {
  sess.dcx().fatal(msg);
  }

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

@@ -20,7 +20,7 @@ use std::mem;
 use std::ops::{ControlFlow, Deref};
 
 use super::ops::{self, NonConstOp, Status};
-use super::qualifs::{self, CustomEq, HasMutInterior, NeedsDrop, NeedsNonConstDrop};
+use super::qualifs::{self, HasMutInterior, NeedsDrop, NeedsNonConstDrop};
 use super::resolver::FlowSensitiveAnalysis;
 use super::{ConstCx, Qualif};
 use crate::const_eval::is_unstable_const_fn;
@@ -149,37 +149,10 @@ impl<'mir, 'tcx> Qualifs<'mir, 'tcx> {
 
  let return_loc = ccx.body.terminator_loc(return_block);
 
- let custom_eq = match ccx.const_kind() {
- // We don't care whether a `const fn` returns a value that is not structurally
- // matchable. Functions calls are opaque and always use type-based qualification, so
- // this value should never be used.
- hir::ConstContext::ConstFn => true,
-
- // If we know that all values of the return type are structurally matchable, there's no
- // need to run dataflow.
- // Opaque types do not participate in const generics or pattern matching, so we can safely count them out.
- _ if ccx.body.return_ty().has_opaque_types()
- || !CustomEq::in_any_value_of_ty(ccx, ccx.body.return_ty()) =>
- {
- false
- }
-
- hir::ConstContext::Const { .. } | hir::ConstContext::Static(_) => {
- let mut cursor = FlowSensitiveAnalysis::new(CustomEq, ccx)
- .into_engine(ccx.tcx, ccx.body)
- .iterate_to_fixpoint()
- .into_results_cursor(ccx.body);
-
- cursor.seek_after_primary_effect(return_loc);
- cursor.get().contains(RETURN_PLACE)
- }
- };
-
  ConstQualifs {
  needs_drop: self.needs_drop(ccx, RETURN_PLACE, return_loc),
  needs_non_const_drop: self.needs_non_const_drop(ccx, RETURN_PLACE, return_loc),
  has_mut_interior: self.has_mut_interior(ccx, RETURN_PLACE, return_loc),
- custom_eq,
  tainted_by_errors,
  }
  }

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

@@ -10,7 +10,7 @@ use rustc_middle::mir::*;
 use rustc_middle::traits::BuiltinImplSource;
 use rustc_middle::ty::{self, AdtDef, GenericArgsRef, Ty};
 use rustc_trait_selection::traits::{
- self, ImplSource, Obligation, ObligationCause, ObligationCtxt, SelectionContext,
+ ImplSource, Obligation, ObligationCause, ObligationCtxt, SelectionContext,
 };
 
 use super::ConstCx;
@@ -24,7 +24,6 @@ pub fn in_any_value_of_ty<'tcx>(
  has_mut_interior: HasMutInterior::in_any_value_of_ty(cx, ty),
  needs_drop: NeedsDrop::in_any_value_of_ty(cx, ty),
  needs_non_const_drop: NeedsNonConstDrop::in_any_value_of_ty(cx, ty),
- custom_eq: CustomEq::in_any_value_of_ty(cx, ty),
  tainted_by_errors,
  }
 }
@@ -213,35 +212,6 @@ impl Qualif for NeedsNonConstDrop {
  }
 }
 
-/// A constant that cannot be used as part of a pattern in a `match` expression.
-pub struct CustomEq;
-
-impl Qualif for CustomEq {
- const ANALYSIS_NAME: &'static str = "flow_custom_eq";
-
- fn in_qualifs(qualifs: &ConstQualifs) -> bool {
- qualifs.custom_eq
- }
-
- fn in_any_value_of_ty<'tcx>(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {
- // If *any* component of a composite data type does not implement `Structural{Partial,}Eq`,
- // we know that at least some values of that type are not structural-match. I say "some"
- // because that component may be part of an enum variant (e.g.,
- // `Option::<NonStructuralMatchTy>::Some`), in which case some values of this type may be
- // structural-match (`Option::None`).
- traits::search_for_structural_match_violation(cx.body.span, cx.tcx, ty).is_some()
- }
-
- fn in_adt_inherently<'tcx>(
- cx: &ConstCx<'_, 'tcx>,
- def: AdtDef<'tcx>,
- args: GenericArgsRef<'tcx>,
- ) -> bool {
- let ty = Ty::new_adt(cx.tcx, def, args);
- !ty.is_structural_eq_shallow(cx.tcx)
- }
-}
-
 // FIXME: Use `mir::visit::Visitor` for the `in_*` functions if/when it supports early return.
 
 /// Returns `true` if this `Rvalue` contains qualif `Q`.

compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs

@@ -44,15 +44,15 @@ impl Translate for AnnotateSnippetEmitter {
 
 impl Emitter for AnnotateSnippetEmitter {
  /// The entry point for the diagnostics generation
- fn emit_diagnostic(&mut self, diag: &Diagnostic) {
+ fn emit_diagnostic(&mut self, mut diag: Diagnostic) {
  let fluent_args = to_fluent_args(diag.args());
 
- let mut children = diag.children.clone();
- let (mut primary_span, suggestions) = self.primary_span_formatted(diag, &fluent_args);
+ let mut suggestions = diag.suggestions.unwrap_or(vec![]);
+ self.primary_span_formatted(&mut diag.span, &mut suggestions, &fluent_args);
 
  self.fix_multispans_in_extern_macros_and_render_macro_backtrace(
- &mut primary_span,
- &mut children,
+ &mut diag.span,
+ &mut diag.children,
  &diag.level,
  self.macro_backtrace,
  );
@@ -62,9 +62,9 @@ impl Emitter for AnnotateSnippetEmitter {
  &diag.messages,
  &fluent_args,
  &diag.code,
- &primary_span,
- &children,
- suggestions,
+ &diag.span,
+ &diag.children,
+ &suggestions,
  );
  }
 

compiler/rustc_errors/src/emitter.rs

@@ -193,7 +193,7 @@ pub type DynEmitter = dyn Emitter + DynSend;
 /// Emitter trait for emitting errors.
 pub trait Emitter: Translate {
  /// Emit a structured diagnostic.
- fn emit_diagnostic(&mut self, diag: &Diagnostic);
+ fn emit_diagnostic(&mut self, diag: Diagnostic);
 
  /// Emit a notification that an artifact has been output.
  /// Currently only supported for the JSON format.
@@ -230,17 +230,17 @@ pub trait Emitter: Translate {
  ///
  /// * If the current `Diagnostic` has only one visible `CodeSuggestion`,
  /// we format the `help` suggestion depending on the content of the
- /// substitutions. In that case, we return the modified span only.
+ /// substitutions. In that case, we modify the span and clear the
+ /// suggestions.
  ///
  /// * If the current `Diagnostic` has multiple suggestions,
- /// we return the original `primary_span` and the original suggestions.
- fn primary_span_formatted<'a>(
+ /// we leave `primary_span` and the suggestions untouched.
+ fn primary_span_formatted(
  &mut self,
- diag: &'a Diagnostic,
+ primary_span: &mut MultiSpan,
+ suggestions: &mut Vec<CodeSuggestion>,
  fluent_args: &FluentArgs<'_>,
- ) -> (MultiSpan, &'a [CodeSuggestion]) {
- let mut primary_span = diag.span.clone();
- let suggestions = diag.suggestions.as_deref().unwrap_or(&[]);
+ ) {
  if let Some((sugg, rest)) = suggestions.split_first() {
  let msg = self.translate_message(&sugg.msg, fluent_args).map_err(Report::new).unwrap();
  if rest.is_empty() &&
@@ -287,16 +287,15 @@ pub trait Emitter: Translate {
  primary_span.push_span_label(sugg.substitutions[0].parts[0].span, msg);
 
  // We return only the modified primary_span
- (primary_span, &[])
+ suggestions.clear();
  } else {
  // if there are multiple suggestions, print them all in full
  // to be consistent. We could try to figure out if we can
  // make one (or the first one) inline, but that would give
  // undue importance to a semi-random suggestion
- (primary_span, suggestions)
  }
  } else {
- (primary_span, suggestions)
+ // do nothing
  }
  }
 
@@ -518,16 +517,15 @@ impl Emitter for HumanEmitter {
  self.sm.as_ref()
  }
 
- fn emit_diagnostic(&mut self, diag: &Diagnostic) {
+ fn emit_diagnostic(&mut self, mut diag: Diagnostic) {
  let fluent_args = to_fluent_args(diag.args());
 
- let mut children = diag.children.clone();
- let (mut primary_span, suggestions) = self.primary_span_formatted(diag, &fluent_args);
- debug!("emit_diagnostic: suggestions={:?}", suggestions);
+ let mut suggestions = diag.suggestions.unwrap_or(vec![]);
+ self.primary_span_formatted(&mut diag.span, &mut suggestions, &fluent_args);
 
  self.fix_multispans_in_extern_macros_and_render_macro_backtrace(
- &mut primary_span,
- &mut children,
+ &mut diag.span,
+ &mut diag.children,
  &diag.level,
  self.macro_backtrace,
  );
@@ -537,9 +535,9 @@ impl Emitter for HumanEmitter {
  &diag.messages,
  &fluent_args,
  &diag.code,
- &primary_span,
- &children,
- suggestions,
+ &diag.span,
+ &diag.children,
+ &suggestions,
  self.track_diagnostics.then_some(&diag.emitted_at),
  );
  }
@@ -576,9 +574,8 @@ impl Emitter for SilentEmitter {
  None
  }
 
- fn emit_diagnostic(&mut self, diag: &Diagnostic) {
+ fn emit_diagnostic(&mut self, mut diag: Diagnostic) {
  if diag.level == Level::Fatal {
- let mut diag = diag.clone();
  diag.note(self.fatal_note.clone());
  self.fatal_dcx.emit_diagnostic(diag);
  }