Remove DefKind::ImplTraitPlaceholder

spastorino · spastorino · commit 7d53d47de6b8 · 2022-11-21T09:50:36.000-03:00
diff --git a/compiler/rustc_hir/src/def.rs b/compiler/rustc_hir/src/def.rs
@@ -109,8 +109,6 @@ pub enum DefKind {
     InlineConst,
     /// Opaque type, aka `impl Trait`.
     OpaqueTy,
-    /// A return-position `impl Trait` in a trait definition
-    ImplTraitPlaceholder,
     Field,
     /// Lifetime parameter: the `'a` in `struct Foo<'a> { ... }`
     LifetimeParam,
@@ -140,7 +138,6 @@ impl DefKind {
                 panic!("impossible struct constructor")
             }
             DefKind::OpaqueTy => "opaque type",
-            DefKind::ImplTraitPlaceholder => "opaque type in trait",
             DefKind::TyAlias => "type alias",
             DefKind::TraitAlias => "trait alias",
             DefKind::AssocTy => "associated type",
@@ -220,8 +217,7 @@ impl DefKind {
             | DefKind::Use
             | DefKind::ForeignMod
             | DefKind::GlobalAsm
-            | DefKind::Impl
-            | DefKind::ImplTraitPlaceholder => None,
+            | DefKind::Impl => None,
         }
     }
 
@@ -258,7 +254,6 @@ impl DefKind {
             | DefKind::Use
             | DefKind::ForeignMod
             | DefKind::OpaqueTy
-            | DefKind::ImplTraitPlaceholder
             | DefKind::Impl
             | DefKind::Field
             | DefKind::TyParam
diff --git a/compiler/rustc_hir/src/target.rs b/compiler/rustc_hir/src/target.rs
@@ -102,7 +102,7 @@ impl Target {
             DefKind::ForeignMod => Target::ForeignMod,
             DefKind::GlobalAsm => Target::GlobalAsm,
             DefKind::TyAlias => Target::TyAlias,
-            DefKind::OpaqueTy | DefKind::ImplTraitPlaceholder => Target::OpaqueTy,
+            DefKind::OpaqueTy => Target::OpaqueTy,
             DefKind::Enum => Target::Enum,
             DefKind::Struct => Target::Struct,
             DefKind::Union => Target::Union,
diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -2406,7 +2406,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
 
         let span = path.span;
         match path.res {
-            Res::Def(DefKind::OpaqueTy | DefKind::ImplTraitPlaceholder, did) => {
+            Res::Def(DefKind::OpaqueTy, did) => {
                 // Check for desugared `impl Trait`.
                 assert!(ty::is_impl_trait_defn(tcx, did).is_none());
                 let item_segment = path.segments.split_last().unwrap();
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -561,9 +561,6 @@ fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, id: hir::ItemId) {
             check_union(tcx, id.owner_id.def_id);
         }
         DefKind::OpaqueTy => {
-            check_opaque(tcx, id);
-        }
-        DefKind::ImplTraitPlaceholder => {
             if let Some((fn_def_id, _)) =
                 tcx.def_path(id.owner_id.to_def_id()).get_impl_trait_in_trait_data()
             {
@@ -575,6 +572,8 @@ fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, id: hir::ItemId) {
                 {
                     check_opaque(tcx, id);
                 }
+            } else {
+                check_opaque(tcx, id);
             }
         }
         DefKind::TyAlias => {
diff --git a/compiler/rustc_hir_analysis/src/check/compare_method.rs b/compiler/rustc_hir_analysis/src/check/compare_method.rs
@@ -582,7 +582,7 @@ impl<'tcx> TypeFolder<'tcx> for ImplTraitInTraitCollector<'_, 'tcx> {
 
     fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
         if let ty::Projection(proj) = ty.kind()
-            && self.tcx().def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder
+            && self.tcx().def_path(proj.item_def_id).get_impl_trait_in_trait_data().is_some()
         {
             if let Some((ty, _)) = self.types.get(&proj.item_def_id) {
                 return *ty;
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -1,5 +1,4 @@
 use crate::constrained_generic_params::{identify_constrained_generic_params, Parameter};
-use hir::def::DefKind;
 use rustc_ast as ast;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
 use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder, ErrorGuaranteed};
@@ -1588,8 +1587,7 @@ fn check_return_position_impl_trait_in_trait_bounds<'tcx>(
         for arg in fn_output.walk() {
             if let ty::GenericArgKind::Type(ty) = arg.unpack()
                 && let ty::Projection(proj) = ty.kind()
-                && tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder
-                && let (trait_fn_def_id, _) = tcx.def_path(proj.item_def_id).get_impl_trait_in_trait_data().unwrap()
+                && let Some((trait_fn_def_id, _)) = tcx.def_path(proj.item_def_id).get_impl_trait_in_trait_data()
                 && trait_fn_def_id == fn_def_id.to_def_id()
             {
                 let bounds = wfcx.tcx().explicit_item_bounds(proj.item_def_id);
diff --git a/compiler/rustc_hir_typeck/src/closure.rs b/compiler/rustc_hir_typeck/src/closure.rs
@@ -2,7 +2,6 @@
 
 use super::{check_fn, Expectation, FnCtxt, GeneratorTypes};
 
-use hir::def::DefKind;
 use rustc_hir as hir;
 use rustc_hir::def_id::LocalDefId;
 use rustc_hir::lang_items::LangItem;
@@ -681,7 +680,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 .find_map(|(p, s)| get_future_output(p, s))?,
             ty::Error(_) => return None,
             ty::Projection(proj)
-                if self.tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder =>
+                if self.tcx.def_path(proj.item_def_id).get_impl_trait_in_trait_data().is_some() =>
             {
                 self.tcx
                     .bound_explicit_item_bounds(proj.item_def_id)
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -65,7 +65,6 @@ use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::{pluralize, struct_span_err, Diagnostic, ErrorGuaranteed, IntoDiagnosticArg};
 use rustc_errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString, MultiSpan};
 use rustc_hir as hir;
-use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::lang_items::LangItem;
@@ -1839,8 +1838,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
                             )
                         }
                         (true, ty::Projection(proj))
-                            if self.tcx.def_kind(proj.item_def_id)
-                                == DefKind::ImplTraitPlaceholder =>
+                            if self.tcx.def_path(proj.item_def_id).get_impl_trait_in_trait_data().is_some() =>
                         {
                             let sm = self.tcx.sess.source_map();
                             let pos = sm.lookup_char_pos(self.tcx.def_span(proj.item_def_id).lo());
diff --git a/compiler/rustc_infer/src/infer/opaque_types.rs b/compiler/rustc_infer/src/infer/opaque_types.rs
@@ -1,7 +1,6 @@
 use crate::errors::OpaqueHiddenTypeDiag;
 use crate::infer::{DefiningAnchor, InferCtxt, InferOk};
 use crate::traits;
-use hir::def::DefKind;
 use hir::def_id::{DefId, LocalDefId};
 use hir::{HirId, OpaqueTyOrigin};
 use rustc_data_structures::sync::Lrc;
@@ -556,8 +555,10 @@ impl<'tcx> InferCtxt<'tcx> {
                     // FIXME(RPITIT): Don't replace RPITITs with inference vars.
                     ty::Projection(projection_ty)
                         if !projection_ty.has_escaping_bound_vars()
-                            && tcx.def_kind(projection_ty.item_def_id)
-                                != DefKind::ImplTraitPlaceholder =>
+                            && tcx
+                                .def_path(projection_ty.item_def_id)
+                                .get_impl_trait_in_trait_data()
+                                .is_none() =>
                     {
                         self.infer_projection(
                             param_env,
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -820,7 +820,6 @@ fn should_encode_visibility(def_kind: DefKind) -> bool {
         | DefKind::Use
         | DefKind::ForeignMod
         | DefKind::OpaqueTy
-        | DefKind::ImplTraitPlaceholder
         | DefKind::Impl
         | DefKind::Field => true,
         DefKind::TyParam
@@ -853,7 +852,6 @@ fn should_encode_stability(def_kind: DefKind) -> bool {
         | DefKind::ForeignMod
         | DefKind::TyAlias
         | DefKind::OpaqueTy
-        | DefKind::ImplTraitPlaceholder
         | DefKind::Enum
         | DefKind::Union
         | DefKind::Impl
@@ -942,7 +940,6 @@ fn should_encode_variances(def_kind: DefKind) -> bool {
         | DefKind::ForeignMod
         | DefKind::TyAlias
         | DefKind::OpaqueTy
-        | DefKind::ImplTraitPlaceholder
         | DefKind::Impl
         | DefKind::Trait
         | DefKind::TraitAlias
@@ -979,7 +976,6 @@ fn should_encode_generics(def_kind: DefKind) -> bool {
         | DefKind::AnonConst
         | DefKind::InlineConst
         | DefKind::OpaqueTy
-        | DefKind::ImplTraitPlaceholder
         | DefKind::Impl
         | DefKind::Field
         | DefKind::TyParam
@@ -1008,7 +1004,6 @@ fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) ->
         | DefKind::Const
         | DefKind::Static(..)
         | DefKind::TyAlias
-        | DefKind::OpaqueTy
         | DefKind::ForeignTy
         | DefKind::Impl
         | DefKind::AssocFn
@@ -1019,7 +1014,7 @@ fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) ->
         | DefKind::AnonConst
         | DefKind::InlineConst => true,
 
-        DefKind::ImplTraitPlaceholder => {
+        DefKind::OpaqueTy => {
             if let Some((fn_def_id, _)) =
                 tcx.def_path(def_id.to_def_id()).get_impl_trait_in_trait_data()
             {
@@ -1033,7 +1028,7 @@ fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) ->
                     }
                 }
             } else {
-                bug!();
+                true
             }
         }
 
@@ -1076,7 +1071,6 @@ fn should_encode_const(def_kind: DefKind) -> bool {
         | DefKind::Static(..)
         | DefKind::TyAlias
         | DefKind::OpaqueTy
-        | DefKind::ImplTraitPlaceholder
         | DefKind::ForeignTy
         | DefKind::Impl
         | DefKind::AssocFn
@@ -1117,7 +1111,7 @@ fn should_encode_trait_impl_trait_tys<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId) ->
     tcx.fn_sig(trait_item_def_id).skip_binder().output().walk().any(|arg| {
         if let ty::GenericArgKind::Type(ty) = arg.unpack()
             && let ty::Projection(data) = ty.kind()
-            && tcx.def_kind(data.item_def_id) == DefKind::ImplTraitPlaceholder
+            && tcx.def_path(data.item_def_id).get_impl_trait_in_trait_data().is_some()
         {
             true
         } else {
diff --git a/compiler/rustc_metadata/src/rmeta/table.rs b/compiler/rustc_metadata/src/rmeta/table.rs
@@ -90,7 +90,6 @@ fixed_size_enum! {
         ( AnonConst                                )
         ( InlineConst                              )
         ( OpaqueTy                                 )
-        ( ImplTraitPlaceholder                     )
         ( Field                                    )
         ( LifetimeParam                            )
         ( GlobalAsm                                )
diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs
@@ -209,13 +209,7 @@ impl<'hir> Map<'hir> {
                 ItemKind::Fn(..) => DefKind::Fn,
                 ItemKind::Macro(_, macro_kind) => DefKind::Macro(macro_kind),
                 ItemKind::Mod(..) => DefKind::Mod,
-                ItemKind::OpaqueTy(ref opaque) => {
-                    if opaque.in_trait {
-                        DefKind::ImplTraitPlaceholder
-                    } else {
-                        DefKind::OpaqueTy
-                    }
-                }
+                ItemKind::OpaqueTy(..) => DefKind::OpaqueTy,
                 ItemKind::TyAlias(..) => DefKind::TyAlias,
                 ItemKind::Enum(..) => DefKind::Enum,
                 ItemKind::Struct(..) => DefKind::Struct,
diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs
@@ -2,7 +2,6 @@ use crate::traits::{ObligationCause, ObligationCauseCode};
 use crate::ty::diagnostics::suggest_constraining_type_param;
 use crate::ty::print::{FmtPrinter, Printer};
 use crate::ty::{self, BoundRegionKind, Region, Ty, TyCtxt};
-use hir::def::DefKind;
 use rustc_errors::Applicability::{MachineApplicable, MaybeIncorrect};
 use rustc_errors::{pluralize, Diagnostic, MultiSpan};
 use rustc_hir as hir;
@@ -436,7 +435,7 @@ impl<'tcx> TyCtxt<'tcx> {
                         diag.note("an associated type was expected, but a different one was found");
                     }
                     (ty::Param(p), ty::Projection(proj)) | (ty::Projection(proj), ty::Param(p))
-                        if self.def_kind(proj.item_def_id) != DefKind::ImplTraitPlaceholder =>
+                        if self.def_path(proj.item_def_id).get_impl_trait_in_trait_data().is_none() =>
                     {
                         let generics = self.generics_of(body_owner_def_id);
                         let p_span = self.def_span(generics.type_param(p, self).def_id);
@@ -546,7 +545,7 @@ impl<T> Trait<T> for X {
                             diag.span_label(p_span, "this type parameter");
                         }
                     }
-                    (ty::Projection(proj_ty), _) if self.def_kind(proj_ty.item_def_id) != DefKind::ImplTraitPlaceholder => {
+                    (ty::Projection(proj_ty), _) if self.def_path(proj_ty.item_def_id).get_impl_trait_in_trait_data().is_none() => {
                         self.expected_projection(
                             diag,
                             proj_ty,
@@ -555,7 +554,7 @@ impl<T> Trait<T> for X {
                             cause.code(),
                         );
                     }
-                    (_, ty::Projection(proj_ty)) if self.def_kind(proj_ty.item_def_id) != DefKind::ImplTraitPlaceholder => {
+                    (_, ty::Projection(proj_ty)) if self.def_path(proj_ty.item_def_id).get_impl_trait_in_trait_data().is_none() => {
                         let msg = format!(
                             "consider constraining the associated type `{}` to `{}`",
                             values.found, values.expected,
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -640,7 +640,11 @@ pub trait PrettyPrinter<'tcx>:
             }
             ty::Projection(ref data) => {
                 if !(self.should_print_verbose() || NO_QUERIES.with(|q| q.get()))
-                    && self.tcx().def_kind(data.item_def_id) == DefKind::ImplTraitPlaceholder
+                    && self
+                        .tcx()
+                        .def_path(data.item_def_id)
+                        .get_impl_trait_in_trait_data()
+                        .is_some()
                 {
                     return self.pretty_print_opaque_impl_type(data.item_def_id, data.substs);
                 } else {
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -1147,7 +1147,7 @@ impl<'tcx> ProjectionTy<'tcx> {
     pub fn trait_def_id(&self, tcx: TyCtxt<'tcx>) -> DefId {
         match tcx.def_kind(self.item_def_id) {
             DefKind::AssocTy | DefKind::AssocConst => tcx.parent(self.item_def_id),
-            DefKind::ImplTraitPlaceholder => {
+            DefKind::OpaqueTy => {
                 let (fn_def_id, _) =
                     tcx.def_path(self.item_def_id).get_impl_trait_in_trait_data().unwrap();
 
diff --git a/compiler/rustc_monomorphize/src/polymorphize.rs b/compiler/rustc_monomorphize/src/polymorphize.rs
@@ -171,7 +171,6 @@ fn mark_used_by_default_parameters<'tcx>(
         | DefKind::AnonConst
         | DefKind::InlineConst
         | DefKind::OpaqueTy
-        | DefKind::ImplTraitPlaceholder
         | DefKind::Field
         | DefKind::LifetimeParam
         | DefKind::GlobalAsm
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
@@ -123,8 +123,10 @@ where
         projection: ty::ProjectionTy<'tcx>,
     ) -> ControlFlow<V::BreakTy> {
         let tcx = self.def_id_visitor.tcx();
-        let (trait_ref, assoc_substs) = if tcx.def_kind(projection.item_def_id)
-            != DefKind::ImplTraitPlaceholder
+        let (trait_ref, assoc_substs) = if tcx
+            .def_path(projection.item_def_id)
+            .get_impl_trait_in_trait_data()
+            .is_none()
         {
             projection.trait_ref_and_own_substs(tcx)
         } else {
@@ -590,7 +592,6 @@ impl<'tcx> EmbargoVisitor<'tcx> {
             | DefKind::ForeignTy
             | DefKind::Fn
             | DefKind::OpaqueTy
-            | DefKind::ImplTraitPlaceholder
             | DefKind::AssocFn
             | DefKind::Trait
             | DefKind::TyParam
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -950,7 +950,6 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
                 | DefKind::TyAlias
                 | DefKind::ForeignTy
                 | DefKind::OpaqueTy
-                | DefKind::ImplTraitPlaceholder
                 | DefKind::TraitAlias
                 | DefKind::AssocTy,
                 _,
diff --git a/compiler/rustc_save_analysis/src/lib.rs b/compiler/rustc_save_analysis/src/lib.rs
@@ -684,7 +684,6 @@ impl<'tcx> SaveContext<'tcx> {
                 | HirDefKind::AssocTy
                 | HirDefKind::Trait
                 | HirDefKind::OpaqueTy
-                | HirDefKind::ImplTraitPlaceholder
                 | HirDefKind::TyParam,
                 def_id,
             ) => Some(Ref { kind: RefKind::Type, span, ref_id: id_from_def_id(def_id) }),
diff --git a/compiler/rustc_trait_selection/src/traits/object_safety.rs b/compiler/rustc_trait_selection/src/traits/object_safety.rs
@@ -13,7 +13,6 @@ use super::{elaborate_predicates, elaborate_trait_ref};
 use crate::infer::TyCtxtInferExt;
 use crate::traits::query::evaluate_obligation::InferCtxtExt;
 use crate::traits::{self, Obligation, ObligationCause};
-use hir::def::DefKind;
 use rustc_errors::{DelayDm, FatalError, MultiSpan};
 use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
@@ -797,7 +796,11 @@ fn contains_illegal_self_type_reference<'tcx, T: TypeVisitable<'tcx>>(
                     }
                 }
                 ty::Projection(ref data)
-                    if self.tcx.def_kind(data.item_def_id) == DefKind::ImplTraitPlaceholder =>
+                    if self
+                        .tcx
+                        .def_path(data.item_def_id)
+                        .get_impl_trait_in_trait_data()
+                        .is_some() =>
                 {
                     // We'll deny these later in their own pass
                     ControlFlow::CONTINUE
@@ -878,7 +881,7 @@ pub fn contains_illegal_impl_trait_in_trait<'tcx>(
     ty.skip_binder().walk().find_map(|arg| {
         if let ty::GenericArgKind::Type(ty) = arg.unpack()
             && let ty::Projection(proj) = ty.kind()
-            && tcx.def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder
+            && tcx.def_path(proj.item_def_id).get_impl_trait_in_trait_data().is_some()
         {
             Some(MethodViolationCode::ReferencesImplTraitInTrait(tcx.def_span(proj.item_def_id)))
         } else {
diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs
diff --git a/compiler/rustc_ty_utils/src/implied_bounds.rs b/compiler/rustc_ty_utils/src/implied_bounds.rs
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
diff --git a/src/librustdoc/formats/item_type.rs b/src/librustdoc/formats/item_type.rs
diff --git a/src/librustdoc/passes/collect_intra_doc_links.rs b/src/librustdoc/passes/collect_intra_doc_links.rs

Original file line number	Diff line number	Diff line change
`@@ -561,9 +561,6 @@ fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, id: hir::ItemId) {`
`561`	`561`	`check_union(tcx, id.owner_id.def_id);`
`562`	`562`	`}`
`563`	`563`	`DefKind::OpaqueTy => {`
`564`		`- check_opaque(tcx, id);`
`565`		`- }`
`566`		`- DefKind::ImplTraitPlaceholder => {`
`567`	`564`	`if let Some((fn_def_id, _)) =`
`568`	`565`	`tcx.def_path(id.owner_id.to_def_id()).get_impl_trait_in_trait_data()`
`569`	`566`	`{`
`@@ -575,6 +572,8 @@ fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, id: hir::ItemId) {`
`575`	`572`	`{`
`576`	`573`	`check_opaque(tcx, id);`
`577`	`574`	`}`
	`575`	`+ } else {`
	`576`	`+ check_opaque(tcx, id);`
`578`	`577`	`}`
`579`	`578`	`}`
`580`	`579`	`DefKind::TyAlias => {`
Original file line number	Diff line number	Diff line change
`@@ -582,7 +582,7 @@ impl<'tcx> TypeFolder<'tcx> for ImplTraitInTraitCollector<'_, 'tcx> {`
`582`	`582`
`583`	`583`	`fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {`
`584`	`584`	`if let ty::Projection(proj) = ty.kind()`
`585`		`- && self.tcx().def_kind(proj.item_def_id) == DefKind::ImplTraitPlaceholder`
	`585`	`+ && self.tcx().def_path(proj.item_def_id).get_impl_trait_in_trait_data().is_some()`
`586`	`586`	`{`
`587`	`587`	`if let Some((ty, _)) = self.types.get(&proj.item_def_id) {`
`588`	`588`	`return *ty;`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,6 @@ use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};`
`65`	`65`	`use rustc_errors::{pluralize, struct_span_err, Diagnostic, ErrorGuaranteed, IntoDiagnosticArg};`
`66`	`66`	`use rustc_errors::{Applicability, DiagnosticBuilder, DiagnosticStyledString, MultiSpan};`
`67`	`67`	`use rustc_hir as hir;`
`68`		`-use rustc_hir::def::DefKind;`
`69`	`68`	`use rustc_hir::def_id::{DefId, LocalDefId};`
`70`	`69`	`use rustc_hir::intravisit::Visitor;`
`71`	`70`	`use rustc_hir::lang_items::LangItem;`
`@@ -1839,8 +1838,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {`
`1839`	`1838`	`)`
`1840`	`1839`	`}`
`1841`	`1840`	`(true, ty::Projection(proj))`
`1842`		`- if self.tcx.def_kind(proj.item_def_id)`
`1843`		`- == DefKind::ImplTraitPlaceholder =>`
	`1841`	`+ if self.tcx.def_path(proj.item_def_id).get_impl_trait_in_trait_data().is_some() =>`
`1844`	`1842`	`{`
`1845`	`1843`	`let sm = self.tcx.sess.source_map();`
`1846`	`1844`	`let pos = sm.lookup_char_pos(self.tcx.def_span(proj.item_def_id).lo());`