Opaque higher ranked

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -167,9 +167,25 @@ pub(crate) struct RegionDefinition<'tcx> {
 
  /// If this is 'static or an early-bound region, then this is
  /// `Some(X)` where `X` is the name of the region.
+ ///
+ /// Use the method `Self::external_name` for more flexibility.
  pub(crate) external_name: Option<ty::Region<'tcx>>,
 }
 
+impl<'tcx> RegionDefinition<'tcx> {
+ /// Gets the name of a universal region (including placeholders).
+ /// Returns `None` if this is an existential variable.
+ pub fn external_name(&self, tcx: TyCtxt<'tcx>) -> Option<ty::Region<'tcx>> {
+ match self.origin {
+ NllRegionVariableOrigin::FreeRegion => self.external_name,
+ NllRegionVariableOrigin::Placeholder(placeholder) => {
+ Some(tcx.mk_region(ty::RePlaceholder(placeholder)))
+ }
+ NllRegionVariableOrigin::Existential { .. } => None,
+ }
+ }
+}
+
 /// N.B., the variants in `Cause` are intentionally ordered. Lower
 /// values are preferred when it comes to error messages. Do not
 /// reorder willy nilly.
@@ -712,16 +728,28 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  *c_r = self.scc_representatives[scc];
  }
 
- // The 'member region' in a member constraint is part of the
- // hidden type, which must be in the root universe. Therefore,
- // it cannot have any placeholders in its value.
- assert!(self.scc_universes[scc] == ty::UniverseIndex::ROOT);
- debug_assert!(
- self.scc_values.placeholders_contained_in(scc).next().is_none(),
- "scc {:?} in a member constraint has placeholder value: {:?}",
- scc,
- self.scc_values.region_value_str(scc),
- );
+ // The 'member region' may have a placeholder region in its value.
+ // Consider the inner opaque type `impl Sized` in:
+ // `fn test() -> impl for<'a> Trait<'a, Ty = impl Sized + 'a>`.
+ // Here choice_regions = ['static, Placeholder('a, U1)].
+ if self.scc_universes[scc] != ty::UniverseIndex::ROOT {
+ let Some(&choice) = choice_regions
+ .iter()
+ .find(|&&choice| self.eval_equal(choice, self.scc_representatives[scc]))
+ else {
+ debug!("failed higher-ranked member constraint");
+ return false;
+ };
+
+ self.member_constraints_applied.push(AppliedMemberConstraint {
+ member_region_scc: scc,
+ min_choice: choice,
+ member_constraint_index,
+ });
+
+ debug!(?choice, "higher-ranked");
+ return true;
+ }
 
  // The existing value for `scc` is a lower-bound. This will
  // consist of some set `{P} + {LB}` of points `{P}` and
@@ -1360,6 +1388,14 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  return self.eval_outlives(sup_region, self.universal_regions.fr_static);
  }
 
+ // Check `sup_region` contains all the placeholder regions in `sub_region`.
+ if !self.scc_values.contains_placeholders(sup_region_scc, sub_region_scc) {
+ debug!(
+ "eval_outlives: returning false because sub region contains a placeholder region not present in super"
+ );
+ return false;
+ }
+
  // Both the `sub_region` and `sup_region` consist of the union
  // of some number of universal regions (along with the union
  // of various points in the CFG; ignore those points for

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -3,6 +3,7 @@ use rustc_data_structures::vec_map::VecMap;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::OpaqueTyOrigin;
 use rustc_infer::infer::error_reporting::unexpected_hidden_region_diagnostic;
+use rustc_infer::infer::opaque_types::OpaqueTypeMap;
 use rustc_infer::infer::TyCtxtInferExt as _;
 use rustc_infer::infer::{DefiningAnchor, InferCtxt};
 use rustc_infer::traits::{Obligation, ObligationCause, TraitEngine};
@@ -62,23 +63,31 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  pub(crate) fn infer_opaque_types(
  &self,
  infcx: &InferCtxt<'_, 'tcx>,
- opaque_ty_decls: VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>,
+ opaque_ty_decls: OpaqueTypeMap<'tcx>,
  ) -> VecMap<LocalDefId, OpaqueHiddenType<'tcx>> {
  let mut result: VecMap<LocalDefId, OpaqueHiddenType<'tcx>> = VecMap::new();
- for (opaque_type_key, (concrete_type, origin)) in opaque_ty_decls {
+ for (opaque_type_key, decl) in opaque_ty_decls {
  let substs = opaque_type_key.substs;
- debug!(?concrete_type, ?substs);
+ debug!(?decl.hidden_type, ?substs);
 
  let mut subst_regions = vec![self.universal_regions.fr_static];
  let universal_substs = infcx.tcx.fold_regions(substs, |region, _| {
- if let ty::RePlaceholder(..) = region.kind() {
- // Higher kinded regions don't need remapping, they don't refer to anything outside of this the substs.
- return region;
+ let (vid, scc) = match region.kind() {
+ ty::ReVar(vid) => (vid, self.constraint_sccs.scc(vid)),
+ _ => bug!("expected nll var"),
+ };
+ trace!(?vid, ?scc);
+
+ // Special handling of higher-ranked regions. These appear in the substs of the
+ // inner opaque type `impl Sized` in:
+ // `fn test() -> impl for<'a> Trait<'a, Ty = impl Sized + 'a>`
+ if self.scc_universes[scc] != ty::UniverseIndex::ROOT {
+ subst_regions.push(vid);
+ return self.definitions[vid]
+ .external_name(infcx.tcx)
+ .expect("higher-ranked existential region found in opaque type substs");
  }
- let vid = self.to_region_vid(region);
- trace!(?vid);
- let scc = self.constraint_sccs.scc(vid);
- trace!(?scc);
+
  match self.scc_values.universal_regions_outlived_by(scc).find_map(|lb| {
  self.eval_equal(vid, lb).then_some(self.definitions[lb].external_name?)
  }) {
@@ -90,7 +99,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  None => {
  subst_regions.push(vid);
  infcx.tcx.sess.delay_span_bug(
- concrete_type.span,
+ decl.hidden_type.span,
  "opaque type with non-universal region substs",
  );
  infcx.tcx.lifetimes.re_static
@@ -102,13 +111,13 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  subst_regions.dedup();
 
  let universal_concrete_type =
- infcx.tcx.fold_regions(concrete_type, |region, _| match *region {
+ infcx.tcx.fold_regions(decl.hidden_type, |region, _| match *region {
  ty::ReVar(vid) => subst_regions
  .iter()
  .find(|ur_vid| self.eval_equal(vid, **ur_vid))
- .and_then(|ur_vid| self.definitions[*ur_vid].external_name)
+ .and_then(|ur_vid| self.definitions[*ur_vid].external_name(infcx.tcx))
  .unwrap_or(infcx.tcx.lifetimes.re_root_empty),
- _ => region,
+ _ => bug!("expected nll var"),
  });
 
  debug!(?universal_concrete_type, ?universal_substs);
@@ -118,7 +127,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  let ty = infcx.infer_opaque_definition_from_instantiation(
  opaque_type_key,
  universal_concrete_type,
- origin,
+ decl.origin,
  );
  // Sometimes two opaque types are the same only after we remap the generic parameters
  // back to the opaque type definition. E.g. we may have `OpaqueType<X, Y>` mapped to `(X, Y)`
@@ -128,19 +137,19 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  if prev.ty != ty {
  if !ty.references_error() {
  prev.report_mismatch(
- &OpaqueHiddenType { ty, span: concrete_type.span },
+ &OpaqueHiddenType { ty, span: decl.hidden_type.span },
  infcx.tcx,
  );
  }
  prev.ty = infcx.tcx.ty_error();
  }
  // Pick a better span if there is one.
  // FIXME(oli-obk): collect multiple spans for better diagnostics down the road.
- prev.span = prev.span.substitute_dummy(concrete_type.span);
+ prev.span = prev.span.substitute_dummy(decl.hidden_type.span);
  } else {
  result.insert(
  opaque_type_key.def_id,
- OpaqueHiddenType { ty, span: concrete_type.span },
+ OpaqueHiddenType { ty, span: decl.hidden_type.span },
  );
  }
  }
@@ -159,6 +168,25 @@ impl<'tcx> RegionInferenceContext<'tcx> {
  {
  tcx.fold_regions(ty, |region, _| match *region {
  ty::ReVar(vid) => {
+ let scc = self.constraint_sccs.scc(vid);
+
+ // Special handling of higher-ranked regions.
+ if self.scc_universes[scc] != ty::UniverseIndex::ROOT {
+ // If the region contains a single placeholder then they're equal.
+ if let Some((0, placeholder)) =
+ self.scc_values.placeholders_contained_in(scc).enumerate().last()
+ {
+ // HACK: we convert named placeholders to free regions for better errors.
+ // Otherwise, this is incorrect.
+ if let bound_region @ ty::BrNamed(scope, _) = placeholder.name {
+ return tcx
+ .mk_region(ty::ReFree(ty::FreeRegion { scope, bound_region }));
+ }
+ }
+ // Fallback: this will produce a cryptic error message.
+ return region;
+ }
+
  // Find something that we can name
  let upper_bound = self.approx_universal_upper_bound(vid);
  let upper_bound = &self.definitions[upper_bound];
@@ -384,7 +412,7 @@ fn check_opaque_type_parameter_valid(
  return false;
  }
  GenericArgKind::Lifetime(lt) => {
- matches!(*lt, ty::ReEarlyBound(_) | ty::ReFree(_))
+ matches!(*lt, ty::ReEarlyBound(_) | ty::ReFree(_) | ty::RePlaceholder(_))
  }
  GenericArgKind::Const(ct) => matches!(ct.kind(), ty::ConstKind::Param(_)),
  };
@@ -494,9 +522,12 @@ impl<'tcx> TypeFolder<'tcx> for ReverseMapper<'tcx> {
  ty::ReErased => return r,
 
  // The regions that we expect from borrow checking.
- ty::ReEarlyBound(_) | ty::ReFree(_) | ty::ReEmpty(ty::UniverseIndex::ROOT) => {}
+ ty::ReEarlyBound(_)
+ | ty::ReFree(_)
+ | ty::RePlaceholder(_)
+ | ty::ReEmpty(ty::UniverseIndex::ROOT) => {}
 
- ty::ReEmpty(_) | ty::RePlaceholder(_) | ty::ReVar(_) => {
+ ty::ReEmpty(_) | ty::ReVar(_) => {
  // All of the regions in the type should either have been
  // erased by writeback, or mapped back to named regions by
  // borrow checking.

compiler/rustc_borrowck/src/region_infer/values.rs

@@ -303,6 +303,22 @@ impl<N: Idx> RegionValues<N> {
  }
  }
 
+ /// Returns `true` if `sup_region` contains all the placeholder elements that
+ /// `sub_region` contains.
+ pub(crate) fn contains_placeholders(&self, sup_region: N, sub_region: N) -> bool {
+ if let Some(sub_row) = self.placeholders.row(sub_region) {
+ if let Some(sup_row) = self.placeholders.row(sup_region) {
+ sup_row.superset(sub_row)
+ } else {
+ // sup row is empty, so sub row must be empty
+ sub_row.is_empty()
+ }
+ } else {
+ // sub row is empty, always true
+ true
+ }
+ }
+
  /// Returns the locations contained within a given region `r`.
  pub(crate) fn locations_outlived_by<'a>(&'a self, r: N) -> impl Iterator<Item = Location> + 'a {
  self.points.row(r).into_iter().flat_map(move |set| {