Introduce impl_is_of_trait

Author: camsteffen

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -535,7 +535,7 @@ impl<'ll, 'tcx> DebugInfoCodegenMethods<'tcx> for CodegenCx<'ll, 'tcx> {
             // subroutine's self-type.
             if let Some(impl_def_id) = cx.tcx.impl_of_assoc(instance.def_id()) {
                 // If the method does *not* belong to a trait, proceed
-                if cx.tcx.trait_id_of_impl(impl_def_id).is_none() {
+                if !cx.tcx.impl_is_of_trait(impl_def_id) {
                     let impl_self_ty = cx.tcx.instantiate_and_normalize_erasing_regions(
                         instance.args,
                         cx.typing_env(),

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -198,7 +198,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
                 }
             }
             ImplItemKind::Type(ty) => {
-                if tcx.impl_trait_ref(tcx.hir_get_parent_item(hir_id)).is_none() {
+                if !tcx.impl_is_of_trait(tcx.hir_get_parent_item(hir_id)) {
                     check_feature_inherent_assoc_ty(tcx, item.span);
                 }
 

compiler/rustc_hir_typeck/src/method/confirm.rs

@@ -284,7 +284,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
             probe::InherentImplPick => {
                 let impl_def_id = pick.item.container_id(self.tcx);
                 assert!(
-                    self.tcx.impl_trait_ref(impl_def_id).is_none(),
+                    !self.tcx.impl_is_of_trait(impl_def_id),
                     "impl {impl_def_id:?} is not an inherent impl"
                 );
                 self.fresh_args_for_item(self.span, impl_def_id)

compiler/rustc_lint/src/nonstandard_style.rs

@@ -31,10 +31,13 @@ pub(crate) fn method_context(cx: &LateContext<'_>, id: LocalDefId) -> MethodLate
     let item = cx.tcx.associated_item(id);
     match item.container {
         ty::AssocItemContainer::Trait => MethodLateContext::TraitAutoImpl,
-        ty::AssocItemContainer::Impl => match cx.tcx.impl_trait_ref(item.container_id(cx.tcx)) {
-            Some(_) => MethodLateContext::TraitImpl,
-            None => MethodLateContext::PlainImpl,
-        },
+        ty::AssocItemContainer::Impl => {
+            if cx.tcx.impl_is_of_trait(item.container_id(cx.tcx)) {
+                MethodLateContext::TraitImpl
+            } else {
+                MethodLateContext::PlainImpl
+            }
+        }
     }
 }
 

compiler/rustc_lint/src/pass_by_value.rs

@@ -25,7 +25,7 @@ impl<'tcx> LateLintPass<'tcx> for PassByValue {
         match &ty.kind {
             TyKind::Ref(_, hir::MutTy { ty: inner_ty, mutbl: hir::Mutability::Not }) => {
                 if let Some(impl_did) = cx.tcx.impl_of_assoc(ty.hir_id.owner.to_def_id()) {
-                    if cx.tcx.impl_trait_ref(impl_did).is_some() {
+                    if cx.tcx.impl_is_of_trait(impl_did) {
                         return;
                     }
                 }

compiler/rustc_lint/src/types.rs

@@ -1907,7 +1907,7 @@ impl InvalidAtomicOrdering {
             && let Some(impl_did) = cx.tcx.impl_of_assoc(m_def_id)
             && let Some(adt) = cx.tcx.type_of(impl_did).instantiate_identity().ty_adt_def()
             // skip extension traits, only lint functions from the standard library
-            && cx.tcx.trait_id_of_impl(impl_did).is_none()
+            && !cx.tcx.impl_is_of_trait(impl_did)
             && let parent = cx.tcx.parent(adt.did())
             && cx.tcx.is_diagnostic_item(sym::atomic_mod, parent)
             && ATOMIC_TYPES.contains(&cx.tcx.item_name(adt.did()))

compiler/rustc_middle/src/middle/privacy.rs

@@ -183,8 +183,7 @@ impl EffectiveVisibilities {
             let is_impl = matches!(tcx.def_kind(def_id), DefKind::Impl { .. });
             let is_associated_item_in_trait_impl = tcx
                 .impl_of_assoc(def_id.to_def_id())
-                .and_then(|impl_id| tcx.trait_id_of_impl(impl_id))
-                .is_some();
+                .is_some_and(|impl_id| tcx.impl_is_of_trait(impl_id));
             if !is_impl && !is_associated_item_in_trait_impl {
                 let nominal_vis = tcx.visibility(def_id);
                 if !nominal_vis.is_at_least(ev.reachable, tcx) {

compiler/rustc_middle/src/ty/context.rs

@@ -2263,7 +2263,7 @@ impl<'tcx> TyCtxt<'tcx> {
     /// Checks if the bound region is in Impl Item.
     pub fn is_bound_region_in_impl_item(self, suitable_region_binding_scope: LocalDefId) -> bool {
         let container_id = self.parent(suitable_region_binding_scope.to_def_id());
-        if self.impl_trait_ref(container_id).is_some() {
+        if self.impl_is_of_trait(container_id) {
             // For now, we do not try to target impls of traits. This is
             // because this message is going to suggest that the user
             // change the fn signature, but they may not be free to do so,

compiler/rustc_middle/src/ty/mod.rs

@@ -2009,6 +2009,14 @@ impl<'tcx> TyCtxt<'tcx> {
         self.impl_trait_header(def_id).map_or(ty::ImplPolarity::Positive, |h| h.polarity)
     }
 
+    pub fn impl_is_of_trait(self, def_id: impl IntoQueryParam<DefId>) -> bool {
+        let def_id = def_id.into_query_param();
+        let DefKind::Impl { of_trait } = self.def_kind(def_id) else {
+            panic!("expected Impl for {def_id:?}");
+        };
+        of_trait
+    }
+
     /// Given an `impl_id`, return the trait it implements.
     /// Return `None` if this is an inherent impl.
     pub fn impl_trait_ref(

compiler/rustc_passes/src/dead.rs

@@ -436,7 +436,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> {
             }
             Node::ImplItem(impl_item) => {
                 let item = self.tcx.local_parent(impl_item.owner_id.def_id);
-                if self.tcx.impl_trait_ref(item).is_none() {
+                if !self.tcx.impl_is_of_trait(item) {
                     //// If it's a type whose items are live, then it's live, too.
                     //// This is done to handle the case where, for example, the static
                     //// method of a private type is used, but the type itself is never