bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Remove HirTyLowerer::set_tainted_by_errors, since it is now redundant

Browse source
This commit is contained in:
Oli Scherer 2024-07-05 10:05:58 +00:00
parent fd9a92542c
commit aece06482e
6 changed files with 97 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

92
compiler/rustc_hir_analysis/src/collect.rs
View file

@ -163,7 +163,7 @@ pub struct CollectItemTypesVisitor<'tcx> {
/// and suggest adding type parameters in the appropriate place, taking into consideration any and /// and suggest adding type parameters in the appropriate place, taking into consideration any and
/// all already existing generic type parameters to avoid suggesting a name that is already in use. /// all already existing generic type parameters to avoid suggesting a name that is already in use.
pub(crate) fn placeholder_type_error<'tcx>( pub(crate) fn placeholder_type_error<'tcx>(
tcx: TyCtxt<'tcx>, cx: &dyn HirTyLowerer<'tcx>,
generics: Option<&hir::Generics<'_>>, generics: Option<&hir::Generics<'_>>,
placeholder_types: Vec<Span>, placeholder_types: Vec<Span>,
suggest: bool, suggest: bool,
@ -174,21 +174,21 @@ pub(crate) fn placeholder_type_error<'tcx>(
return; return;
} }
placeholder_type_error_diag(tcx, generics, placeholder_types, vec![], suggest, hir_ty, kind) placeholder_type_error_diag(cx, generics, placeholder_types, vec![], suggest, hir_ty, kind)
.emit(); .emit();
} }
pub(crate) fn placeholder_type_error_diag<'tcx>( pub(crate) fn placeholder_type_error_diag<'cx, 'tcx>(
tcx: TyCtxt<'tcx>, cx: &'cx dyn HirTyLowerer<'tcx>,
generics: Option<&hir::Generics<'_>>, generics: Option<&hir::Generics<'_>>,
placeholder_types: Vec<Span>, placeholder_types: Vec<Span>,
additional_spans: Vec<Span>, additional_spans: Vec<Span>,
suggest: bool, suggest: bool,
hir_ty: Option<&hir::Ty<'_>>, hir_ty: Option<&hir::Ty<'_>>,
kind: &'static str, kind: &'static str,
) -> Diag<'tcx> { ) -> Diag<'cx> {
if placeholder_types.is_empty() { if placeholder_types.is_empty() {
return bad_placeholder(tcx, additional_spans, kind); return bad_placeholder(cx, additional_spans, kind);
} }
let params = generics.map(|g| g.params).unwrap_or_default(); let params = generics.map(|g| g.params).unwrap_or_default();
@ -212,7 +212,7 @@ pub(crate) fn placeholder_type_error_diag<'tcx>(
} }
let mut err = let mut err =
bad_placeholder(tcx, placeholder_types.into_iter().chain(additional_spans).collect(), kind); bad_placeholder(cx, placeholder_types.into_iter().chain(additional_spans).collect(), kind);
// Suggest, but only if it is not a function in const or static // Suggest, but only if it is not a function in const or static
if suggest { if suggest {
@ -226,7 +226,7 @@ pub(crate) fn placeholder_type_error_diag<'tcx>(
// Check if parent is const or static // Check if parent is const or static
is_const_or_static = matches!( is_const_or_static = matches!(
tcx.parent_hir_node(hir_ty.hir_id), cx.tcx().parent_hir_node(hir_ty.hir_id),
Node::Item(&hir::Item { Node::Item(&hir::Item {
kind: hir::ItemKind::Const(..) | hir::ItemKind::Static(..), kind: hir::ItemKind::Const(..) | hir::ItemKind::Static(..),
.. ..
@ -269,7 +269,16 @@ fn reject_placeholder_type_signatures_in_item<'tcx>(
let mut visitor = HirPlaceholderCollector::default(); let mut visitor = HirPlaceholderCollector::default();
visitor.visit_item(item); visitor.visit_item(item);
placeholder_type_error(tcx, Some(generics), visitor.0, suggest, None, item.kind.descr()); let icx = ItemCtxt::new(tcx, item.owner_id.def_id);
placeholder_type_error(
icx.lowerer(),
Some(generics),
visitor.0,
suggest,
None,
item.kind.descr(),
);
} }
impl<'tcx> Visitor<'tcx> for CollectItemTypesVisitor<'tcx> { impl<'tcx> Visitor<'tcx> for CollectItemTypesVisitor<'tcx> {
@ -331,15 +340,15 @@ impl<'tcx> Visitor<'tcx> for CollectItemTypesVisitor<'tcx> {
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// Utility types and common code for the above passes. // Utility types and common code for the above passes.
fn bad_placeholder<'tcx>( fn bad_placeholder<'cx, 'tcx>(
tcx: TyCtxt<'tcx>, cx: &'cx dyn HirTyLowerer<'tcx>,
mut spans: Vec<Span>, mut spans: Vec<Span>,
kind: &'static str, kind: &'static str,
) -> Diag<'tcx> { ) -> Diag<'cx> {
let kind = if kind.ends_with('s') { format!("{kind}es") } else { format!("{kind}s") }; let kind = if kind.ends_with('s') { format!("{kind}es") } else { format!("{kind}s") };
spans.sort(); spans.sort();
tcx.dcx().create_err(errors::PlaceholderNotAllowedItemSignatures { spans, kind }) cx.dcx().create_err(errors::PlaceholderNotAllowedItemSignatures { spans, kind })
} }
impl<'tcx> ItemCtxt<'tcx> { impl<'tcx> ItemCtxt<'tcx> {
@ -383,14 +392,13 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
fn re_infer(&self, span: Span, reason: RegionInferReason<'_>) -> ty::Region<'tcx> { fn re_infer(&self, span: Span, reason: RegionInferReason<'_>) -> ty::Region<'tcx> {
if let RegionInferReason::BorrowedObjectLifetimeDefault = reason { if let RegionInferReason::BorrowedObjectLifetimeDefault = reason {
let e = struct_span_code_err!( let e = struct_span_code_err!(
self.tcx().dcx(), self.dcx(),
span, span,
E0228, E0228,
"the lifetime bound for this object type cannot be deduced \ "the lifetime bound for this object type cannot be deduced \
from context; please supply an explicit bound" from context; please supply an explicit bound"
) )
.emit(); .emit();
self.set_tainted_by_errors(e);
ty::Region::new_error(self.tcx(), e) ty::Region::new_error(self.tcx(), e)
} else { } else {
// This indicates an illegal lifetime in a non-assoc-trait position // This indicates an illegal lifetime in a non-assoc-trait position
@ -515,10 +523,6 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
None None
} }
fn set_tainted_by_errors(&self, err: ErrorGuaranteed) {
self.tainted_by_errors.set(Some(err));
}
fn lower_fn_sig( fn lower_fn_sig(
&self, &self,
decl: &hir::FnDecl<'tcx>, decl: &hir::FnDecl<'tcx>,
@ -576,7 +580,7 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
// `ident_span` to not emit an error twice when we have `fn foo(_: fn() -> _)`. // `ident_span` to not emit an error twice when we have `fn foo(_: fn() -> _)`.
let mut diag = crate::collect::placeholder_type_error_diag( let mut diag = crate::collect::placeholder_type_error_diag(
tcx, self,
generics, generics,
visitor.0, visitor.0,
infer_replacements.iter().map(|(s, _)| *s).collect(), infer_replacements.iter().map(|(s, _)| *s).collect(),
@ -596,7 +600,7 @@ impl<'tcx> HirTyLowerer<'tcx> for ItemCtxt<'tcx> {
); );
} }
self.set_tainted_by_errors(diag.emit()); diag.emit();
} }
(input_tys, output_ty) (input_tys, output_ty)
@ -645,6 +649,7 @@ fn lower_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
let it = tcx.hir().item(item_id); let it = tcx.hir().item(item_id);
debug!(item = %it.ident, id = %it.hir_id()); debug!(item = %it.ident, id = %it.hir_id());
let def_id = item_id.owner_id.def_id; let def_id = item_id.owner_id.def_id;
let icx = ItemCtxt::new(tcx, def_id);
match &it.kind { match &it.kind {
// These don't define types. // These don't define types.
@ -669,7 +674,7 @@ fn lower_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
let mut visitor = HirPlaceholderCollector::default(); let mut visitor = HirPlaceholderCollector::default();
visitor.visit_foreign_item(item); visitor.visit_foreign_item(item);
placeholder_type_error( placeholder_type_error(
tcx, icx.lowerer(),
None, None,
visitor.0, visitor.0,
false, false,
@ -748,7 +753,14 @@ fn lower_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) {
if !ty.is_suggestable_infer_ty() { if !ty.is_suggestable_infer_ty() {
let mut visitor = HirPlaceholderCollector::default(); let mut visitor = HirPlaceholderCollector::default();
visitor.visit_item(it); visitor.visit_item(it);
placeholder_type_error(tcx, None, visitor.0, false, None, it.kind.descr()); placeholder_type_error(
icx.lowerer(),
None,
visitor.0,
false,
None,
it.kind.descr(),
);
} }
} }
@ -766,6 +778,7 @@ fn lower_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::TraitItemId) {
let trait_item = tcx.hir().trait_item(trait_item_id); let trait_item = tcx.hir().trait_item(trait_item_id);
let def_id = trait_item_id.owner_id; let def_id = trait_item_id.owner_id;
tcx.ensure().generics_of(def_id); tcx.ensure().generics_of(def_id);
let icx = ItemCtxt::new(tcx, def_id.def_id);
match trait_item.kind { match trait_item.kind {
hir::TraitItemKind::Fn(..) => { hir::TraitItemKind::Fn(..) => {
@ -782,7 +795,14 @@ fn lower_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::TraitItemId) {
// Account for `const C: _;`. // Account for `const C: _;`.
let mut visitor = HirPlaceholderCollector::default(); let mut visitor = HirPlaceholderCollector::default();
visitor.visit_trait_item(trait_item); visitor.visit_trait_item(trait_item);
placeholder_type_error(tcx, None, visitor.0, false, None, "associated constant"); placeholder_type_error(
icx.lowerer(),
None,
visitor.0,
false,
None,
"associated constant",
);
} }
} }
@ -793,7 +813,7 @@ fn lower_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::TraitItemId) {
// Account for `type T = _;`. // Account for `type T = _;`.
let mut visitor = HirPlaceholderCollector::default(); let mut visitor = HirPlaceholderCollector::default();
visitor.visit_trait_item(trait_item); visitor.visit_trait_item(trait_item);
placeholder_type_error(tcx, None, visitor.0, false, None, "associated type"); placeholder_type_error(icx.lowerer(), None, visitor.0, false, None, "associated type");
} }
hir::TraitItemKind::Type(_, None) => { hir::TraitItemKind::Type(_, None) => {
@ -804,7 +824,7 @@ fn lower_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::TraitItemId) {
let mut visitor = HirPlaceholderCollector::default(); let mut visitor = HirPlaceholderCollector::default();
visitor.visit_trait_item(trait_item); visitor.visit_trait_item(trait_item);
placeholder_type_error(tcx, None, visitor.0, false, None, "associated type"); placeholder_type_error(icx.lowerer(), None, visitor.0, false, None, "associated type");
} }
}; };
@ -817,6 +837,7 @@ fn lower_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::ImplItemId) {
tcx.ensure().type_of(def_id); tcx.ensure().type_of(def_id);
tcx.ensure().predicates_of(def_id); tcx.ensure().predicates_of(def_id);
let impl_item = tcx.hir().impl_item(impl_item_id); let impl_item = tcx.hir().impl_item(impl_item_id);
let icx = ItemCtxt::new(tcx, def_id.def_id);
match impl_item.kind { match impl_item.kind {
hir::ImplItemKind::Fn(..) => { hir::ImplItemKind::Fn(..) => {
tcx.ensure().codegen_fn_attrs(def_id); tcx.ensure().codegen_fn_attrs(def_id);
@ -827,14 +848,21 @@ fn lower_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::ImplItemId) {
let mut visitor = HirPlaceholderCollector::default(); let mut visitor = HirPlaceholderCollector::default();
visitor.visit_impl_item(impl_item); visitor.visit_impl_item(impl_item);
placeholder_type_error(tcx, None, visitor.0, false, None, "associated type"); placeholder_type_error(icx.lowerer(), None, visitor.0, false, None, "associated type");
} }
hir::ImplItemKind::Const(ty, _) => { hir::ImplItemKind::Const(ty, _) => {
// Account for `const T: _ = ..;` // Account for `const T: _ = ..;`
if !ty.is_suggestable_infer_ty() { if !ty.is_suggestable_infer_ty() {
let mut visitor = HirPlaceholderCollector::default(); let mut visitor = HirPlaceholderCollector::default();
visitor.visit_impl_item(impl_item); visitor.visit_impl_item(impl_item);
placeholder_type_error(tcx, None, visitor.0, false, None, "associated constant"); placeholder_type_error(
icx.lowerer(),
None,
visitor.0,
false,
None,
"associated constant",
);
} }
} }
} }
@ -1385,7 +1413,7 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_, ty::PolyFn
.. ..
}) })
| Item(hir::Item { kind: ItemKind::Fn(sig, generics, _), .. }) => { | Item(hir::Item { kind: ItemKind::Fn(sig, generics, _), .. }) => {
infer_return_ty_for_fn_sig(tcx, sig, generics, def_id, &icx) infer_return_ty_for_fn_sig(sig, generics, def_id, &icx)
} }
ImplItem(hir::ImplItem { kind: ImplItemKind::Fn(sig, _), generics, .. }) => { ImplItem(hir::ImplItem { kind: ImplItemKind::Fn(sig, _), generics, .. }) => {
@ -1402,7 +1430,7 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_, ty::PolyFn
None, None,
) )
} else { } else {
infer_return_ty_for_fn_sig(tcx, sig, generics, def_id, &icx) infer_return_ty_for_fn_sig(sig, generics, def_id, &icx)
} }
} }
@ -1455,12 +1483,12 @@ fn fn_sig(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_, ty::PolyFn
} }
fn infer_return_ty_for_fn_sig<'tcx>( fn infer_return_ty_for_fn_sig<'tcx>(
tcx: TyCtxt<'tcx>,
sig: &hir::FnSig<'tcx>, sig: &hir::FnSig<'tcx>,
generics: &hir::Generics<'_>, generics: &hir::Generics<'_>,
def_id: LocalDefId, def_id: LocalDefId,
icx: &ItemCtxt<'tcx>, icx: &ItemCtxt<'tcx>,
) -> ty::PolyFnSig<'tcx> { ) -> ty::PolyFnSig<'tcx> {
let tcx = icx.tcx;
let hir_id = tcx.local_def_id_to_hir_id(def_id); let hir_id = tcx.local_def_id_to_hir_id(def_id);
match sig.decl.output.get_infer_ret_ty() { match sig.decl.output.get_infer_ret_ty() {
@ -1492,7 +1520,7 @@ fn infer_return_ty_for_fn_sig<'tcx>(
let mut visitor = HirPlaceholderCollector::default(); let mut visitor = HirPlaceholderCollector::default();
visitor.visit_ty(ty); visitor.visit_ty(ty);
let mut diag = bad_placeholder(tcx, visitor.0, "return type"); let mut diag = bad_placeholder(icx.lowerer(), visitor.0, "return type");
let ret_ty = fn_sig.output(); let ret_ty = fn_sig.output();
// Don't leak types into signatures unless they're nameable! // Don't leak types into signatures unless they're nameable!
// For example, if a function returns itself, we don't want that // For example, if a function returns itself, we don't want that

27
compiler/rustc_hir_analysis/src/collect/type_of.rs
View file

@ -12,6 +12,7 @@ use rustc_span::symbol::Ident;
use rustc_span::{Span, DUMMY_SP}; use rustc_span::{Span, DUMMY_SP};
use crate::errors::TypeofReservedKeywordUsed; use crate::errors::TypeofReservedKeywordUsed;
use crate::hir_ty_lowering::HirTyLowerer;
use super::bad_placeholder; use super::bad_placeholder;
use super::ItemCtxt; use super::ItemCtxt;
@ -357,7 +358,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
.and_then(|body_id| { .and_then(|body_id| {
ty.is_suggestable_infer_ty().then(|| { ty.is_suggestable_infer_ty().then(|| {
infer_placeholder_type( infer_placeholder_type(
tcx, icx.lowerer(),
def_id, def_id,
body_id, body_id,
ty.span, ty.span,
@ -381,7 +382,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
ImplItemKind::Const(ty, body_id) => { ImplItemKind::Const(ty, body_id) => {
if ty.is_suggestable_infer_ty() { if ty.is_suggestable_infer_ty() {
infer_placeholder_type( infer_placeholder_type(
tcx, icx.lowerer(),
def_id, def_id,
body_id, body_id,
ty.span, ty.span,
@ -405,7 +406,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
ItemKind::Static(ty, .., body_id) => { ItemKind::Static(ty, .., body_id) => {
if ty.is_suggestable_infer_ty() { if ty.is_suggestable_infer_ty() {
infer_placeholder_type( infer_placeholder_type(
tcx, icx.lowerer(),
def_id, def_id,
body_id, body_id,
ty.span, ty.span,
@ -418,7 +419,14 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
} }
ItemKind::Const(ty, _, body_id) => { ItemKind::Const(ty, _, body_id) => {
if ty.is_suggestable_infer_ty() { if ty.is_suggestable_infer_ty() {
infer_placeholder_type(tcx, def_id, body_id, ty.span, item.ident, "constant") infer_placeholder_type(
icx.lowerer(),
def_id,
body_id,
ty.span,
item.ident,
"constant",
)
} else { } else {
icx.lower_ty(ty) icx.lower_ty(ty)
} }
@ -559,21 +567,22 @@ pub(super) fn type_of_opaque(
} }
} }
fn infer_placeholder_type<'a>( fn infer_placeholder_type<'tcx>(
tcx: TyCtxt<'a>, cx: &dyn HirTyLowerer<'tcx>,
def_id: LocalDefId, def_id: LocalDefId,
body_id: hir::BodyId, body_id: hir::BodyId,
span: Span, span: Span,
item_ident: Ident, item_ident: Ident,
kind: &'static str, kind: &'static str,
) -> Ty<'a> { ) -> Ty<'tcx> {
let tcx = cx.tcx();
let ty = tcx.diagnostic_only_typeck(def_id).node_type(body_id.hir_id); let ty = tcx.diagnostic_only_typeck(def_id).node_type(body_id.hir_id);
// If this came from a free `const` or `static mut?` item, // If this came from a free `const` or `static mut?` item,
// then the user may have written e.g. `const A = 42;`. // then the user may have written e.g. `const A = 42;`.
// In this case, the parser has stashed a diagnostic for // In this case, the parser has stashed a diagnostic for
// us to improve in typeck so we do that now. // us to improve in typeck so we do that now.
let guar = tcx let guar = cx
.dcx() .dcx()
.try_steal_modify_and_emit_err(span, StashKey::ItemNoType, |err| { .try_steal_modify_and_emit_err(span, StashKey::ItemNoType, |err| {
if !ty.references_error() { if !ty.references_error() {
@ -602,7 +611,7 @@ fn infer_placeholder_type<'a>(
} }
}) })
.unwrap_or_else(|| { .unwrap_or_else(|| {
let mut diag = bad_placeholder(tcx, vec![span], kind); let mut diag = bad_placeholder(cx, vec![span], kind);
if !ty.references_error() { if !ty.references_error() {
if let Some(ty) = ty.make_suggestable(tcx, false, None) { if let Some(ty) = ty.make_suggestable(tcx, false, None) {

43
compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
View file

@ -462,9 +462,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
} }
} }
} }
let reported = err.emit(); err.emit()
self.set_tainted_by_errors(reported);
reported
} }
pub(crate) fn complain_about_ambiguous_inherent_assoc_ty( pub(crate) fn complain_about_ambiguous_inherent_assoc_ty(
@ -481,9 +479,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
); );
err.span_label(name.span, format!("multiple `{name}` found")); err.span_label(name.span, format!("multiple `{name}` found"));
self.note_ambiguous_inherent_assoc_ty(&mut err, candidates, span); self.note_ambiguous_inherent_assoc_ty(&mut err, candidates, span);
let reported = err.emit(); err.emit()
self.set_tainted_by_errors(reported);
reported
} }
// FIXME(fmease): Heavily adapted from `rustc_hir_typeck::method::suggest`. Deduplicate. // FIXME(fmease): Heavily adapted from `rustc_hir_typeck::method::suggest`. Deduplicate.
@ -973,7 +969,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
} }
} }
self.set_tainted_by_errors(err.emit()); err.emit();
} }
/// On ambiguous associated type, look for an associated function whose name matches the /// On ambiguous associated type, look for an associated function whose name matches the
@ -1010,17 +1006,14 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
.filter_by_name_unhygienic(Symbol::intern(&name)) .filter_by_name_unhygienic(Symbol::intern(&name))
.next() .next()
{ {
let reported = Err(struct_span_code_err!(self.dcx(), span, E0223, "ambiguous associated type")
struct_span_code_err!(self.dcx(), span, E0223, "ambiguous associated type") .with_span_suggestion_verbose(
.with_span_suggestion_verbose( ident2.span.to(ident3.span),
ident2.span.to(ident3.span), format!("there is an associated function with a similar name: `{name}`"),
format!("there is an associated function with a similar name: `{name}`"), name,
name, Applicability::MaybeIncorrect,
Applicability::MaybeIncorrect, )
) .emit())
.emit();
self.set_tainted_by_errors(reported);
Err(reported)
} else { } else {
Ok(()) Ok(())
} }
@ -1129,9 +1122,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
err.span_label(span, format!("not allowed on {what}")); err.span_label(span, format!("not allowed on {what}"));
} }
generics_args_err_extend(self.tcx(), segments, &mut err, err_extend); generics_args_err_extend(self.tcx(), segments, &mut err, err_extend);
let reported = err.emit(); err.emit()
self.set_tainted_by_errors(reported);
reported
} }
pub fn report_trait_object_addition_traits_error( pub fn report_trait_object_addition_traits_error(
@ -1167,9 +1158,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
for more information on them, visit \ for more information on them, visit \
<https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>", <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>",
); );
let reported = err.emit(); err.emit()
self.set_tainted_by_errors(reported);
reported
} }
pub fn report_trait_object_with_no_traits_error( pub fn report_trait_object_with_no_traits_error(
@ -1183,10 +1172,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
.map(|&(trait_ref, _)| trait_ref.def_id()) .map(|&(trait_ref, _)| trait_ref.def_id())
.find(|&trait_ref| tcx.is_trait_alias(trait_ref)) .find(|&trait_ref| tcx.is_trait_alias(trait_ref))
.map(|trait_ref| tcx.def_span(trait_ref)); .map(|trait_ref| tcx.def_span(trait_ref));
let reported =
self.dcx().emit_err(TraitObjectDeclaredWithNoTraits { span, trait_alias_span }); self.dcx().emit_err(TraitObjectDeclaredWithNoTraits { span, trait_alias_span })
self.set_tainted_by_errors(reported);
reported
} }
} }

22
compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
View file

@ -180,12 +180,6 @@ pub trait HirTyLowerer<'tcx> {
/// The inference context of the lowering context if applicable. /// The inference context of the lowering context if applicable.
fn infcx(&self) -> Option<&InferCtxt<'tcx>>; fn infcx(&self) -> Option<&InferCtxt<'tcx>>;
/// Taint the context with errors.
///
/// Invoke this when you encounter an error from some prior pass like name resolution.
/// This is used to help suppress derived errors typeck might otherwise report.
fn set_tainted_by_errors(&self, e: ErrorGuaranteed);
/// Convenience method for coercing the lowering context into a trait object type. /// Convenience method for coercing the lowering context into a trait object type.
/// ///
/// Most lowering routines are defined on the trait object type directly /// Most lowering routines are defined on the trait object type directly
@ -405,10 +399,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
self_ty.is_some(), self_ty.is_some(),
); );
if let Err(err) = &arg_count.correct {
self.set_tainted_by_errors(err.reported);
}
// Skip processing if type has no generic parameters. // Skip processing if type has no generic parameters.
// Traits always have `Self` as a generic parameter, which means they will not return early // Traits always have `Self` as a generic parameter, which means they will not return early
// here and so associated item constraints will be handled regardless of whether there are // here and so associated item constraints will be handled regardless of whether there are
@ -569,7 +559,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
span, span,
modifier: constness.as_str(), modifier: constness.as_str(),
}); });
self.set_tainted_by_errors(reported);
arg_count.correct = Err(GenericArgCountMismatch { reported, invalid_args: vec![] }); arg_count.correct = Err(GenericArgCountMismatch { reported, invalid_args: vec![] });
} }
@ -876,7 +865,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
span, span,
constraint, constraint,
); );
self.set_tainted_by_errors(reported);
return Err(reported); return Err(reported);
}; };
debug!(?bound); debug!(?bound);
@ -959,7 +947,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
)); ));
} }
let reported = err.emit(); let reported = err.emit();
self.set_tainted_by_errors(reported);
if !where_bounds.is_empty() { if !where_bounds.is_empty() {
return Err(reported); return Err(reported);
} }
@ -1152,7 +1139,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
assoc_ident.name, assoc_ident.name,
) )
}; };
self.set_tainted_by_errors(reported);
return Err(reported); return Err(reported);
} }
}; };
@ -1403,13 +1389,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
let tcx = self.tcx(); let tcx = self.tcx();
if !tcx.visibility(item_def_id).is_accessible_from(scope, tcx) { if !tcx.visibility(item_def_id).is_accessible_from(scope, tcx) {
let reported = self.dcx().emit_err(crate::errors::AssocItemIsPrivate { self.dcx().emit_err(crate::errors::AssocItemIsPrivate {
span, span,
kind: tcx.def_descr(item_def_id), kind: tcx.def_descr(item_def_id),
name: ident, name: ident,
defined_here_label: tcx.def_span(item_def_id), defined_here_label: tcx.def_span(item_def_id),
}); });
self.set_tainted_by_errors(reported);
} }
tcx.check_stability(item_def_id, Some(block), span, None); tcx.check_stability(item_def_id, Some(block), span, None);
@ -1835,7 +1820,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
err.span_note(impl_.self_ty.span, "not a concrete type"); err.span_note(impl_.self_ty.span, "not a concrete type");
} }
let reported = err.emit(); let reported = err.emit();
self.set_tainted_by_errors(reported);
Ty::new_error(tcx, reported) Ty::new_error(tcx, reported)
} else { } else {
ty ty
@ -1882,7 +1866,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
.tcx() .tcx()
.dcx() .dcx()
.span_delayed_bug(path.span, "path with `Res::Err` but no error emitted"); .span_delayed_bug(path.span, "path with `Res::Err` but no error emitted");
self.set_tainted_by_errors(e);
Ty::new_error(self.tcx(), e) Ty::new_error(self.tcx(), e)
} }
Res::Def(..) => { Res::Def(..) => {
@ -2017,7 +2000,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
if self.check_delegation_constraints(sig_id, span, idx == hir::InferDelegationKind::Output) if self.check_delegation_constraints(sig_id, span, idx == hir::InferDelegationKind::Output)
{ {
let e = self.dcx().span_delayed_bug(span, "not supported delegation case"); let e = self.dcx().span_delayed_bug(span, "not supported delegation case");
self.set_tainted_by_errors(e);
return Ty::new_error(self.tcx(), e); return Ty::new_error(self.tcx(), e);
}; };
let sig = self.tcx().fn_sig(sig_id); let sig = self.tcx().fn_sig(sig_id);
@ -2442,7 +2424,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
err.note("consider introducing a named lifetime parameter"); err.note("consider introducing a named lifetime parameter");
} }
self.set_tainted_by_errors(err.emit()); err.emit();
} }
} }

3
compiler/rustc_hir_analysis/src/hir_ty_lowering/object_safety.rs
View file

@ -262,7 +262,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
if references_self { if references_self {
let def_id = i.bottom().0.def_id(); let def_id = i.bottom().0.def_id();
let reported = struct_span_code_err!( struct_span_code_err!(
self.dcx(), self.dcx(),
i.bottom().1, i.bottom().1,
E0038, E0038,
@ -275,7 +275,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
.error_msg(), .error_msg(),
) )
.emit(); .emit();
self.set_tainted_by_errors(reported);
} }
ty::ExistentialTraitRef { def_id: trait_ref.def_id, args } ty::ExistentialTraitRef { def_id: trait_ref.def_id, args }

6
compiler/rustc_hir_typeck/src/fn_ctxt/mod.rs
View file

@ -5,7 +5,7 @@ mod checks;
mod inspect_obligations; mod inspect_obligations;
mod suggestions; mod suggestions;
use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed}; use rustc_errors::DiagCtxtHandle;
use crate::coercion::DynamicCoerceMany; use crate::coercion::DynamicCoerceMany;
use crate::fallback::DivergingFallbackBehavior; use crate::fallback::DivergingFallbackBehavior;
@ -342,10 +342,6 @@ impl<'tcx> HirTyLowerer<'tcx> for FnCtxt<'_, 'tcx> {
Some(&self.infcx) Some(&self.infcx)
} }
fn set_tainted_by_errors(&self, e: ErrorGuaranteed) {
self.infcx.set_tainted_by_errors(e)
}
fn lower_fn_sig( fn lower_fn_sig(
&self, &self,
decl: &rustc_hir::FnDecl<'tcx>, decl: &rustc_hir::FnDecl<'tcx>,