fully_revealed_type_of

Author: compiler-errors

compiler/rustc_hir_analysis/src/collect.rs

@@ -62,6 +62,7 @@ pub fn provide(providers: &mut Providers) {
     *providers = Providers {
         opt_const_param_of: type_of::opt_const_param_of,
         type_of: type_of::type_of,
+        fully_revealed_type_of: type_of::fully_revealed_type_of,
         item_bounds: item_bounds::item_bounds,
         explicit_item_bounds: item_bounds::explicit_item_bounds,
         generics_of: generics_of::generics_of,

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -7,7 +7,9 @@ use rustc_hir::{HirId, Node};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::subst::InternalSubsts;
 use rustc_middle::ty::util::IntTypeExt;
-use rustc_middle::ty::{self, DefIdTree, Ty, TyCtxt, TypeFolder, TypeSuperFoldable, TypeVisitable};
+use rustc_middle::ty::{
+    self, DefIdTree, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitable,
+};
 use rustc_span::symbol::Ident;
 use rustc_span::{Span, DUMMY_SP};
 
@@ -538,6 +540,35 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: DefId) -> Ty<'_> {
     }
 }
 
+pub fn fully_revealed_type_of<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> Ty<'tcx> {
+    let ty = tcx.type_of(def_id);
+    if ty.has_opaque_types() { ty.fold_with(&mut DeeperTypeFolder { tcx }) } else { ty }
+}
+
+struct DeeperTypeFolder<'tcx> {
+    tcx: TyCtxt<'tcx>,
+}
+
+impl<'tcx> TypeFolder<'tcx> for DeeperTypeFolder<'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
+
+    fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
+        if !ty.has_opaque_types() {
+            return ty;
+        }
+
+        let ty = ty.super_fold_with(self);
+
+        if let ty::Opaque(def_id, substs) = *ty.kind() {
+            self.tcx.bound_fully_revealed_type_of(def_id).subst(self.tcx, substs)
+        } else {
+            ty
+        }
+    }
+}
+
 #[instrument(skip(tcx), level = "debug")]
 /// Checks "defining uses" of opaque `impl Trait` types to ensure that they meet the restrictions
 /// laid for "higher-order pattern unification".

compiler/rustc_middle/src/query/mod.rs

@@ -164,6 +164,21 @@ rustc_queries! {
         separate_provide_extern
     }
 
+    query fully_revealed_type_of(key: DefId) -> Ty<'tcx> {
+        desc { |tcx|
+            "fully {action} `{path}`",
+            action = {
+                use rustc_hir::def::DefKind;
+                match tcx.def_kind(key) {
+                    DefKind::TyAlias => "expanding type alias",
+                    DefKind::TraitAlias => "expanding trait alias",
+                    _ => "computing type of",
+                }
+            },
+            path = tcx.def_path_str(key),
+        }
+    }
+
     query collect_trait_impl_trait_tys(key: DefId)
         -> Result<&'tcx FxHashMap<DefId, Ty<'tcx>>, ErrorGuaranteed>
     {

compiler/rustc_middle/src/ty/util.rs

@@ -650,6 +650,10 @@ impl<'tcx> TyCtxt<'tcx> {
         ty::EarlyBinder(self.type_of(def_id))
     }
 
+    pub fn bound_fully_revealed_type_of(self, def_id: DefId) -> ty::EarlyBinder<Ty<'tcx>> {
+        ty::EarlyBinder(self.fully_revealed_type_of(def_id))
+    }
+
     pub fn bound_trait_impl_trait_tys(
         self,
         def_id: DefId,

compiler/rustc_trait_selection/src/traits/project.rs

@@ -514,7 +514,7 @@ impl<'a, 'b, 'tcx> TypeFolder<'tcx> for AssocTypeNormalizer<'a, 'b, 'tcx> {
                         }
 
                         let substs = substs.fold_with(self);
-                        let generic_ty = self.tcx().bound_type_of(def_id);
+                        let generic_ty = self.tcx().bound_fully_revealed_type_of(def_id);
                         let concrete_ty = generic_ty.subst(self.tcx(), substs);
                         self.depth += 1;
                         let folded_ty = self.fold_ty(concrete_ty);

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

@@ -217,7 +217,7 @@ impl<'cx, 'tcx> FallibleTypeFolder<'tcx> for QueryNormalizer<'cx, 'tcx> {
                             self.infcx.err_ctxt().report_overflow_error(&obligation, true);
                         }
 
-                        let generic_ty = self.tcx().bound_type_of(def_id);
+                        let generic_ty = self.tcx().bound_fully_revealed_type_of(def_id);
                         let concrete_ty = generic_ty.subst(self.tcx(), substs);
                         self.anon_depth += 1;
                         if concrete_ty == ty {