fn suggest_restricting_param_bound(
&self,
err: &mut DiagnosticBuilder<'_>,
- trait_ref: ty::PolyTraitRef<'tcx>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
body_id: hir::HirId,
);
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'tcx>,
- trait_ref: ty::PolyTraitRef<'tcx>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
);
fn get_closure_name(
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
);
fn suggest_add_reference_to_arg(
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
- trait_ref: &ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
has_custom_message: bool,
) -> bool;
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
);
fn suggest_remove_await(
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
);
fn suggest_semicolon_removal(
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
span: Span,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
);
fn return_type_span(&self, obligation: &PredicateObligation<'tcx>) -> Option<Span>;
err: &mut DiagnosticBuilder<'_>,
span: Span,
obligation: &PredicateObligation<'tcx>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
) -> bool;
fn point_at_returns_when_relevant(
interior_extra_info: Option<(Option<Span>, Span, Option<hir::HirId>, Option<Span>)>,
inner_generator_body: Option<&hir::Body<'tcx>>,
outer_generator: Option<DefId>,
- trait_ref: ty::TraitRef<'tcx>,
+ trait_pred: ty::TraitPredicate<'tcx>,
target_ty: Ty<'tcx>,
typeck_results: Option<&ty::TypeckResults<'tcx>>,
obligation: &PredicateObligation<'tcx>,
&self,
err: &mut DiagnosticBuilder<'_>,
predicate: &T,
+ param_env: ty::ParamEnv<'tcx>,
cause_code: &ObligationCauseCode<'tcx>,
- obligated_types: &mut Vec<&ty::TyS<'tcx>>,
+ obligated_types: &mut Vec<Ty<'tcx>>,
seen_requirements: &mut FxHashSet<DefId>,
) where
T: fmt::Display;
&self,
err: &mut DiagnosticBuilder<'_>,
obligation: &PredicateObligation<'tcx>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
span: Span,
);
}
err: &mut DiagnosticBuilder<'_>,
fn_sig: Option<&hir::FnSig<'_>>,
projection: Option<&ty::ProjectionTy<'_>>,
- trait_ref: ty::PolyTraitRef<'tcx>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
super_traits: Option<(&Ident, &hir::GenericBounds<'_>)>,
) {
// When we are dealing with a trait, `super_traits` will be `Some`:
// The type param `T: Trait` we will suggest to introduce.
let type_param = format!("{}: {}", type_param_name, bound_str);
- // FIXME: modify the `trait_ref` instead of string shenanigans.
+ // FIXME: modify the `trait_pred` instead of string shenanigans.
// Turn `<impl Trait as Foo>::Bar: Qux` into `<T as Foo>::Bar: Qux`.
- let pred = trait_ref.without_const().to_predicate(tcx).to_string();
+ let pred = trait_pred.to_predicate(tcx).to_string();
let pred = pred.replace(&impl_trait_str, &type_param_name);
let mut sugg = vec![
// Find the last of the generic parameters contained within the span of
.find(|p| !matches!(p.kind, hir::GenericParamKind::Type { synthetic: true, .. })),
super_traits,
) {
- (_, None) => predicate_constraint(
- generics,
- trait_ref.without_const().to_predicate(tcx).to_string(),
+ (_, None) => predicate_constraint(generics, trait_pred.to_predicate(tcx).to_string()),
+ (None, Some((ident, []))) => (
+ ident.span.shrink_to_hi(),
+ format!(": {}", trait_pred.print_modifiers_and_trait_path()),
+ ),
+ (_, Some((_, [.., bounds]))) => (
+ bounds.span().shrink_to_hi(),
+ format!(" + {}", trait_pred.print_modifiers_and_trait_path()),
+ ),
+ (Some(_), Some((_, []))) => (
+ generics.span.shrink_to_hi(),
+ format!(": {}", trait_pred.print_modifiers_and_trait_path()),
),
- (None, Some((ident, []))) => {
- (ident.span.shrink_to_hi(), format!(": {}", trait_ref.print_only_trait_path()))
- }
- (_, Some((_, [.., bounds]))) => {
- (bounds.span().shrink_to_hi(), format!(" + {}", trait_ref.print_only_trait_path()))
- }
- (Some(_), Some((_, []))) => {
- (generics.span.shrink_to_hi(), format!(": {}", trait_ref.print_only_trait_path()))
- }
};
err.span_suggestion_verbose(
fn suggest_restricting_param_bound(
&self,
mut err: &mut DiagnosticBuilder<'_>,
- trait_ref: ty::PolyTraitRef<'tcx>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
body_id: hir::HirId,
) {
- let self_ty = trait_ref.skip_binder().self_ty();
+ let self_ty = trait_pred.skip_binder().self_ty();
let (param_ty, projection) = match self_ty.kind() {
ty::Param(_) => (true, None),
ty::Projection(projection) => (false, Some(projection)),
err,
None,
projection,
- trait_ref,
+ trait_pred,
Some((ident, bounds)),
);
return;
assert!(param_ty);
// Restricting `Self` for a single method.
suggest_restriction(
- self.tcx, &generics, "`Self`", err, None, projection, trait_ref, None,
+ self.tcx, &generics, "`Self`", err, None, projection, trait_pred, None,
);
return;
}
err,
Some(fn_sig),
projection,
- trait_ref,
+ trait_pred,
None,
);
return;
err,
None,
projection,
- trait_ref,
+ trait_pred,
None,
);
return;
{
// Missing generic type parameter bound.
let param_name = self_ty.to_string();
- let constraint =
- with_no_trimmed_paths(|| trait_ref.print_only_trait_path().to_string());
+ let constraint = with_no_trimmed_paths(|| {
+ trait_pred.print_modifiers_and_trait_path().to_string()
+ });
if suggest_constraining_type_param(
self.tcx,
generics,
&mut err,
¶m_name,
&constraint,
- Some(trait_ref.def_id()),
+ Some(trait_pred.def_id()),
) {
return;
}
}) if !param_ty => {
// Missing generic type parameter bound.
let param_name = self_ty.to_string();
- let constraint = trait_ref.print_only_trait_path().to_string();
+ let constraint = trait_pred.print_modifiers_and_trait_path().to_string();
if suggest_arbitrary_trait_bound(generics, &mut err, ¶m_name, &constraint) {
return;
}
_ => {}
}
- hir_id = self.tcx.hir().get_parent_item(hir_id);
+ hir_id = self.tcx.hir().local_def_id_to_hir_id(self.tcx.hir().get_parent_item(hir_id));
}
}
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'tcx>,
- trait_ref: ty::PolyTraitRef<'tcx>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
) {
// It only make sense when suggesting dereferences for arguments
let code = if let ObligationCauseCode::FunctionArgumentObligation { parent_code, .. } =
let param_env = obligation.param_env;
let body_id = obligation.cause.body_id;
let span = obligation.cause.span;
- let real_trait_ref = match &*code {
+ let real_trait_pred = match &*code {
ObligationCauseCode::ImplDerivedObligation(cause)
| ObligationCauseCode::DerivedObligation(cause)
- | ObligationCauseCode::BuiltinDerivedObligation(cause) => cause.parent_trait_ref,
- _ => trait_ref,
+ | ObligationCauseCode::BuiltinDerivedObligation(cause) => cause.parent_trait_pred,
+ _ => trait_pred,
};
- let real_ty = match real_trait_ref.self_ty().no_bound_vars() {
+ let real_ty = match real_trait_pred.self_ty().no_bound_vars() {
Some(ty) => ty,
None => return,
};
// Re-add the `&`
let ty = self.tcx.mk_ref(region, TypeAndMut { ty, mutbl });
let obligation =
- self.mk_trait_obligation_with_new_self_ty(param_env, real_trait_ref, ty);
+ self.mk_trait_obligation_with_new_self_ty(param_env, real_trait_pred, ty);
Some(steps).filter(|_| self.predicate_may_hold(&obligation))
}) {
if steps > 0 {
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
) {
- let self_ty = match trait_ref.self_ty().no_bound_vars() {
+ let self_ty = match trait_pred.self_ty().no_bound_vars() {
None => return,
Some(ty) => ty,
};
};
let new_obligation =
- self.mk_trait_obligation_with_new_self_ty(obligation.param_env, trait_ref, output_ty);
+ self.mk_trait_obligation_with_new_self_ty(obligation.param_env, trait_pred, output_ty);
match self.evaluate_obligation(&new_obligation) {
Ok(
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
- poly_trait_ref: &ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ poly_trait_pred: ty::PolyTraitPredicate<'tcx>,
has_custom_message: bool,
) -> bool {
let span = obligation.cause.span;
let param_env = obligation.param_env;
// Try to apply the original trait binding obligation by borrowing.
- let mut try_borrowing = |old_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ let mut try_borrowing = |old_pred: ty::PolyTraitPredicate<'tcx>,
blacklist: &[DefId]|
-> bool {
- if blacklist.contains(&old_ref.def_id()) {
+ if blacklist.contains(&old_pred.def_id()) {
return false;
}
- let orig_ty = old_ref.self_ty().skip_binder();
+ let orig_ty = old_pred.self_ty().skip_binder();
let mk_result = |new_ty| {
- let new_ref = old_ref.rebind(ty::TraitRef::new(
- old_ref.def_id(),
- self.tcx.mk_substs_trait(new_ty, &old_ref.skip_binder().substs[1..]),
- ));
- self.predicate_must_hold_modulo_regions(&Obligation::new(
- ObligationCause::dummy(),
- param_env,
- new_ref.without_const().to_predicate(self.tcx),
- ))
+ let obligation =
+ self.mk_trait_obligation_with_new_self_ty(param_env, old_pred, new_ty);
+ self.predicate_must_hold_modulo_regions(&obligation)
};
let imm_result = mk_result(self.tcx.mk_imm_ref(self.tcx.lifetimes.re_static, orig_ty));
let mut_result = mk_result(self.tcx.mk_mut_ref(self.tcx.lifetimes.re_static, orig_ty));
let msg = format!(
"the trait bound `{}: {}` is not satisfied",
orig_ty,
- old_ref.print_only_trait_path(),
+ old_pred.print_modifiers_and_trait_path(),
);
if has_custom_message {
err.note(&msg);
span,
&format!(
"expected an implementor of trait `{}`",
- old_ref.print_only_trait_path(),
+ old_pred.print_modifiers_and_trait_path(),
),
);
};
if let ObligationCauseCode::ImplDerivedObligation(obligation) = code {
- try_borrowing(obligation.parent_trait_ref, &[])
+ try_borrowing(obligation.parent_trait_pred, &[])
} else if let ObligationCauseCode::BindingObligation(_, _)
| ObligationCauseCode::ItemObligation(_) = code
{
- try_borrowing(*poly_trait_ref, &never_suggest_borrow)
+ try_borrowing(poly_trait_pred, &never_suggest_borrow)
} else {
false
}
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
) {
let span = obligation.cause.span;
return;
}
- let mut suggested_ty = match trait_ref.self_ty().no_bound_vars() {
+ let mut suggested_ty = match trait_pred.self_ty().no_bound_vars() {
Some(ty) => ty,
None => return,
};
for refs_remaining in 0..refs_number {
- if let ty::Ref(_, inner_ty, _) = suggested_ty.kind() {
- suggested_ty = inner_ty;
+ let ty::Ref(_, inner_ty, _) = suggested_ty.kind() else {
+ break;
+ };
+ suggested_ty = *inner_ty;
- let new_obligation = self.mk_trait_obligation_with_new_self_ty(
- obligation.param_env,
- trait_ref,
- suggested_ty,
- );
+ let new_obligation = self.mk_trait_obligation_with_new_self_ty(
+ obligation.param_env,
+ trait_pred,
+ suggested_ty,
+ );
- if self.predicate_may_hold(&new_obligation) {
- let sp = self
- .tcx
- .sess
- .source_map()
- .span_take_while(span, |c| c.is_whitespace() || *c == '&');
+ if self.predicate_may_hold(&new_obligation) {
+ let sp = self
+ .tcx
+ .sess
+ .source_map()
+ .span_take_while(span, |c| c.is_whitespace() || *c == '&');
- let remove_refs = refs_remaining + 1;
+ let remove_refs = refs_remaining + 1;
- let msg = if remove_refs == 1 {
- "consider removing the leading `&`-reference".to_string()
- } else {
- format!("consider removing {} leading `&`-references", remove_refs)
- };
+ let msg = if remove_refs == 1 {
+ "consider removing the leading `&`-reference".to_string()
+ } else {
+ format!("consider removing {} leading `&`-references", remove_refs)
+ };
- err.span_suggestion_short(
- sp,
- &msg,
- String::new(),
- Applicability::MachineApplicable,
- );
- break;
- }
- } else {
+ err.span_suggestion_short(
+ sp,
+ &msg,
+ String::new(),
+ Applicability::MachineApplicable,
+ );
break;
}
}
&self,
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
) {
let points_at_arg = matches!(
obligation.cause.code(),
// Do not suggest removal of borrow from type arguments.
return;
}
- let trait_ref = self.resolve_vars_if_possible(trait_ref);
- if trait_ref.has_infer_types_or_consts() {
+ let trait_pred = self.resolve_vars_if_possible(trait_pred);
+ if trait_pred.has_infer_types_or_consts() {
// Do not ICE while trying to find if a reborrow would succeed on a trait with
// unresolved bindings.
return;
}
- if let ty::Ref(region, t_type, mutability) = *trait_ref.skip_binder().self_ty().kind() {
+ if let ty::Ref(region, t_type, mutability) = *trait_pred.skip_binder().self_ty().kind()
+ {
if region.is_late_bound() || t_type.has_escaping_bound_vars() {
// Avoid debug assertion in `mk_obligation_for_def_id`.
//
let new_obligation = self.mk_trait_obligation_with_new_self_ty(
obligation.param_env,
- trait_ref,
+ trait_pred,
suggested_ty,
);
let suggested_ty_would_satisfy_obligation = self
} else {
err.note(&format!(
"`{}` is implemented for `{:?}`, but not for `{:?}`",
- trait_ref.print_only_trait_path(),
+ trait_pred.print_modifiers_and_trait_path(),
suggested_ty,
- trait_ref.skip_binder().self_ty(),
+ trait_pred.skip_binder().self_ty(),
));
}
}
obligation: &PredicateObligation<'tcx>,
err: &mut DiagnosticBuilder<'_>,
span: Span,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
) {
let is_empty_tuple =
|ty: ty::Binder<'tcx, Ty<'_>>| *ty.skip_binder().kind() == ty::Tuple(ty::List::empty());
if let hir::ExprKind::Block(blk, _) = &body.value.kind {
if sig.decl.output.span().overlaps(span)
&& blk.expr.is_none()
- && is_empty_tuple(trait_ref.self_ty())
+ && is_empty_tuple(trait_pred.self_ty())
{
// FIXME(estebank): When encountering a method with a trait
// bound not satisfied in the return type with a body that has
err: &mut DiagnosticBuilder<'_>,
span: Span,
obligation: &PredicateObligation<'tcx>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
) -> bool {
match obligation.cause.code().peel_derives() {
// Only suggest `impl Trait` if the return type is unsized because it is `dyn Trait`.
return false;
};
let body = hir.body(*body_id);
- let trait_ref = self.resolve_vars_if_possible(trait_ref);
- let ty = trait_ref.skip_binder().self_ty();
+ let trait_pred = self.resolve_vars_if_possible(trait_pred);
+ let ty = trait_pred.skip_binder().self_ty();
let is_object_safe = match ty.kind() {
ty::Dynamic(predicates, _) => {
// If the `dyn Trait` is not object safe, do not suggest `Box<dyn Trait>`.
_ => return false,
};
- let ret_ty = if let hir::FnRetTy::Return(ret_ty) = sig.decl.output {
- ret_ty
- } else {
+ let hir::FnRetTy::Return(ret_ty) = sig.decl.output else {
return false;
};
};
let sm = self.tcx.sess.source_map();
- let snippet = if let (true, hir::TyKind::TraitObject(..), Ok(snippet), true) = (
+ let (true, hir::TyKind::TraitObject(..), Ok(snippet), true) = (
// Verify that we're dealing with a return `dyn Trait`
ret_ty.span.overlaps(span),
&ret_ty.kind,
// If any of the return types does not conform to the trait, then we can't
// suggest `impl Trait` nor trait objects: it is a type mismatch error.
all_returns_conform_to_trait,
- ) {
- snippet
- } else {
+ ) else {
return false;
};
err.code(error_code!(E0746));
.returns
.iter()
.flat_map(|expr| {
- vec![
+ [
(expr.span.shrink_to_lo(), "Box::new(".to_string()),
(expr.span.shrink_to_hi(), ")".to_string()),
]
trait_ref.rebind(sig).to_string()
}
- let argument_kind = match expected_ref.skip_binder().substs.type_at(0) {
- t if t.is_closure() => "closure",
- t if t.is_generator() => "generator",
+ let argument_kind = match expected_ref.skip_binder().self_ty().kind() {
+ ty::Closure(..) => "closure",
+ ty::Generator(..) => "generator",
_ => "function",
};
let mut err = struct_span_err!(
err.span_suggestion(
span,
"use the fully qualified path to an implementation",
- format!("<Type as {}>::{}", self.tcx.def_path_str(trait_ref), assoc_item.ident),
+ format!("<Type as {}>::{}", self.tcx.def_path_str(trait_ref), assoc_item.name),
Applicability::HasPlaceholders,
);
}
// bound was introduced. At least one generator should be present for this diagnostic to be
// modified.
let (mut trait_ref, mut target_ty) = match obligation.predicate.kind().skip_binder() {
- ty::PredicateKind::Trait(p) => (Some(p.trait_ref), Some(p.self_ty())),
+ ty::PredicateKind::Trait(p) => (Some(p), Some(p.self_ty())),
_ => (None, None),
};
let mut generator = None;
ObligationCauseCode::DerivedObligation(derived_obligation)
| ObligationCauseCode::BuiltinDerivedObligation(derived_obligation)
| ObligationCauseCode::ImplDerivedObligation(derived_obligation) => {
- let ty = derived_obligation.parent_trait_ref.skip_binder().self_ty();
+ let ty = derived_obligation.parent_trait_pred.skip_binder().self_ty();
debug!(
"maybe_note_obligation_cause_for_async_await: \
parent_trait_ref={:?} self_ty.kind={:?}",
- derived_obligation.parent_trait_ref,
+ derived_obligation.parent_trait_pred,
ty.kind()
);
seen_upvar_tys_infer_tuple = true;
}
_ if generator.is_none() => {
- trait_ref = Some(derived_obligation.parent_trait_ref.skip_binder());
+ trait_ref = Some(derived_obligation.parent_trait_pred.skip_binder());
target_ty = Some(ty);
}
_ => {}
// `erase_late_bound_regions`.
let ty_erased = self.tcx.erase_late_bound_regions(ty);
let ty_erased = self.tcx.erase_regions(ty_erased);
- let eq = ty::TyS::same_type(ty_erased, target_ty_erased);
+ let eq = ty_erased == target_ty_erased;
debug!(
"maybe_note_obligation_cause_for_async_await: ty_erased={:?} \
target_ty_erased={:?} eq={:?}",
if let Some(cause) =
typeck_results.generator_interior_types.as_ref().skip_binder().iter().find(
|ty::GeneratorInteriorTypeCause { ty, .. }| {
- ty_matches(typeck_results.generator_interior_types.rebind(ty))
+ ty_matches(typeck_results.generator_interior_types.rebind(*ty))
},
)
{
interior_extra_info: Option<(Option<Span>, Span, Option<hir::HirId>, Option<Span>)>,
inner_generator_body: Option<&hir::Body<'tcx>>,
outer_generator: Option<DefId>,
- trait_ref: ty::TraitRef<'tcx>,
+ trait_pred: ty::TraitPredicate<'tcx>,
target_ty: Ty<'tcx>,
typeck_results: Option<&ty::TypeckResults<'tcx>>,
obligation: &PredicateObligation<'tcx>,
// not implemented.
let hir = self.tcx.hir();
let trait_explanation = if let Some(name @ (sym::Send | sym::Sync)) =
- self.tcx.get_diagnostic_name(trait_ref.def_id)
+ self.tcx.get_diagnostic_name(trait_pred.def_id())
{
let (trait_name, trait_verb) =
if name == sym::Send { ("`Send`", "sent") } else { ("`Sync`", "shared") };
format!("is not {}", trait_name)
} else {
- format!("does not implement `{}`", trait_ref.print_only_trait_path())
+ format!("does not implement `{}`", trait_pred.print_modifiers_and_trait_path())
};
let mut explain_yield = |interior_span: Span,
self.note_obligation_cause_code(
err,
&obligation.predicate,
+ obligation.param_env,
next_code.unwrap(),
&mut Vec::new(),
&mut Default::default(),
&self,
err: &mut DiagnosticBuilder<'_>,
predicate: &T,
+ param_env: ty::ParamEnv<'tcx>,
cause_code: &ObligationCauseCode<'tcx>,
- obligated_types: &mut Vec<&ty::TyS<'tcx>>,
+ obligated_types: &mut Vec<Ty<'tcx>>,
seen_requirements: &mut FxHashSet<DefId>,
) where
T: fmt::Display,
| ObligationCauseCode::AwaitableExpr(_)
| ObligationCauseCode::ForLoopIterator
| ObligationCauseCode::QuestionMark
- | ObligationCauseCode::LetElse => {}
+ | ObligationCauseCode::LetElse
+ | ObligationCauseCode::CheckAssociatedTypeBounds { .. } => {}
ObligationCauseCode::SliceOrArrayElem => {
err.note("slice and array elements must have `Sized` type");
}
err.note("shared static variables must have a type that implements `Sync`");
}
ObligationCauseCode::BuiltinDerivedObligation(ref data) => {
- let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_ref);
+ let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
let ty = parent_trait_ref.skip_binder().self_ty();
if parent_trait_ref.references_error() {
err.cancel();
if let ObligationCauseCode::BuiltinDerivedObligation(ref data) =
*data.parent_code
{
- let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_ref);
+ let parent_trait_ref =
+ self.resolve_vars_if_possible(data.parent_trait_pred);
let ty = parent_trait_ref.skip_binder().self_ty();
matches!(ty.kind(), ty::Generator(..))
|| matches!(ty.kind(), ty::Closure(..))
obligated_types.push(ty);
- let parent_predicate = parent_trait_ref.without_const().to_predicate(tcx);
+ let parent_predicate = parent_trait_ref.to_predicate(tcx);
if !self.is_recursive_obligation(obligated_types, &data.parent_code) {
// #74711: avoid a stack overflow
ensure_sufficient_stack(|| {
self.note_obligation_cause_code(
err,
&parent_predicate,
+ param_env,
&data.parent_code,
obligated_types,
seen_requirements,
self.note_obligation_cause_code(
err,
&parent_predicate,
+ param_env,
&cause_code.peel_derives(),
obligated_types,
seen_requirements,
}
}
ObligationCauseCode::ImplDerivedObligation(ref data) => {
- let mut parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_ref);
- let parent_def_id = parent_trait_ref.def_id();
+ let mut parent_trait_pred = self.resolve_vars_if_possible(data.parent_trait_pred);
+ parent_trait_pred.remap_constness_diag(param_env);
+ let parent_def_id = parent_trait_pred.def_id();
let msg = format!(
"required because of the requirements on the impl of `{}` for `{}`",
- parent_trait_ref.print_only_trait_path(),
- parent_trait_ref.skip_binder().self_ty()
+ parent_trait_pred.print_modifiers_and_trait_path(),
+ parent_trait_pred.skip_binder().self_ty()
);
let mut candidates = vec![];
self.tcx.for_each_relevant_impl(
parent_def_id,
- parent_trait_ref.self_ty().skip_binder(),
+ parent_trait_pred.self_ty().skip_binder(),
|impl_def_id| match self.tcx.hir().get_if_local(impl_def_id) {
Some(Node::Item(hir::Item {
kind: hir::ItemKind::Impl(hir::Impl { .. }),
_ => err.note(&msg),
};
- let mut parent_predicate = parent_trait_ref.without_const().to_predicate(tcx);
+ let mut parent_predicate = parent_trait_pred.to_predicate(tcx);
let mut data = data;
let mut count = 0;
seen_requirements.insert(parent_def_id);
while let ObligationCauseCode::ImplDerivedObligation(child) = &*data.parent_code {
// Skip redundant recursive obligation notes. See `ui/issue-20413.rs`.
- let child_trait_ref = self.resolve_vars_if_possible(child.parent_trait_ref);
- let child_def_id = child_trait_ref.def_id();
+ let child_trait_pred = self.resolve_vars_if_possible(child.parent_trait_pred);
+ let child_def_id = child_trait_pred.def_id();
if seen_requirements.insert(child_def_id) {
break;
}
count += 1;
data = child;
- parent_predicate = child_trait_ref.without_const().to_predicate(tcx);
- parent_trait_ref = child_trait_ref;
+ parent_predicate = child_trait_pred.to_predicate(tcx);
+ parent_trait_pred = child_trait_pred;
}
if count > 0 {
err.note(&format!(
));
err.note(&format!(
"required because of the requirements on the impl of `{}` for `{}`",
- parent_trait_ref.print_only_trait_path(),
- parent_trait_ref.skip_binder().self_ty()
+ parent_trait_pred.print_modifiers_and_trait_path(),
+ parent_trait_pred.skip_binder().self_ty()
));
}
// #74711: avoid a stack overflow
self.note_obligation_cause_code(
err,
&parent_predicate,
+ param_env,
&data.parent_code,
obligated_types,
seen_requirements,
});
}
ObligationCauseCode::DerivedObligation(ref data) => {
- let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_ref);
- let parent_predicate = parent_trait_ref.without_const().to_predicate(tcx);
+ let parent_trait_ref = self.resolve_vars_if_possible(data.parent_trait_pred);
+ let parent_predicate = parent_trait_ref.to_predicate(tcx);
// #74711: avoid a stack overflow
ensure_sufficient_stack(|| {
self.note_obligation_cause_code(
err,
&parent_predicate,
+ param_env,
&data.parent_code,
obligated_types,
seen_requirements,
{
let in_progress_typeck_results =
self.in_progress_typeck_results.map(|t| t.borrow());
- let parent_id = hir.local_def_id(hir.get_parent_item(arg_hir_id));
+ let parent_id = hir.get_parent_item(arg_hir_id);
let typeck_results: &TypeckResults<'tcx> = match &in_progress_typeck_results {
Some(t) if t.hir_owner == parent_id => t,
_ => self.tcx.typeck(parent_id),
if let Some(Node::Expr(hir::Expr {
kind:
hir::ExprKind::Call(hir::Expr { span, .. }, _)
- | hir::ExprKind::MethodCall(_, span, ..),
+ | hir::ExprKind::MethodCall(
+ hir::PathSegment { ident: Ident { span, .. }, .. },
+ ..,
+ ),
..
})) = hir.find(call_hir_id)
{
self.note_obligation_cause_code(
err,
predicate,
+ param_env,
&parent_code,
obligated_types,
seen_requirements,
&self,
err: &mut DiagnosticBuilder<'_>,
obligation: &PredicateObligation<'tcx>,
- trait_ref: ty::Binder<'tcx, ty::TraitRef<'tcx>>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
span: Span,
) {
debug!(
- "suggest_await_before_try: obligation={:?}, span={:?}, trait_ref={:?}, trait_ref_self_ty={:?}",
+ "suggest_await_before_try: obligation={:?}, span={:?}, trait_pred={:?}, trait_pred_self_ty={:?}",
obligation,
span,
- trait_ref,
- trait_ref.self_ty()
+ trait_pred,
+ trait_pred.self_ty()
);
let body_hir_id = obligation.cause.body_id;
let item_id = self.tcx.hir().get_parent_node(body_hir_id);
if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
let future_trait = self.tcx.require_lang_item(LangItem::Future, None);
- let self_ty = self.resolve_vars_if_possible(trait_ref.self_ty());
+ let self_ty = self.resolve_vars_if_possible(trait_pred.self_ty());
// Do not check on infer_types to avoid panic in evaluate_obligation.
if self_ty.has_infer_types() {
let projection_ty = ty::ProjectionTy {
// `T`
substs: self.tcx.mk_substs_trait(
- trait_ref.self_ty().skip_binder(),
- self.fresh_substs_for_item(span, item_def_id),
+ trait_pred.self_ty().skip_binder(),
+ &self.fresh_substs_for_item(span, item_def_id)[1..],
),
// `Future::Output`
item_def_id,
);
let try_obligation = self.mk_trait_obligation_with_new_self_ty(
obligation.param_env,
- trait_ref,
- normalized_ty,
+ trait_pred,
+ normalized_ty.ty().unwrap(),
);
debug!("suggest_await_before_try: try_trait_obligation {:?}", try_obligation);
if self.predicate_may_hold(&try_obligation)
}
impl<'v> Visitor<'v> for ReturnsVisitor<'v> {
- type Map = hir::intravisit::ErasedMap<'v>;
-
- fn nested_visit_map(&mut self) -> hir::intravisit::NestedVisitorMap<Self::Map> {
- hir::intravisit::NestedVisitorMap::None
- }
-
fn visit_expr(&mut self, ex: &'v hir::Expr<'v>) {
// Visit every expression to detect `return` paths, either through the function's tail
// expression or `return` statements. We walk all nodes to find `return` statements, but
}
impl<'v> Visitor<'v> for AwaitsVisitor {
- type Map = hir::intravisit::ErasedMap<'v>;
-
- fn nested_visit_map(&mut self) -> hir::intravisit::NestedVisitorMap<Self::Map> {
- hir::intravisit::NestedVisitorMap::None
- }
-
fn visit_expr(&mut self, ex: &'v hir::Expr<'v>) {
if let hir::ExprKind::Yield(_, hir::YieldSource::Await { expr: Some(id) }) = ex.kind {
self.awaits.push(id)
projects / rustc.git / blobdiff