Use AssocItemContainer more

Author: camsteffen

compiler/rustc_hir_typeck/src/method/confirm.rs

@@ -272,11 +272,13 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
     ) -> GenericArgsRef<'tcx> {
         match pick.kind {
             probe::InherentImplPick => {
-                let impl_def_id = pick.item.container_id(self.tcx);
-                assert!(
-                    self.tcx.impl_trait_ref(impl_def_id).is_none(),
-                    "impl {impl_def_id:?} is not an inherent impl"
+                assert_eq!(
+                    pick.item.container,
+                    ty::AssocItemContainer::InherentImpl,
+                    "{:?} is not in an inherent impl",
+                    pick.item.def_id,
                 );
+                let impl_def_id = pick.item.container_id(self.tcx);
                 self.fresh_args_for_item(self.span, impl_def_id)
             }
 

compiler/rustc_lint/src/nonstandard_style.rs

@@ -20,11 +20,6 @@ use crate::lints::{
 };
 use crate::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 
-fn assoc_item_in_trait_impl(cx: &LateContext<'_>, ii: &hir::ImplItem<'_>) -> bool {
-    let item = cx.tcx.associated_item(ii.owner_id);
-    item.trait_item_def_id.is_some()
-}
-
 declare_lint! {
     /// The `non_camel_case_types` lint detects types, variants, traits and
     /// type parameters that don't have camel case names.
@@ -592,7 +587,7 @@ impl<'tcx> LateLintPass<'tcx> for NonUpperCaseGlobals {
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, ii: &hir::ImplItem<'_>) {
         if let hir::ImplItemKind::Const(..) = ii.kind
-            && !assoc_item_in_trait_impl(cx, ii)
+            && cx.tcx.associated_item(ii.owner_id).container != AssocItemContainer::TraitImpl
         {
             NonUpperCaseGlobals::check_upper_case(cx, "associated constant", None, &ii.ident);
         }

compiler/rustc_lint/src/types.rs

@@ -9,8 +9,8 @@ use rustc_hir::{AmbigArg, Expr, ExprKind, HirId, LangItem};
 use rustc_middle::bug;
 use rustc_middle::ty::layout::{LayoutOf, SizeSkeleton};
 use rustc_middle::ty::{
-    self, Adt, AdtKind, GenericArgsRef, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
-    TypeVisitableExt,
+    self, Adt, AdtKind, AssocItemContainer, GenericArgsRef, Ty, TyCtxt, TypeSuperVisitable,
+    TypeVisitable, TypeVisitableExt,
 };
 use rustc_session::{declare_lint, declare_lint_pass, impl_lint_pass};
 use rustc_span::def_id::LocalDefId;
@@ -1904,10 +1904,10 @@ impl InvalidAtomicOrdering {
         if let ExprKind::MethodCall(method_path, _, args, _) = &expr.kind
             && recognized_names.contains(&method_path.ident.name)
             && let Some(m_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
-            && 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.associated_item(m_def_id).container == AssocItemContainer::InherentImpl
+            && let impl_id = cx.tcx.parent(m_def_id)
+            && let Some(adt) = cx.tcx.type_of(impl_id).instantiate_identity().ty_adt_def()
             && 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

@@ -8,6 +8,7 @@ use rustc_data_structures::fx::{FxIndexMap, IndexEntry};
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_hir::def::DefKind;
 use rustc_macros::HashStable;
+use rustc_middle::ty::AssocItemContainer;
 use rustc_query_system::ich::StableHashingContext;
 use rustc_span::def_id::{CRATE_DEF_ID, LocalDefId};
 
@@ -180,11 +181,11 @@ impl EffectiveVisibilities {
             // All effective visibilities except `reachable_through_impl_trait` are limited to
             // nominal visibility. For some items nominal visibility doesn't make sense so we
             // don't check this condition for them.
-            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();
+            let def_kind = tcx.def_kind(def_id);
+            let is_impl = matches!(def_kind, DefKind::Impl { .. });
+            let is_associated_item_in_trait_impl = def_kind.is_assoc()
+                && tcx.associated_item(def_id.to_def_id()).container
+                    == AssocItemContainer::TraitImpl;
             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_passes/src/check_attr.rs

@@ -33,7 +33,7 @@ use rustc_middle::middle::resolve_bound_vars::ObjectLifetimeDefault;
 use rustc_middle::query::Providers;
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
-use rustc_middle::ty::{self, TyCtxt, TypingMode};
+use rustc_middle::ty::{self, AssocItemContainer, TyCtxt, TypingMode};
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::CrateType;
 use rustc_session::lint;
@@ -2662,8 +2662,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     fn check_type_const(&self, hir_id: HirId, attr_span: Span, target: Target) {
         let tcx = self.tcx;
         if target == Target::AssocConst
-            && let parent = tcx.parent(hir_id.expect_owner().to_def_id())
-            && self.tcx.def_kind(parent) == DefKind::Trait
+            && tcx.associated_item(hir_id.expect_owner().to_def_id()).container
+                == AssocItemContainer::Trait
         {
             return;
         } else {

compiler/rustc_trait_selection/src/error_reporting/traits/call_kind.rs

@@ -2,7 +2,6 @@
 //! as well as errors when attempting to call a non-const function in a const
 //! context.
 
-use rustc_hir::def::DefKind;
 use rustc_hir::def_id::DefId;
 use rustc_hir::{LangItem, lang_items};
 use rustc_middle::ty::{AssocItemContainer, GenericArgsRef, Instance, Ty, TyCtxt, TypingEnv};
@@ -106,8 +105,8 @@ pub fn call_kind<'tcx>(
         );
         let deref_target_span = if let Ok(Some(instance)) =
             Instance::try_resolve(tcx, typing_env, method_did, method_args)
+            && tcx.associated_item(instance.def_id()).container == AssocItemContainer::TraitImpl
             && let instance_parent_def_id = tcx.parent(instance.def_id())
-            && matches!(tcx.def_kind(instance_parent_def_id), DefKind::Impl { .. })
             && let Ok(instance) =
                 specialization_graph::assoc_def(tcx, instance_parent_def_id, deref_target_def_id)
             && instance.is_final()

compiler/rustc_trait_selection/src/traits/normalize.rs

@@ -11,8 +11,8 @@ use rustc_macros::extension;
 use rustc_middle::span_bug;
 use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty::{
-    self, AliasTerm, Term, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitable,
-    TypeVisitableExt, TypingMode,
+    self, AliasTerm, AssocItemContainer, Term, Ty, TyCtxt, TypeFoldable, TypeFolder,
+    TypeSuperFoldable, TypeVisitable, TypeVisitableExt, TypingMode,
 };
 use tracing::{debug, instrument};
 
@@ -450,14 +450,13 @@ impl<'a, 'b, 'tcx> TypeFolder<TyCtxt<'tcx>> for AssocTypeNormalizer<'a, 'b, 'tcx
             };
 
             let ct = match tcx.def_kind(uv.def) {
-                DefKind::AssocConst => match tcx.def_kind(tcx.parent(uv.def)) {
-                    DefKind::Trait => self.normalize_trait_projection(uv.into()),
-                    DefKind::Impl { of_trait: false } => {
+                DefKind::AssocConst => match tcx.associated_item(uv.def).container {
+                    AssocItemContainer::Trait => self.normalize_trait_projection(uv.into()),
+                    AssocItemContainer::InherentImpl => {
                         self.normalize_inherent_projection(uv.into())
                     }
-                    kind => unreachable!(
-                        "unexpected `DefKind` for const alias' resolution's parent def: {:?}",
-                        kind
+                    AssocItemContainer::TraitImpl => unreachable!(
+                        "unexpected `TraitImpl` container for const alias' resolution's parent def",
                     ),
                 },
                 DefKind::Const | DefKind::AnonConst => self.normalize_free_alias(uv.into()),

compiler/rustc_trait_selection/src/traits/wf.rs

@@ -11,8 +11,8 @@ use rustc_hir::lang_items::LangItem;
 use rustc_infer::traits::{ObligationCauseCode, PredicateObligations};
 use rustc_middle::bug;
 use rustc_middle::ty::{
-    self, GenericArgsRef, Term, TermKind, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
-    TypeVisitableExt, TypeVisitor,
+    self, AssocItemContainer, GenericArgsRef, Term, TermKind, Ty, TyCtxt, TypeSuperVisitable,
+    TypeVisitable, TypeVisitableExt, TypeVisitor,
 };
 use rustc_session::parse::feature_err;
 use rustc_span::def_id::{DefId, LocalDefId};
@@ -984,7 +984,7 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                     ));
 
                     if tcx.def_kind(uv.def) == DefKind::AssocConst
-                        && tcx.def_kind(tcx.parent(uv.def)) == (DefKind::Impl { of_trait: false })
+                        && tcx.associated_item(uv.def).container == AssocItemContainer::InherentImpl
                     {
                         self.add_wf_preds_for_inherent_projection(uv.into());
                         return; // Subtree is handled by above function