Introduce DefPathData::ImplTraitInTrait

spastorino · spastorino · commit c4dd9a2a421f · 2022-11-20T15:55:24.000-03:00
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -1472,7 +1472,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 DefPathData::ImplTrait,
             ),
             hir::OpaqueTyOrigin::FnReturn(fn_def_id) => {
-                self.create_def(fn_def_id, opaque_ty_node_id, DefPathData::ImplTrait)
+                if in_trait {
+                    self.create_def(
+                        fn_def_id,
+                        opaque_ty_node_id,
+                        DefPathData::ImplTraitInTrait(fn_def_id.to_def_id(), None),
+                    )
+                } else {
+                    self.create_def(fn_def_id, opaque_ty_node_id, DefPathData::ImplTrait)
+                }
             }
             hir::OpaqueTyOrigin::AsyncFn(..) => bug!("unreachable"),
         };
@@ -1839,8 +1847,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
         let fn_def_id = self.local_def_id(fn_node_id);
 
-        let opaque_ty_def_id =
-            self.create_def(fn_def_id, opaque_ty_node_id, DefPathData::ImplTrait);
+        let opaque_ty_def_id = if in_trait {
+            self.create_def(
+                fn_def_id,
+                opaque_ty_node_id,
+                DefPathData::ImplTraitInTrait(fn_def_id.to_def_id(), None),
+            )
+        } else {
+            self.create_def(fn_def_id, opaque_ty_node_id, DefPathData::ImplTrait)
+        };
 
         // When we create the opaque type for this async fn, it is going to have
         // to capture all the lifetimes involved in the signature (including in the
diff --git a/compiler/rustc_hir/src/definitions.rs b/compiler/rustc_hir/src/definitions.rs
@@ -5,7 +5,9 @@
 //! expressions) that are mostly just leftovers.
 
 pub use crate::def_id::DefPathHash;
-use crate::def_id::{CrateNum, DefIndex, LocalDefId, StableCrateId, CRATE_DEF_INDEX, LOCAL_CRATE};
+use crate::def_id::{
+    CrateNum, DefId, DefIndex, LocalDefId, StableCrateId, CRATE_DEF_INDEX, LOCAL_CRATE,
+};
 use crate::def_path_hash_map::DefPathHashMap;
 
 use rustc_data_structures::fx::FxHashMap;
@@ -245,6 +247,17 @@ impl DefPath {
 
         s
     }
+
+    pub fn get_impl_trait_in_trait_data(&self) -> Option<(DefId, Option<DefId>)> {
+        if let Some(def_path_data) = self.data.last()
+            && let DefPathData::ImplTraitInTrait(fn_def_id, of_trait) =
+            def_path_data.data
+        {
+            Some((fn_def_id, of_trait))
+        } else {
+            None
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Encodable, Decodable)]
@@ -281,6 +294,10 @@ pub enum DefPathData {
     AnonConst,
     /// An `impl Trait` type node.
     ImplTrait,
+    /// An `impl Trait` type node inside a `trait` or inside an `impl` of a `trait`.
+    /// On a `trait` the value is `(trait_fn_def_id, None)`.
+    /// On an `impl` the value is `(impl_fn_def_id, Some(trait_rpit_def_id))`.
+    ImplTraitInTrait(DefId, Option<DefId>),
 }
 
 impl Definitions {
@@ -404,7 +421,7 @@ impl DefPathData {
             TypeNs(name) | ValueNs(name) | MacroNs(name) | LifetimeNs(name) => Some(name),
 
             Impl | ForeignMod | CrateRoot | Use | GlobalAsm | ClosureExpr | Ctor | AnonConst
-            | ImplTrait => None,
+            | ImplTrait | ImplTraitInTrait(..) => None,
         }
     }
 
@@ -424,6 +441,7 @@ impl DefPathData {
             Ctor => DefPathDataName::Anon { namespace: sym::constructor },
             AnonConst => DefPathDataName::Anon { namespace: sym::constant },
             ImplTrait => DefPathDataName::Anon { namespace: sym::opaque },
+            ImplTraitInTrait(..) => DefPathDataName::Anon { namespace: sym::opaque },
         }
     }
 }
diff --git a/compiler/rustc_hir/src/lib.rs b/compiler/rustc_hir/src/lib.rs
@@ -5,6 +5,7 @@
 #![feature(associated_type_defaults)]
 #![feature(closure_track_caller)]
 #![feature(const_btree_len)]
+#![feature(let_chains)]
 #![feature(min_specialization)]
 #![feature(never_type)]
 #![feature(rustc_attrs)]
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -564,14 +564,17 @@ fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, id: hir::ItemId) {
             check_opaque(tcx, id);
         }
         DefKind::ImplTraitPlaceholder => {
-            let parent = tcx.impl_trait_in_trait_parent(id.owner_id.to_def_id());
-            // Only check the validity of this opaque type if the function has a default body
-            if let hir::Node::TraitItem(hir::TraitItem {
-                kind: hir::TraitItemKind::Fn(_, hir::TraitFn::Provided(_)),
-                ..
-            }) = tcx.hir().get_by_def_id(parent.expect_local())
+            if let Some((fn_def_id, _)) =
+                tcx.def_path(id.owner_id.to_def_id()).get_impl_trait_in_trait_data()
             {
-                check_opaque(tcx, id);
+                // Only check the validity of this opaque type if the function has a default body
+                if let hir::Node::TraitItem(hir::TraitItem {
+                    kind: hir::TraitItemKind::Fn(_, hir::TraitFn::Provided(_)),
+                    ..
+                }) = tcx.hir().get_by_def_id(fn_def_id.as_local().unwrap())
+                {
+                    check_opaque(tcx, id);
+                }
             }
         }
         DefKind::TyAlias => {
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1020,15 +1020,20 @@ fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) ->
         | DefKind::InlineConst => true,
 
         DefKind::ImplTraitPlaceholder => {
-            let parent_def_id = tcx.impl_trait_in_trait_parent(def_id.to_def_id());
-            let assoc_item = tcx.associated_item(parent_def_id);
-            match assoc_item.container {
-                // Always encode an RPIT in an impl fn, since it always has a body
-                ty::AssocItemContainer::ImplContainer => true,
-                ty::AssocItemContainer::TraitContainer => {
-                    // Encode an RPIT for a trait only if the trait has a default body
-                    assoc_item.defaultness(tcx).has_value()
+            if let Some((fn_def_id, _)) =
+                tcx.def_path(def_id.to_def_id()).get_impl_trait_in_trait_data()
+            {
+                let assoc_item = tcx.associated_item(fn_def_id);
+                match assoc_item.container {
+                    // Always encode an RPIT in an impl fn, since it always has a body
+                    ty::AssocItemContainer::ImplContainer => true,
+                    ty::AssocItemContainer::TraitContainer => {
+                        // Encode an RPIT for a trait only if the trait has a default body
+                        assoc_item.defaultness(tcx).has_value()
+                    }
                 }
+            } else {
+                bug!();
             }
         }
 
diff --git a/compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs b/compiler/rustc_symbol_mangling/src/typeid/typeid_itanium_cxx_abi.rs
@@ -396,7 +396,8 @@ fn encode_ty_name<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) -> String {
             hir::definitions::DefPathData::ClosureExpr => "C",
             hir::definitions::DefPathData::Ctor => "c",
             hir::definitions::DefPathData::AnonConst => "k",
-            hir::definitions::DefPathData::ImplTrait => "i",
+            hir::definitions::DefPathData::ImplTrait
+            | hir::definitions::DefPathData::ImplTraitInTrait(..) => "i",
             hir::definitions::DefPathData::CrateRoot
             | hir::definitions::DefPathData::Use
             | hir::definitions::DefPathData::GlobalAsm
diff --git a/compiler/rustc_symbol_mangling/src/v0.rs b/compiler/rustc_symbol_mangling/src/v0.rs
@@ -782,7 +782,7 @@ impl<'tcx> Printer<'tcx> for &mut SymbolMangler<'tcx> {
             DefPathData::ClosureExpr => 'C',
             DefPathData::Ctor => 'c',
             DefPathData::AnonConst => 'k',
-            DefPathData::ImplTrait => 'i',
+            DefPathData::ImplTrait | DefPathData::ImplTraitInTrait(..) => 'i',
 
             // These should never show up as `path_append` arguments.
             DefPathData::CrateRoot
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
@@ -1324,7 +1324,13 @@ fn assemble_candidate_for_impl_trait_in_trait<'cx, 'tcx>(
 ) {
     let tcx = selcx.tcx();
     if tcx.def_kind(obligation.predicate.item_def_id) == DefKind::ImplTraitPlaceholder {
-        let trait_fn_def_id = tcx.impl_trait_in_trait_parent(obligation.predicate.item_def_id);
+        let trait_fn_def_id = if let Some((fn_def_id, _)) =
+            tcx.def_path(obligation.predicate.item_def_id).get_impl_trait_in_trait_data()
+        {
+            fn_def_id
+        } else {
+            tcx.impl_trait_in_trait_parent(obligation.predicate.item_def_id)
+        };
         // If we are trying to project an RPITIT with trait's default `Self` parameter,
         // then we must be within a default trait body.
         if obligation.predicate.self_ty()

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,9 @@`
`5`	`5`	`//! expressions) that are mostly just leftovers.`
`6`	`6`
`7`	`7`	`pub use crate::def_id::DefPathHash;`
`8`		`-use crate::def_id::{CrateNum, DefIndex, LocalDefId, StableCrateId, CRATE_DEF_INDEX, LOCAL_CRATE};`
	`8`	`+use crate::def_id::{`
	`9`	`+ CrateNum, DefId, DefIndex, LocalDefId, StableCrateId, CRATE_DEF_INDEX, LOCAL_CRATE,`
	`10`	`+};`
`9`	`11`	`use crate::def_path_hash_map::DefPathHashMap;`
`10`	`12`
`11`	`13`	`use rustc_data_structures::fx::FxHashMap;`
`@@ -245,6 +247,17 @@ impl DefPath {`
`245`	`247`
`246`	`248`	`s`
`247`	`249`	`}`
	`250`	`+`
	`251`	`+ pub fn get_impl_trait_in_trait_data(&self) -> Option<(DefId, Option<DefId>)> {`
	`252`	`+ if let Some(def_path_data) = self.data.last()`
	`253`	`+ && let DefPathData::ImplTraitInTrait(fn_def_id, of_trait) =`
	`254`	`+ def_path_data.data`
	`255`	`+ {`
	`256`	`+ Some((fn_def_id, of_trait))`
	`257`	`+ } else {`
	`258`	`+ None`
	`259`	`+ }`
	`260`	`+ }`
`248`	`261`	`}`
`249`	`262`
`250`	`263`	`#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Encodable, Decodable)]`
`@@ -281,6 +294,10 @@ pub enum DefPathData {`
`281`	`294`	`AnonConst,`
`282`	`295`	/// An `impl Trait` type node.
`283`	`296`	`ImplTrait,`
	`297`	+ /// An `impl Trait` type node inside a `trait` or inside an `impl` of a `trait`.
	`298`	+ /// On a `trait` the value is `(trait_fn_def_id, None)`.
	`299`	+ /// On an `impl` the value is `(impl_fn_def_id, Some(trait_rpit_def_id))`.
	`300`	`+ ImplTraitInTrait(DefId, Option<DefId>),`
`284`	`301`	`}`
`285`	`302`
`286`	`303`	`impl Definitions {`
`@@ -404,7 +421,7 @@ impl DefPathData {`
`404`	`421`	`TypeNs(name) \| ValueNs(name) \| MacroNs(name) \| LifetimeNs(name) => Some(name),`
`405`	`422`
`406`	`423`	`Impl \| ForeignMod \| CrateRoot \| Use \| GlobalAsm \| ClosureExpr \| Ctor \| AnonConst`
`407`		`- \| ImplTrait => None,`
	`424`	`+ \| ImplTrait \| ImplTraitInTrait(..) => None,`
`408`	`425`	`}`
`409`	`426`	`}`
`410`	`427`
`@@ -424,6 +441,7 @@ impl DefPathData {`
`424`	`441`	`Ctor => DefPathDataName::Anon { namespace: sym::constructor },`
`425`	`442`	`AnonConst => DefPathDataName::Anon { namespace: sym::constant },`
`426`	`443`	`ImplTrait => DefPathDataName::Anon { namespace: sym::opaque },`
	`444`	`+ ImplTraitInTrait(..) => DefPathDataName::Anon { namespace: sym::opaque },`
`427`	`445`	`}`
`428`	`446`	`}`
`429`	`447`	`}`