Do not erase late bound regions, replace them with placeholders

Author: spastorino

compiler/rustc_hir_analysis/src/astconv/mod.rs

@@ -29,6 +29,7 @@ use rustc_hir::{GenericArg, GenericArgs, OpaqueTyOrigin};
 use rustc_infer::infer::{InferCtxt, InferOk, TyCtxtInferExt};
 use rustc_infer::traits::ObligationCause;
 use rustc_middle::middle::stability::AllowUnstable;
+use rustc_middle::ty::visit::TypeVisitable;
 use rustc_middle::ty::GenericParamDefKind;
 use rustc_middle::ty::{
     self, Const, GenericArgKind, GenericArgsRef, IsSuggestable, Ty, TyCtxt, TypeVisitableExt,
@@ -38,9 +39,9 @@ use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::symbol::{kw, Ident, Symbol};
 use rustc_span::{sym, BytePos, Span, DUMMY_SP};
 use rustc_target::spec::abi;
+use rustc_trait_selection::traits::query::normalize::MaxEscapingBoundVarVisitor;
 use rustc_trait_selection::traits::wf::object_region_bounds;
 use rustc_trait_selection::traits::{self, NormalizeExt, ObligationCtxt};
-use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
 
 use std::fmt::Display;
 use std::slice;
@@ -1609,133 +1610,116 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
         let cause = ObligationCause::misc(span, block.owner.def_id);
 
         let mut fulfillment_errors = Vec::new();
-        let mut applicable_candidates: Vec<_> = infcx.probe(|_| {
-            // Regions are not considered during selection.
-            let self_ty = self_ty
-                .fold_with(&mut BoundVarEraser { tcx, universe: infcx.create_next_universe() });
-
-            struct BoundVarEraser<'tcx> {
-                tcx: TyCtxt<'tcx>,
-                universe: ty::UniverseIndex,
-            }
-
-            // FIXME(non_lifetime_binders): Don't assign the same universe to each placeholder.
-            impl<'tcx> TypeFolder<TyCtxt<'tcx>> for BoundVarEraser<'tcx> {
-                fn interner(&self) -> TyCtxt<'tcx> {
-                    self.tcx
-                }
+        infcx.probe(|_| {
+            let mut universes = if self_ty.has_escaping_bound_vars() {
+                let mut max_visitor =
+                    MaxEscapingBoundVarVisitor { outer_index: ty::INNERMOST, escaping: 0 };
+                self_ty.visit_with(&mut max_visitor);
+                vec![None; max_visitor.escaping]
+            } else {
+                vec![]
+            };
 
-                fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
-                    // FIXME(@lcnr): This is broken, erasing bound regions
-                    // impacts selection as it results in different types.
-                    if r.is_bound() { self.tcx.lifetimes.re_erased } else { r }
-                }
+            crate::traits::project::with_replaced_escaping_bound_vars(
+                infcx,
+                &mut universes,
+                self_ty,
+                |self_ty| {
+                    let InferOk { value: self_ty, obligations } =
+                        infcx.at(&cause, param_env).normalize(self_ty);
 
-                fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
-                    match *ty.kind() {
-                        ty::Bound(_, bv) => Ty::new_placeholder(
-                            self.tcx,
-                            ty::PlaceholderType { universe: self.universe, bound: bv },
-                        ),
-                        _ => ty.super_fold_with(self),
-                    }
-                }
+                    let mut applicable_candidates: Vec<_> = candidates
+                        .iter()
+                        .copied()
+                        .filter(|&(impl_, _)| {
+                            infcx.probe(|_| {
+                                let ocx = ObligationCtxt::new(&infcx);
+                                ocx.register_obligations(obligations.clone());
+
+                                let impl_args = infcx.fresh_args_for_item(span, impl_);
+                                let impl_ty = tcx.type_of(impl_).instantiate(tcx, impl_args);
+                                let impl_ty = ocx.normalize(&cause, param_env, impl_ty);
+
+                                // Check that the self types can be related.
+                                // FIXME(inherent_associated_types): Should we use `eq` here? Method probing uses
+                                // `sup` for this situtation, too. What for? To constrain inference variables?
+                                if ocx
+                                    .sup(&ObligationCause::dummy(), param_env, impl_ty, self_ty)
+                                    .is_err()
+                                {
+                                    return false;
+                                }
 
-                fn fold_const(
-                    &mut self,
-                    ct: ty::Const<'tcx>,
-                ) -> <TyCtxt<'tcx> as rustc_type_ir::Interner>::Const {
-                    assert!(!ct.ty().has_escaping_bound_vars());
-
-                    match ct.kind() {
-                        ty::ConstKind::Bound(_, bv) => ty::Const::new_placeholder(
-                            self.tcx,
-                            ty::PlaceholderConst { universe: self.universe, bound: bv },
-                            ct.ty(),
-                        ),
-                        _ => ct.super_fold_with(self),
-                    }
-                }
-            }
+                                // Check whether the impl imposes obligations we have to worry about.
+                                let impl_bounds =
+                                    tcx.predicates_of(impl_).instantiate(tcx, impl_args);
+                                let impl_bounds = ocx.normalize(&cause, param_env, impl_bounds);
+                                let impl_obligations = traits::predicates_for_generics(
+                                    |_, _| cause.clone(),
+                                    param_env,
+                                    impl_bounds,
+                                );
+                                ocx.register_obligations(impl_obligations);
 
-            let InferOk { value: self_ty, obligations } =
-                infcx.at(&cause, param_env).normalize(self_ty);
+                                let mut errors = ocx.select_where_possible();
+                                if !errors.is_empty() {
+                                    fulfillment_errors.append(&mut errors);
+                                    return false;
+                                }
 
-            candidates
-                .iter()
-                .copied()
-                .filter(|&(impl_, _)| {
-                    infcx.probe(|_| {
-                        let ocx = ObligationCtxt::new(&infcx);
-                        ocx.register_obligations(obligations.clone());
-
-                        let impl_args = infcx.fresh_args_for_item(span, impl_);
-                        let impl_ty = tcx.type_of(impl_).instantiate(tcx, impl_args);
-                        let impl_ty = ocx.normalize(&cause, param_env, impl_ty);
-
-                        // Check that the self types can be related.
-                        // FIXME(inherent_associated_types): Should we use `eq` here? Method probing uses
-                        // `sup` for this situtation, too. What for? To constrain inference variables?
-                        if ocx.sup(&ObligationCause::dummy(), param_env, impl_ty, self_ty).is_err()
-                        {
-                            return false;
-                        }
+                                true
+                            })
+                        })
+                        .collect();
+
+                    if applicable_candidates.len() > 1 {
+                        return Err(self.complain_about_ambiguous_inherent_assoc_type(
+                            name,
+                            applicable_candidates
+                                .into_iter()
+                                .map(|(_, (candidate, _))| candidate)
+                                .collect(),
+                            span,
+                        ));
+                    }
 
-                        // Check whether the impl imposes obligations we have to worry about.
-                        let impl_bounds = tcx.predicates_of(impl_).instantiate(tcx, impl_args);
-                        let impl_bounds = ocx.normalize(&cause, param_env, impl_bounds);
-                        let impl_obligations = traits::predicates_for_generics(
-                            |_, _| cause.clone(),
-                            param_env,
-                            impl_bounds,
+                    if let Some((impl_, (assoc_item, def_scope))) = applicable_candidates.pop() {
+                        self.check_assoc_ty(assoc_item, name, def_scope, block, span);
+
+                        // FIXME(fmease): Currently creating throwaway `parent_args` to please
+                        // `create_args_for_associated_item`. Modify the latter instead (or sth. similar) to
+                        // not require the parent args logic.
+                        let parent_args = ty::GenericArgs::identity_for_item(tcx, impl_);
+                        let args = self.create_args_for_associated_item(
+                            span,
+                            assoc_item,
+                            segment,
+                            parent_args,
+                        );
+                        let args = tcx.mk_args_from_iter(
+                            std::iter::once(ty::GenericArg::from(self_ty))
+                                .chain(args.into_iter().skip(parent_args.len())),
                         );
-                        ocx.register_obligations(impl_obligations);
-
-                        let mut errors = ocx.select_where_possible();
-                        if !errors.is_empty() {
-                            fulfillment_errors.append(&mut errors);
-                            return false;
-                        }
-
-                        true
-                    })
-                })
-                .collect()
-        });
-
-        if applicable_candidates.len() > 1 {
-            return Err(self.complain_about_ambiguous_inherent_assoc_type(
-                name,
-                applicable_candidates.into_iter().map(|(_, (candidate, _))| candidate).collect(),
-                span,
-            ));
-        }
-
-        if let Some((impl_, (assoc_item, def_scope))) = applicable_candidates.pop() {
-            self.check_assoc_ty(assoc_item, name, def_scope, block, span);
-
-            // FIXME(fmease): Currently creating throwaway `parent_args` to please
-            // `create_args_for_associated_item`. Modify the latter instead (or sth. similar) to
-            // not require the parent args logic.
-            let parent_args = ty::GenericArgs::identity_for_item(tcx, impl_);
-            let args = self.create_args_for_associated_item(span, assoc_item, segment, parent_args);
-            let args = tcx.mk_args_from_iter(
-                std::iter::once(ty::GenericArg::from(self_ty))
-                    .chain(args.into_iter().skip(parent_args.len())),
-            );
 
-            let ty = Ty::new_alias(tcx, ty::Inherent, ty::AliasTy::new(tcx, assoc_item, args));
+                        let ty = Ty::new_alias(
+                            tcx,
+                            ty::Inherent,
+                            ty::AliasTy::new(tcx, assoc_item, args),
+                        );
 
-            return Ok(Some((ty, assoc_item)));
-        }
+                        return Ok(Some((ty, assoc_item)));
+                    }
 
-        Err(self.complain_about_inherent_assoc_type_not_found(
-            name,
-            self_ty,
-            candidates,
-            fulfillment_errors,
-            span,
-        ))
+                    Err(self.complain_about_inherent_assoc_type_not_found(
+                        name,
+                        self_ty,
+                        candidates,
+                        fulfillment_errors,
+                        span,
+                    ))
+                },
+            )
+        })
     }
 
     fn lookup_assoc_ty(

compiler/rustc_trait_selection/src/traits/query/normalize.rs

@@ -120,10 +120,10 @@ impl<'cx, 'tcx> QueryNormalizeExt<'tcx> for At<'cx, 'tcx> {
 }
 
 // Visitor to find the maximum escaping bound var
-struct MaxEscapingBoundVarVisitor {
+pub struct MaxEscapingBoundVarVisitor {
     // The index which would count as escaping
-    outer_index: ty::DebruijnIndex,
-    escaping: usize,
+    pub outer_index: ty::DebruijnIndex,
+    pub escaping: usize,
 }
 
 impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MaxEscapingBoundVarVisitor {

tests/ui/associated-inherent-types/issue-111404-1.rs

@@ -9,5 +9,6 @@ impl<'a> Foo<fn(&'a ())> {
 
 fn bar(_: fn(Foo<for<'b> fn(Foo<fn(&'b ())>::Assoc)>::Assoc)) {}
 //~^ ERROR higher-ranked subtype error
+//~| ERROR higher-ranked subtype error
 
 fn main() {}

tests/ui/associated-inherent-types/issue-111404-1.stderr

@@ -4,5 +4,13 @@ error: higher-ranked subtype error
 LL | fn bar(_: fn(Foo<for<'b> fn(Foo<fn(&'b ())>::Assoc)>::Assoc)) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to previous error
+error: higher-ranked subtype error
+  --> $DIR/issue-111404-1.rs:10:1
+   |
+LL | fn bar(_: fn(Foo<for<'b> fn(Foo<fn(&'b ())>::Assoc)>::Assoc)) {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors