use crate::autoderef::Autoderef;
use crate::infer::InferCtxt;
+use crate::traits::NormalizeExt;
use hir::def::CtorOf;
use hir::HirId;
obligated_types: &mut Vec<Ty<'tcx>>,
seen_requirements: &mut FxHashSet<DefId>,
) where
- T: fmt::Display + ToPredicate<'tcx, T>;
+ T: fmt::Display + ToPredicate<'tcx>;
/// Suggest to await before try: future? => future.await?
fn suggest_await_before_try(
obligation.param_env,
trait_pred_and_suggested_ty,
);
- let suggested_ty_would_satisfy_obligation =
- self.predicate_must_hold_modulo_regions(&new_obligation);
+ let suggested_ty_would_satisfy_obligation = self
+ .evaluate_obligation_no_overflow(&new_obligation)
+ .must_apply_modulo_regions();
if suggested_ty_would_satisfy_obligation {
let sp = self
.tcx
.as_local()
.and_then(|def_id| hir.maybe_body_owned_by(def_id))
.map(|body_id| hir.body(body_id));
- let is_async = self
- .tcx
- .generator_kind(generator_did)
- .map(|generator_kind| matches!(generator_kind, hir::GeneratorKind::Async(..)))
- .unwrap_or(false);
let mut visitor = AwaitsVisitor::default();
if let Some(body) = generator_body {
visitor.visit_body(body);
debug!(?interior_or_upvar_span);
if let Some(interior_or_upvar_span) = interior_or_upvar_span {
+ let is_async = self.tcx.generator_is_async(generator_did);
let typeck_results = match generator_data {
GeneratorData::Local(typeck_results) => Some(typeck_results),
GeneratorData::Foreign(_) => None,
obligated_types: &mut Vec<Ty<'tcx>>,
seen_requirements: &mut FxHashSet<DefId>,
) where
- T: fmt::Display,
+ T: fmt::Display + ToPredicate<'tcx>,
{
let tcx = self.tcx;
match *cause_code {
if is_future
&& obligated_types.last().map_or(false, |ty| match ty.kind() {
ty::Generator(last_def_id, ..) => {
- matches!(
- tcx.generator_kind(last_def_id),
- Some(GeneratorKind::Async(..))
- )
+ tcx.generator_is_async(*last_def_id)
}
_ => false,
})
self.tcx.mk_substs_trait(trait_pred.self_ty(), []),
)
});
- let InferOk { value: projection_ty, .. } = self
- .partially_normalize_associated_types_in(
- obligation.cause.clone(),
- obligation.param_env,
- projection_ty,
- );
+ let InferOk { value: projection_ty, .. } =
+ self.at(&obligation.cause, obligation.param_env).normalize(projection_ty);
debug!(
normalized_projection_type = ?self.resolve_vars_if_possible(projection_ty)