nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

replace guess_head_span with def_span

Browse Source
This commit is contained in:
Takayuki Maeda 2022-07-04 17:23:24 +09:00
parent 5b8cf49c51
commit 83dea35384
24 changed files with 111 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
compiler/rustc_borrowck/src/diagnostics/mod.rs
View File

@ -812,12 +812,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
return FnSelfUse {
var_span: stmt.source_info.span,
fn_call_span: *fn_span,
fn_span: self
.infcx
.tcx
.sess
.source_map()
.guess_head_span(self.infcx.tcx.def_span(method_did)),
fn_span: self.infcx.tcx.def_span(method_did),
kind,
};
}

5
compiler/rustc_const_eval/src/transform/check_consts/ops.rs
View File

@ -155,8 +155,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
});
if let Ok(Some(ImplSource::UserDefined(data))) = implsrc {
let span =
tcx.sess.source_map().guess_head_span(tcx.def_span(data.impl_def_id));
let span = tcx.def_span(data.impl_def_id);
err.span_note(span, "impl defined here, but it is not `const`");
}
}
@ -205,7 +204,7 @@ impl<'tcx> NonConstOp<'tcx> for FnCallNonConst<'tcx> {
match self_ty.kind() {
FnDef(def_id, ..) => {
let span = tcx.sess.source_map().guess_head_span(tcx.def_span(*def_id));
let span = tcx.def_span(*def_id);
if ccx.tcx.is_const_fn_raw(*def_id) {
span_bug!(span, "calling const FnDef errored when it shouldn't");
}

8
compiler/rustc_infer/src/infer/error_reporting/mod.rs
View File

@ -148,12 +148,10 @@ fn msg_span_from_early_bound_and_free_regions<'tcx>(
tcx: TyCtxt<'tcx>,
region: ty::Region<'tcx>,
) -> (String, Span) {
let sm = tcx.sess.source_map();
let scope = region.free_region_binding_scope(tcx).expect_local();
match *region {
ty::ReEarlyBound(ref br) => {
let mut sp = sm.guess_head_span(tcx.def_span(scope));
let mut sp = tcx.def_span(scope);
if let Some(param) =
tcx.hir().get_generics(scope).and_then(|generics| generics.get_named(br.name))
{
@ -174,7 +172,7 @@ fn msg_span_from_early_bound_and_free_regions<'tcx>(
} else {
match fr.bound_region {
ty::BoundRegionKind::BrNamed(_, name) => {
let mut sp = sm.guess_head_span(tcx.def_span(scope));
let mut sp = tcx.def_span(scope);
if let Some(param) =
tcx.hir().get_generics(scope).and_then(|generics| generics.get_named(name))
{
@ -193,7 +191,7 @@ fn msg_span_from_early_bound_and_free_regions<'tcx>(
),
_ => (
format!("the lifetime `{}` as defined here", region),
sm.guess_head_span(tcx.def_span(scope)),
tcx.def_span(scope),
),
}
}

8
compiler/rustc_infer/src/traits/error_reporting/mod.rs
View File

@ -23,10 +23,12 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
let mut err = struct_span_err!(self.tcx.sess, sp, E0276, "{}", msg);
if let Some(trait_item_span) = self.tcx.hir().span_if_local(trait_item_def_id) {
let span = self.tcx.sess.source_map().guess_head_span(trait_item_span);
if trait_item_def_id.is_local() {
let item_name = self.tcx.item_name(impl_item_def_id.to_def_id());
err.span_label(span, format!("definition of `{}` from trait", item_name));
err.span_label(
self.tcx.def_span(trait_item_def_id),
format!("definition of `{}` from trait", item_name),
);
}
err.span_label(sp, format!("impl has extra requirement {}", requirement));

21
compiler/rustc_lint/src/builtin.rs
View File

@ -551,7 +551,6 @@ impl MissingDoc {
&self,
cx: &LateContext<'_>,
def_id: LocalDefId,
sp: Span,
article: &'static str,
desc: &'static str,
) {
@ -610,13 +609,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
}
fn check_crate(&mut self, cx: &LateContext<'_>) {
self.check_missing_docs_attrs(
cx,
CRATE_DEF_ID,
cx.tcx.def_span(CRATE_DEF_ID),
"the",
"crate",
);
self.check_missing_docs_attrs(cx, CRATE_DEF_ID, "the", "crate");
}
fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) {
@ -646,13 +639,13 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
let (article, desc) = cx.tcx.article_and_description(it.def_id.to_def_id());
self.check_missing_docs_attrs(cx, it.def_id, it.span, article, desc);
self.check_missing_docs_attrs(cx, it.def_id, article, desc);
}
fn check_trait_item(&mut self, cx: &LateContext<'_>, trait_item: &hir::TraitItem<'_>) {
let (article, desc) = cx.tcx.article_and_description(trait_item.def_id.to_def_id());
self.check_missing_docs_attrs(cx, trait_item.def_id, trait_item.span, article, desc);
self.check_missing_docs_attrs(cx, trait_item.def_id, article, desc);
}
fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
@ -680,23 +673,23 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc {
}
let (article, desc) = cx.tcx.article_and_description(impl_item.def_id.to_def_id());
self.check_missing_docs_attrs(cx, impl_item.def_id, impl_item.span, article, desc);
self.check_missing_docs_attrs(cx, impl_item.def_id, article, desc);
}
fn check_foreign_item(&mut self, cx: &LateContext<'_>, foreign_item: &hir::ForeignItem<'_>) {
let (article, desc) = cx.tcx.article_and_description(foreign_item.def_id.to_def_id());
self.check_missing_docs_attrs(cx, foreign_item.def_id, foreign_item.span, article, desc);
self.check_missing_docs_attrs(cx, foreign_item.def_id, article, desc);
}
fn check_field_def(&mut self, cx: &LateContext<'_>, sf: &hir::FieldDef<'_>) {
if !sf.is_positional() {
let def_id = cx.tcx.hir().local_def_id(sf.hir_id);
self.check_missing_docs_attrs(cx, def_id, sf.span, "a", "struct field")
self.check_missing_docs_attrs(cx, def_id, "a", "struct field")
}
}
fn check_variant(&mut self, cx: &LateContext<'_>, v: &hir::Variant<'_>) {
self.check_missing_docs_attrs(cx, cx.tcx.hir().local_def_id(v.id), v.span, "a", "variant");
self.check_missing_docs_attrs(cx, cx.tcx.hir().local_def_id(v.id), "a", "variant");
}
}

2
compiler/rustc_middle/src/ty/error.rs
View File

@ -795,7 +795,7 @@ fn foo(&self) -> Self::T { String::new() }
if item_def_id == proj_ty_item_def_id =>
{
Some((
self.sess.source_map().guess_head_span(self.def_span(item.def_id)),
self.def_span(item.def_id),
format!("consider calling `{}`", self.def_path_str(item.def_id)),
))
}

20
compiler/rustc_trait_selection/src/traits/error_reporting/mod.rs
View File

@ -1112,18 +1112,12 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
})
.collect::<Option<Vec<ArgKind>>>()?,
),
Node::Item(&hir::Item { span, kind: hir::ItemKind::Fn(ref sig, ..), .. })
| Node::ImplItem(&hir::ImplItem {
span,
kind: hir::ImplItemKind::Fn(ref sig, _),
..
})
Node::Item(&hir::Item { kind: hir::ItemKind::Fn(ref sig, ..), .. })
| Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(ref sig, _), .. })
| Node::TraitItem(&hir::TraitItem {
span,
kind: hir::TraitItemKind::Fn(ref sig, _),
..
kind: hir::TraitItemKind::Fn(ref sig, _), ..
}) => (
sm.guess_head_span(span),
sig.span,
sig.decl
.inputs
.iter()
@ -1138,7 +1132,6 @@ impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
),
Node::Ctor(ref variant_data) => {
let span = variant_data.ctor_hir_id().map_or(DUMMY_SP, |id| hir.span(id));
let span = sm.guess_head_span(span);
(span, vec![ArgKind::empty(); variant_data.fields().len()])
}
_ => panic!("non-FnLike node found: {:?}", node),
@ -2185,7 +2178,7 @@ impl<'a, 'tcx> InferCtxtPrivExt<'a, 'tcx> for InferCtxt<'a, 'tcx> {
let mut post = vec![];
for def_id in impls {
match self.tcx.span_of_impl(*def_id) {
Ok(span) => spans.push(self.tcx.sess.source_map().guess_head_span(span)),
Ok(span) => spans.push(span),
Err(name) => {
crates.push(name);
if let Some(header) = to_pretty_impl_header(self.tcx, *def_id) {
@ -2532,8 +2525,7 @@ pub fn recursive_type_with_infinite_size_error<'tcx>(
spans: Vec<(Span, Option<hir::HirId>)>,
) {
assert!(type_def_id.is_local());
let span = tcx.hir().span_if_local(type_def_id).unwrap();
let span = tcx.sess.source_map().guess_head_span(span);
let span = tcx.def_span(type_def_id);
let path = tcx.def_path_str(type_def_id);
let mut err =
struct_span_err!(tcx.sess, span, E0072, "recursive type `{}` has infinite size", path);

23
compiler/rustc_trait_selection/src/traits/specialize/mod.rs
View File

@ -341,10 +341,7 @@ fn report_negative_positive_conflict(
positive_impl_def_id: DefId,
sg: &mut specialization_graph::Graph,
) {
let impl_span = tcx
.sess
.source_map()
.guess_head_span(tcx.span_of_impl(local_impl_def_id.to_def_id()).unwrap());
let impl_span = tcx.span_of_impl(local_impl_def_id.to_def_id()).unwrap();
let mut err = struct_span_err!(
tcx.sess,
@ -357,10 +354,7 @@ fn report_negative_positive_conflict(
match tcx.span_of_impl(negative_impl_def_id) {
Ok(span) => {
err.span_label(
tcx.sess.source_map().guess_head_span(span),
"negative implementation here".to_string(),
);
err.span_label(span, "negative implementation here");
}
Err(cname) => {
err.note(&format!("negative implementation in crate `{}`", cname));
@ -369,10 +363,7 @@ fn report_negative_positive_conflict(
match tcx.span_of_impl(positive_impl_def_id) {
Ok(span) => {
err.span_label(
tcx.sess.source_map().guess_head_span(span),
"positive implementation here".to_string(),
);
err.span_label(span, "positive implementation here");
}
Err(cname) => {
err.note(&format!("positive implementation in crate `{}`", cname));
@ -389,8 +380,7 @@ fn report_conflicting_impls(
used_to_be_allowed: Option<FutureCompatOverlapErrorKind>,
sg: &mut specialization_graph::Graph,
) {
let impl_span =
tcx.sess.source_map().guess_head_span(tcx.span_of_impl(impl_def_id.to_def_id()).unwrap());
let impl_span = tcx.def_span(impl_def_id);
// Work to be done after we've built the DiagnosticBuilder. We have to define it
// now because the struct_lint methods don't return back the DiagnosticBuilder
@ -417,10 +407,7 @@ fn report_conflicting_impls(
let mut err = err.build(&msg);
match tcx.span_of_impl(overlap.with_impl) {
Ok(span) => {
err.span_label(
tcx.sess.source_map().guess_head_span(span),
"first implementation here".to_string(),
);
err.span_label(span, "first implementation here".to_string());
err.span_label(
impl_span,

9
compiler/rustc_typeck/src/astconv/mod.rs
View File

@ -1958,9 +1958,11 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
);
}
if let Some(sp) = tcx.hir().span_if_local(adt_def.did()) {
let sp = tcx.sess.source_map().guess_head_span(sp);
err.span_label(sp, format!("variant `{}` not found here", assoc_ident));
if adt_def.did().is_local() {
err.span_label(
tcx.def_span(adt_def.did()),
format!("variant `{assoc_ident}` not found for this enum"),
);
}
err.emit()
@ -2450,7 +2452,6 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let msg = format!("`Self` is of type `{ty}`");
if let (Ok(i_sp), Some(t_sp)) = (span_of_impl, span_of_ty) {
let i_sp = tcx.sess.source_map().guess_head_span(i_sp);
let mut span: MultiSpan = vec![t_sp].into();
span.push_span_label(
i_sp,

20
compiler/rustc_typeck/src/check/check.rs
View File

@ -288,11 +288,9 @@ fn check_panic_info_fn(
tcx.sess.span_err(decl.output.span(), "return type should be `!`");
}
let span = tcx.def_span(fn_id);
let inputs = fn_sig.inputs();
if inputs.len() != 1 {
let span = tcx.sess.source_map().guess_head_span(span);
tcx.sess.span_err(span, "function should have one argument");
tcx.sess.span_err(tcx.def_span(fn_id), "function should have one argument");
return;
}
@ -345,9 +343,7 @@ fn check_alloc_error_fn(
let inputs = fn_sig.inputs();
if inputs.len() != 1 {
let span = tcx.def_span(fn_id);
let span = tcx.sess.source_map().guess_head_span(span);
tcx.sess.span_err(span, "function should have one argument");
tcx.sess.span_err(tcx.def_span(fn_id), "function should have one argument");
return;
}
@ -1034,7 +1030,6 @@ fn check_impl_items_against_trait<'tcx>(
compare_impl_method(
tcx,
&ty_impl_item,
impl_item.span,
&ty_trait_item,
impl_trait_ref,
opt_trait_span,
@ -1094,17 +1089,20 @@ fn check_impl_items_against_trait<'tcx>(
}
if !missing_items.is_empty() {
let impl_span = tcx.sess.source_map().guess_head_span(full_impl_span);
missing_items_err(tcx, impl_span, &missing_items, full_impl_span);
missing_items_err(tcx, tcx.def_span(impl_id), &missing_items, full_impl_span);
}
if let Some(missing_items) = must_implement_one_of {
let impl_span = tcx.sess.source_map().guess_head_span(full_impl_span);
let attr_span = tcx
.get_attr(impl_trait_ref.def_id, sym::rustc_must_implement_one_of)
.map(|attr| attr.span);
missing_items_must_implement_one_of_err(tcx, impl_span, missing_items, attr_span);
missing_items_must_implement_one_of_err(
tcx,
tcx.def_span(impl_id),
missing_items,
attr_span,
);
}
}
}

16
compiler/rustc_typeck/src/check/compare_method.rs
View File

@ -33,14 +33,13 @@ use super::{potentially_plural_count, FnCtxt, Inherited};
pub(crate) fn compare_impl_method<'tcx>(
tcx: TyCtxt<'tcx>,
impl_m: &ty::AssocItem,
impl_m_span: Span,
trait_m: &ty::AssocItem,
impl_trait_ref: ty::TraitRef<'tcx>,
trait_item_span: Option<Span>,
) {
debug!("compare_impl_method(impl_trait_ref={:?})", impl_trait_ref);
let impl_m_span = tcx.sess.source_map().guess_head_span(impl_m_span);
let impl_m_span = tcx.def_span(impl_m.def_id);
if let Err(_) = compare_self_type(tcx, impl_m, impl_m_span, trait_m, impl_trait_ref) {
return;
@ -444,13 +443,9 @@ fn check_region_bounds_on_impl_item<'tcx>(
.as_local()
.and_then(|did| tcx.hir().get_generics(did))
.map_or(def_span, |g| g.span);
let generics_span = tcx.hir().span_if_local(trait_m.def_id).map(|sp| {
let def_sp = tcx.sess.source_map().guess_head_span(sp);
trait_m
.def_id
.as_local()
.and_then(|did| tcx.hir().get_generics(did))
.map_or(def_sp, |g| g.span)
let generics_span = trait_m.def_id.as_local().map(|did| {
let def_sp = tcx.def_span(did);
tcx.hir().get_generics(did).map_or(def_sp, |g| g.span)
});
let reported = tcx.sess.emit_err(LifetimesOrBoundsMismatchOnTrait {
@ -1044,8 +1039,7 @@ fn compare_generic_param_kinds<'tcx>(
err.span_label(trait_header_span, "");
err.span_label(param_trait_span, make_param_message("expected", param_trait));
let impl_header_span =
tcx.sess.source_map().guess_head_span(tcx.def_span(tcx.parent(impl_item.def_id)));
let impl_header_span = tcx.def_span(tcx.parent(impl_item.def_id));
err.span_label(impl_header_span, "");
err.span_label(param_impl_span, make_param_message("found", param_impl));

5
compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs
View File

@ -184,9 +184,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
} else if let (ty::FnDef(def_id, ..), true) =
(&found.kind(), self.suggest_fn_call(err, expr, expected, found))
{
if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
let sp = self.sess().source_map().guess_head_span(sp);
err.span_label(sp, &format!("{} defined here", found));
if def_id.is_local() {
err.span_label(self.tcx.def_span(def_id), &format!("{} defined here", found));
}
} else if !self.check_for_cast(err, expr, found, expected, expected_ty_expr) {
let is_struct_pat_shorthand_field =

52
compiler/rustc_typeck/src/check/method/suggest.rs
View File

@ -121,11 +121,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}) else {
continue;
};
let note_span = self
.tcx
.hir()
.span_if_local(item.def_id)
.or_else(|| self.tcx.hir().span_if_local(impl_did));
let note_span = if item.def_id.is_local() {
Some(self.tcx.def_span(item.def_id))
} else if impl_did.is_local() {
Some(self.tcx.def_span(impl_did))
} else {
None
};
let impl_ty = self.tcx.at(span).type_of(impl_did);
@ -158,10 +161,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
};
if let Some(note_span) = note_span {
// We have a span pointing to the method. Show note with snippet.
err.span_note(
self.tcx.sess.source_map().guess_head_span(note_span),
&note_str,
);
err.span_note(note_span, &note_str);
} else {
err.note(&note_str);
}
@ -197,11 +197,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
CandidateSource::Trait(trait_did) => {
let Some(item) = self.associated_value(trait_did, item_name) else { continue };
let item_span = self
.tcx
.sess
.source_map()
.guess_head_span(self.tcx.def_span(item.def_id));
let item_span = self.tcx.def_span(item.def_id);
let idx = if sources.len() > 1 {
let msg = &format!(
"candidate #{} is defined in the trait `{}`",
@ -471,9 +467,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
err.note(&format!("`count` is defined on `{iterator_trait}`, which `{actual}` does not implement"));
}
} else if !unsatisfied_predicates.is_empty() {
let def_span = |def_id| {
self.tcx.sess.source_map().guess_head_span(self.tcx.def_span(def_id))
};
let mut type_params = FxHashMap::default();
// Pick out the list of unimplemented traits on the receiver.
@ -564,22 +557,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
);
match &self_ty.kind() {
// Point at the type that couldn't satisfy the bound.
ty::Adt(def, _) => bound_spans.push((def_span(def.did()), msg)),
ty::Adt(def, _) => {
bound_spans.push((self.tcx.def_span(def.did()), msg))
}
// Point at the trait object that couldn't satisfy the bound.
ty::Dynamic(preds, _) => {
for pred in preds.iter() {
match pred.skip_binder() {
ty::ExistentialPredicate::Trait(tr) => {
bound_spans.push((def_span(tr.def_id), msg.clone()))
}
ty::ExistentialPredicate::Trait(tr) => bound_spans
.push((self.tcx.def_span(tr.def_id), msg.clone())),
ty::ExistentialPredicate::Projection(_)
| ty::ExistentialPredicate::AutoTrait(_) => {}
}
}
}
// Point at the closure that couldn't satisfy the bound.
ty::Closure(def_id, _) => bound_spans
.push((def_span(*def_id), format!("doesn't satisfy `{}`", quiet))),
ty::Closure(def_id, _) => bound_spans.push((
tcx.def_span(*def_id),
format!("doesn't satisfy `{}`", quiet),
)),
_ => {}
}
};
@ -1469,21 +1465,20 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
_ => None,
})
.collect::<FxHashSet<_>>();
let sm = self.tcx.sess.source_map();
let mut spans: MultiSpan = def_ids
.iter()
.filter_map(|def_id| {
let span = self.tcx.def_span(*def_id);
if span.is_dummy() { None } else { Some(sm.guess_head_span(span)) }
if span.is_dummy() { None } else { Some(span) }
})
.collect::<Vec<_>>()
.into();
for pred in &preds {
match pred.self_ty().kind() {
ty::Adt(def, _) => {
ty::Adt(def, _) if def.did().is_local() => {
spans.push_span_label(
sm.guess_head_span(self.tcx.def_span(def.did())),
self.tcx.def_span(def.did()),
format!("must implement `{}`", pred.trait_ref.print_only_trait_path()),
);
}
@ -2090,9 +2085,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
match &potential_candidates[..] {
[] => {}
[trait_info] if trait_info.def_id.is_local() => {
let span = self.tcx.hir().span_if_local(trait_info.def_id).unwrap();
err.span_note(
self.tcx.sess.source_map().guess_head_span(span),
self.tcx.def_span(trait_info.def_id),
&format!(
"`{}` defines an item `{}`, perhaps you need to {} it",
self.tcx.def_path_str(trait_info.def_id),

41
compiler/rustc_typeck/src/coherence/mod.rs
View File

@ -9,7 +9,6 @@ use rustc_errors::struct_span_err;
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_middle::ty::query::Providers;
use rustc_middle::ty::{self, TyCtxt, TypeVisitable};
use rustc_span::Span;
use rustc_trait_selection::traits;
mod builtin;
@ -18,11 +17,6 @@ mod inherent_impls_overlap;
mod orphan;
mod unsafety;
/// Obtains the span of just the impl header of `impl_def_id`.
fn impl_header_span(tcx: TyCtxt<'_>, impl_def_id: LocalDefId) -> Span {
tcx.sess.source_map().guess_head_span(tcx.span_of_impl(impl_def_id.to_def_id()).unwrap())
}
fn check_impl(tcx: TyCtxt<'_>, impl_def_id: LocalDefId, trait_ref: ty::TraitRef<'_>) {
debug!(
"(checking implementation) adding impl for trait '{:?}', item '{}'",
@ -47,56 +41,53 @@ fn enforce_trait_manually_implementable(
) {
let did = Some(trait_def_id);
let li = tcx.lang_items();
let impl_header_span = tcx.def_span(impl_def_id);
// Disallow *all* explicit impls of `Pointee`, `DiscriminantKind`, `Sized` and `Unsize` for now.
if did == li.pointee_trait() {
let span = impl_header_span(tcx, impl_def_id);
struct_span_err!(
tcx.sess,
span,
impl_header_span,
E0322,
"explicit impls for the `Pointee` trait are not permitted"
)
.span_label(span, "impl of `Pointee` not allowed")
.span_label(impl_header_span, "impl of `Pointee` not allowed")
.emit();
return;
}
if did == li.discriminant_kind_trait() {
let span = impl_header_span(tcx, impl_def_id);
struct_span_err!(
tcx.sess,
span,
impl_header_span,
E0322,
"explicit impls for the `DiscriminantKind` trait are not permitted"
)
.span_label(span, "impl of `DiscriminantKind` not allowed")
.span_label(impl_header_span, "impl of `DiscriminantKind` not allowed")
.emit();
return;
}
if did == li.sized_trait() {
let span = impl_header_span(tcx, impl_def_id);
struct_span_err!(
tcx.sess,
span,
impl_header_span,
E0322,
"explicit impls for the `Sized` trait are not permitted"
)
.span_label(span, "impl of `Sized` not allowed")
.span_label(impl_header_span, "impl of `Sized` not allowed")
.emit();
return;
}
if did == li.unsize_trait() {
let span = impl_header_span(tcx, impl_def_id);
struct_span_err!(
tcx.sess,
span,
impl_header_span,
E0328,
"explicit impls for the `Unsize` trait are not permitted"
)
.span_label(span, "impl of `Unsize` not allowed")
.span_label(impl_header_span, "impl of `Unsize` not allowed")
.emit();
return;
}
@ -110,10 +101,9 @@ fn enforce_trait_manually_implementable(
tcx.trait_def(trait_def_id).specialization_kind
{
if !tcx.features().specialization && !tcx.features().min_specialization {
let span = impl_header_span(tcx, impl_def_id);
tcx.sess
.struct_span_err(
span,
impl_header_span,
"implementing `rustc_specialization_trait` traits is unstable",
)
.help("add `#![feature(min_specialization)]` to the crate attributes to enable")
@ -138,8 +128,13 @@ fn enforce_empty_impls_for_marker_traits(
return;
}
let span = impl_header_span(tcx, impl_def_id);
struct_span_err!(tcx.sess, span, E0715, "impls for marker traits cannot contain items").emit();
struct_span_err!(
tcx.sess,
tcx.def_span(impl_def_id),
E0715,
"impls for marker traits cannot contain items"
)
.emit();
}
pub fn provide(providers: &mut Providers) {
@ -217,7 +212,7 @@ fn check_object_overlap<'tcx>(
} else {
let mut supertrait_def_ids = traits::supertrait_def_ids(tcx, component_def_id);
if supertrait_def_ids.any(|d| d == trait_def_id) {
let span = impl_header_span(tcx, impl_def_id);
let span = tcx.def_span(impl_def_id);
struct_span_err!(
tcx.sess,
span,

2
compiler/rustc_typeck/src/coherence/orphan.rs
View File

@ -47,7 +47,7 @@ fn do_orphan_check_impl<'tcx>(
let hir::ItemKind::Impl(ref impl_) = item.kind else {
bug!("{:?} is not an impl: {:?}", def_id, item);
};
let sp = tcx.sess.source_map().guess_head_span(item.span);
let sp = tcx.def_span(def_id);
let tr = impl_.of_trait.as_ref().unwrap();
// Ensure no opaque types are present in this impl header. See issues #76202 and #86411 for examples,

12
compiler/rustc_typeck/src/lib.rs
View File

@ -223,15 +223,7 @@ fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: DefId) {
if !def_id.is_local() {
return None;
}
let hir_id = tcx.hir().local_def_id_to_hir_id(def_id.expect_local());
match tcx.hir().find(hir_id) {
Some(Node::Item(hir::Item { span: item_span, .. })) => {
Some(tcx.sess.source_map().guess_head_span(*item_span))
}
_ => {
span_bug!(tcx.def_span(def_id), "main has a non-function type");
}
}
Some(tcx.def_span(def_id))
}
fn main_fn_return_type_span(tcx: TyCtxt<'_>, def_id: DefId) -> Option<Span> {
@ -416,7 +408,7 @@ fn check_start_fn_ty(tcx: TyCtxt<'_>, start_def_id: DefId) {
error = true;
}
if let hir::IsAsync::Async = sig.header.asyncness {
let span = tcx.sess.source_map().guess_head_span(it.span);
let span = tcx.def_span(it.def_id);
struct_span_err!(
tcx.sess,
span,

2
src/test/rustdoc-ui/deny-missing-docs-crate.stderr
View File

@ -16,7 +16,7 @@ error: missing documentation for a struct
--> $DIR/deny-missing-docs-crate.rs:3:1
|
LL | pub struct Foo;
| ^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^
error: aborting due to 2 previous errors

2
src/test/ui/issues/issue-34209.stderr
View File

@ -2,7 +2,7 @@ error[E0599]: no variant named `B` found for enum `S`
--> $DIR/issue-34209.rs:7:12
|
LL | enum S {
| ------ variant `B` not found here
| ------ variant `B` not found for this enum
...
LL | S::B {} => {},
| ^ help: there is a variant with a similar name: `A`

9
src/test/ui/issues/issue-37884.stderr
View File

@ -1,13 +1,8 @@
error[E0308]: method not compatible with trait
--> $DIR/issue-37884.rs:6:5
|
LL | / fn next(&'a mut self) -> Option<Self::Item>
LL | |
LL | |
LL | | {
LL | | Some(&mut self.0)
LL | | }
| |_____^ lifetime mismatch
LL | fn next(&'a mut self) -> Option<Self::Item>
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ lifetime mismatch
|
= note: expected fn pointer `fn(&mut RepeatMut<'a, T>) -> Option<_>`
found fn pointer `fn(&'a mut RepeatMut<'a, T>) -> Option<_>`

2
src/test/ui/issues/issue-77919.stderr
View File

@ -24,7 +24,7 @@ LL | const VAL: T;
| ------------ `VAL` from trait
...
LL | impl<N, M> TypeVal<usize> for Multiply<N, M> where N: TypeVal<VAL> {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `VAL` in implementation
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `VAL` in implementation
error: constant expression depends on a generic parameter
--> $DIR/issue-77919.rs:2:9

16
src/test/ui/lint/lint-missing-doc.stderr
View File

@ -2,7 +2,7 @@ error: missing documentation for a type alias
--> $DIR/lint-missing-doc.rs:11:1
|
LL | pub type PubTypedef = String;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^
|
note: the lint level is defined here
--> $DIR/lint-missing-doc.rs:3:9
@ -56,13 +56,13 @@ error: missing documentation for an associated type
--> $DIR/lint-missing-doc.rs:64:5
|
LL | type AssociatedType;
| ^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^
error: missing documentation for an associated type
--> $DIR/lint-missing-doc.rs:65:5
|
LL | type AssociatedTypeDef = Self;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^
error: missing documentation for an associated function
--> $DIR/lint-missing-doc.rs:81:5
@ -92,13 +92,13 @@ error: missing documentation for a constant
--> $DIR/lint-missing-doc.rs:151:1
|
LL | pub const FOO4: u32 = 0;
| ^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^
error: missing documentation for a static
--> $DIR/lint-missing-doc.rs:161:1
|
LL | pub static BAR4: u32 = 0;
| ^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^
error: missing documentation for a function
--> $DIR/lint-missing-doc.rs:167:5
@ -122,19 +122,19 @@ error: missing documentation for a function
--> $DIR/lint-missing-doc.rs:189:5
|
LL | pub fn extern_fn_undocumented(f: f32) -> f32;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: missing documentation for a static
--> $DIR/lint-missing-doc.rs:194:5
|
LL | pub static EXTERN_STATIC_UNDOCUMENTED: u8;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: missing documentation for a foreign type
--> $DIR/lint-missing-doc.rs:199:5
|
LL | pub type ExternTyUndocumented;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: aborting due to 22 previous errors

0
src/test/ui/parenthesized-deref-suggestion.rs → src/test/ui/suggestions/parenthesized-deref-suggestion.rs
View File

0
src/test/ui/parenthesized-deref-suggestion.stderr → src/test/ui/suggestions/parenthesized-deref-suggestion.stderr
View File

6
src/test/ui/suggestions/suggest-variants.stderr
View File

@ -2,7 +2,7 @@ error[E0599]: no variant named `Squareee` found for enum `Shape`
--> $DIR/suggest-variants.rs:12:41
|
LL | enum Shape {
| ---------- variant `Squareee` not found here
| ---------- variant `Squareee` not found for this enum
...
LL | println!("My shape is {:?}", Shape::Squareee { size: 5});
| ^^^^^^^^ help: there is a variant with a similar name: `Square`
@ -11,7 +11,7 @@ error[E0599]: no variant named `Circl` found for enum `Shape`
--> $DIR/suggest-variants.rs:13:41
|
LL | enum Shape {
| ---------- variant `Circl` not found here
| ---------- variant `Circl` not found for this enum
...
LL | println!("My shape is {:?}", Shape::Circl { size: 5});
| ^^^^^ help: there is a variant with a similar name: `Circle`
@ -20,7 +20,7 @@ error[E0599]: no variant named `Rombus` found for enum `Shape`
--> $DIR/suggest-variants.rs:14:41
|
LL | enum Shape {
| ---------- variant `Rombus` not found here
| ---------- variant `Rombus` not found for this enum
...
LL | println!("My shape is {:?}", Shape::Rombus{ size: 5});
| ^^^^^^ variant not found in `Shape`