use rustc_errors::{pluralize, struct_span_err, Diagnostic, ErrorGuaranteed};
use rustc_errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString, MultiSpan};
use rustc_hir as hir;
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::lang_items::LangItem;
use rustc_hir::{Item, ItemKind, Node};
use rustc_middle::dep_graph::DepContext;
///
/// For the following code:
///
- /// ```no_run
+ /// ```ignore (illustrative)
/// let x: Foo<Bar<Qux>> = foo::<Bar<Qux>>();
/// ```
///
/// A possible error is to forget to add `.await` when using futures:
///
- /// ```
+ /// ```compile_fail,E0308
/// async fn make_u32() -> u32 {
/// 22
/// }
err.span_suggestion(
span.with_hi(before_close).shrink_to_hi(),
msg,
- ",".into(),
+ ",",
Applicability::MachineApplicable,
);
} else {
bound_kind: GenericKind<'tcx>,
sub: Region<'tcx>,
) {
- self.construct_generic_bound_failure(span, origin, bound_kind, sub).emit();
+ let owner =
+ self.in_progress_typeck_results.map(|typeck_results| typeck_results.borrow().hir_owner);
+ self.construct_generic_bound_failure(span, origin, bound_kind, sub, owner).emit();
}
pub fn construct_generic_bound_failure(
origin: Option<SubregionOrigin<'tcx>>,
bound_kind: GenericKind<'tcx>,
sub: Region<'tcx>,
+ owner: Option<LocalDefId>,
) -> DiagnosticBuilder<'a, ErrorGuaranteed> {
let hir = self.tcx.hir();
// Attempt to obtain the span of the parameter so we can
// suggest adding an explicit lifetime bound to it.
- let generics = self
- .in_progress_typeck_results
- .map(|typeck_results| typeck_results.borrow().hir_owner)
- .map(|owner| {
- let hir_id = hir.local_def_id_to_hir_id(owner);
- let parent_id = hir.get_parent_item(hir_id);
- (
- // Parent item could be a `mod`, so we check the HIR before calling:
- if let Some(Node::Item(Item {
- kind: ItemKind::Trait(..) | ItemKind::Impl { .. },
- ..
- })) = hir.find_by_def_id(parent_id)
- {
- Some(self.tcx.generics_of(parent_id))
- } else {
- None
- },
- self.tcx.generics_of(owner.to_def_id()),
- hir.span(hir_id),
- )
- });
+ let generics = owner.map(|owner| {
+ let hir_id = hir.local_def_id_to_hir_id(owner);
+ let parent_id = hir.get_parent_item(hir_id);
+ (
+ // Parent item could be a `mod`, so we check the HIR before calling:
+ if let Some(Node::Item(Item {
+ kind: ItemKind::Trait(..) | ItemKind::Impl { .. },
+ ..
+ })) = hir.find_by_def_id(parent_id)
+ {
+ Some(self.tcx.generics_of(parent_id))
+ } else {
+ None
+ },
+ self.tcx.generics_of(owner.to_def_id()),
+ hir.span(hir_id),
+ )
+ });
let span = match generics {
// This is to get around the trait identity obligation, that has a `DUMMY_SP` as signal
_ => span,
};
+ // type_param_span is (span, has_bounds)
let type_param_span = match (generics, bound_kind) {
(Some((_, ref generics, _)), GenericKind::Param(ref param)) => {
// Account for the case where `param` corresponds to `Self`,
// Get the `hir::Param` to verify whether it already has any bounds.
// We do this to avoid suggesting code that ends up as `T: 'a'b`,
// instead we suggest `T: 'a + 'b` in that case.
- let id = hir.local_def_id_to_hir_id(def_id);
- let mut has_bounds = false;
- if let Node::GenericParam(param) = hir.get(id) {
- has_bounds = !param.bounds.is_empty();
- }
- let sp = self.tcx.def_span(def_id);
+ let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id);
+ let ast_generics = self.tcx.hir().get_generics(hir_id.owner);
+ let bounds =
+ ast_generics.and_then(|g| g.bounds_span_for_suggestions(def_id));
// `sp` only covers `T`, change it so that it covers
// `T:` when appropriate
- let is_impl_trait = bound_kind.to_string().starts_with("impl ");
- let sp = if has_bounds && !is_impl_trait {
- sp.to(self
- .tcx
- .sess
- .source_map()
- .next_point(self.tcx.sess.source_map().next_point(sp)))
+ if let Some(span) = bounds {
+ (span, true)
} else {
- sp
- };
- (sp, has_bounds, is_impl_trait)
+ let sp = self.tcx.def_span(def_id);
+ (sp.shrink_to_hi(), false)
+ }
})
} else {
None
fn binding_suggestion<'tcx, S: fmt::Display>(
err: &mut Diagnostic,
- type_param_span: Option<(Span, bool, bool)>,
+ type_param_span: Option<(Span, bool)>,
bound_kind: GenericKind<'tcx>,
sub: S,
) {
let msg = "consider adding an explicit lifetime bound";
- if let Some((sp, has_lifetimes, is_impl_trait)) = type_param_span {
- let suggestion = if is_impl_trait {
- format!("{} + {}", bound_kind, sub)
- } else {
- let tail = if has_lifetimes { " + " } else { "" };
- format!("{}: {}{}", bound_kind, sub, tail)
- };
- err.span_suggestion(
+ if let Some((sp, has_lifetimes)) = type_param_span {
+ let suggestion =
+ if has_lifetimes { format!(" + {}", sub) } else { format!(": {}", sub) };
+ err.span_suggestion_verbose(
sp,
&format!("{}...", msg),
suggestion,
Applicability::MaybeIncorrect, // Issue #41966
);
} else {
- let consider = format!(
- "{} {}...",
- msg,
- if type_param_span.map_or(false, |(_, _, is_impl_trait)| is_impl_trait) {
- format!(" `{}` to `{}`", sub, bound_kind)
- } else {
- format!("`{}: {}`", bound_kind, sub)
- },
- );
+ let consider = format!("{} `{}: {}`...", msg, bound_kind, sub,);
err.help(&consider);
}
}
let new_binding_suggestion =
- |err: &mut Diagnostic,
- type_param_span: Option<(Span, bool, bool)>,
- bound_kind: GenericKind<'tcx>| {
+ |err: &mut Diagnostic, type_param_span: Option<(Span, bool)>| {
let msg = "consider introducing an explicit lifetime bound";
- if let Some((sp, has_lifetimes, is_impl_trait)) = type_param_span {
- let suggestion = if is_impl_trait {
- (sp.shrink_to_hi(), format!(" + {}", new_lt))
+ if let Some((sp, has_lifetimes)) = type_param_span {
+ let suggestion = if has_lifetimes {
+ format!(" + {}", new_lt)
} else {
- let tail = if has_lifetimes { " +" } else { "" };
- (sp, format!("{}: {}{}", bound_kind, new_lt, tail))
+ format!(": {}", new_lt)
};
let mut sugg =
- vec![suggestion, (span.shrink_to_hi(), format!(" + {}", new_lt))];
+ vec![(sp, suggestion), (span.shrink_to_hi(), format!(" + {}", new_lt))];
if let Some(lt) = add_lt_sugg {
sugg.push(lt);
sugg.rotate_right(1);
let pred = format!("{}: {}", bound_kind, sub);
let suggestion = format!(
"{} {}",
- if !generics.where_clause.predicates.is_empty() { "," } else { " where" },
+ if !generics.predicates.is_empty() { "," } else { " where" },
pred,
);
err.span_suggestion(
- generics.where_clause.tail_span_for_suggestion(),
+ generics.tail_span_for_predicate_suggestion(),
"consider adding a where clause",
suggestion,
Applicability::MaybeIncorrect,
None,
);
if let Some(infer::RelateParamBound(_, t, _)) = origin {
- let return_impl_trait = self
- .in_progress_typeck_results
- .map(|typeck_results| typeck_results.borrow().hir_owner)
- .and_then(|owner| self.tcx.return_type_impl_trait(owner))
- .is_some();
+ let return_impl_trait =
+ owner.and_then(|owner| self.tcx.return_type_impl_trait(owner)).is_some();
let t = self.resolve_vars_if_possible(t);
match t.kind() {
// We've got:
// suggest:
// fn get_later<'a, G: 'a, T>(g: G, dest: &mut T) -> impl FnOnce() + '_ + 'a
ty::Closure(_, _substs) | ty::Opaque(_, _substs) if return_impl_trait => {
- new_binding_suggestion(&mut err, type_param_span, bound_kind);
+ new_binding_suggestion(&mut err, type_param_span);
}
_ => {
binding_suggestion(&mut err, type_param_span, bound_kind, new_lt);
projects / rust.git / blobdiff