de-HIRify check_variances_for_type_defn

Author: oli-obk

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -309,11 +309,11 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
             check_item_type(tcx, def_id, ty.span, UnsizedHandling::Forbid)
         }
         hir::ItemKind::Struct(_, hir_generics) => check_type_defn(tcx, item, false)
-            .and(check_variances_for_type_defn(tcx, item, hir_generics)),
+            .and(check_variances_for_type_defn(tcx, item.owner_id.def_id, hir_generics)),
         hir::ItemKind::Union(_, hir_generics) => check_type_defn(tcx, item, true)
-            .and(check_variances_for_type_defn(tcx, item, hir_generics)),
+            .and(check_variances_for_type_defn(tcx, item.owner_id.def_id, hir_generics)),
         hir::ItemKind::Enum(_, hir_generics) => check_type_defn(tcx, item, true)
-            .and(check_variances_for_type_defn(tcx, item, hir_generics)),
+            .and(check_variances_for_type_defn(tcx, item.owner_id.def_id, hir_generics)),
         hir::ItemKind::Trait(..) => check_trait(tcx, item),
         hir::ItemKind::TraitAlias(..) => check_trait(tcx, item),
         // `ForeignItem`s are handled separately.
@@ -323,7 +323,7 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
                 // Bounds of lazy type aliases and of eager ones that contain opaque types are respected.
                 // E.g: `type X = impl Trait;`, `type X = (impl Trait, Y);`.
                 check_item_type(tcx, def_id, hir_ty.span, UnsizedHandling::Allow)
-                    .and(check_variances_for_type_defn(tcx, item, hir_generics))
+                    .and(check_variances_for_type_defn(tcx, item.owner_id.def_id, hir_generics))
             } else {
                 Ok(())
             }
@@ -1801,30 +1801,30 @@ fn receiver_is_implemented<'tcx>(
 
 fn check_variances_for_type_defn<'tcx>(
     tcx: TyCtxt<'tcx>,
-    item: &hir::Item<'tcx>,
+    item: LocalDefId,
     hir_generics: &hir::Generics<'tcx>,
 ) -> Result<(), ErrorGuaranteed> {
-    let identity_args = ty::GenericArgs::identity_for_item(tcx, item.owner_id);
+    let identity_args = ty::GenericArgs::identity_for_item(tcx, item);
 
-    match item.kind {
-        ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) => {
-            for field in tcx.adt_def(item.owner_id).all_fields() {
+    match tcx.def_kind(item) {
+        DefKind::Enum | DefKind::Struct | DefKind::Union => {
+            for field in tcx.adt_def(item).all_fields() {
                 field.ty(tcx, identity_args).error_reported()?;
             }
         }
-        ItemKind::TyAlias(..) => {
+        DefKind::TyAlias => {
             assert!(
-                tcx.type_alias_is_lazy(item.owner_id),
+                tcx.type_alias_is_lazy(item),
                 "should not be computing variance of non-weak type alias"
             );
-            tcx.type_of(item.owner_id).skip_binder().error_reported()?;
+            tcx.type_of(item).skip_binder().error_reported()?;
         }
-        kind => span_bug!(item.span, "cannot compute the variances of {kind:?}"),
+        kind => span_bug!(tcx.def_span(item), "cannot compute the variances of {kind:?}"),
     }
 
-    let ty_predicates = tcx.predicates_of(item.owner_id);
+    let ty_predicates = tcx.predicates_of(item);
     assert_eq!(ty_predicates.parent, None);
-    let variances = tcx.variances_of(item.owner_id);
+    let variances = tcx.variances_of(item);
 
     let mut constrained_parameters: FxHashSet<_> = variances
         .iter()
@@ -1837,7 +1837,7 @@ fn check_variances_for_type_defn<'tcx>(
 
     // Lazily calculated because it is only needed in case of an error.
     let explicitly_bounded_params = LazyCell::new(|| {
-        let icx = crate::collect::ItemCtxt::new(tcx, item.owner_id.def_id);
+        let icx = crate::collect::ItemCtxt::new(tcx, item);
         hir_generics
             .predicates
             .iter()
@@ -1853,7 +1853,7 @@ fn check_variances_for_type_defn<'tcx>(
             .collect::<FxHashSet<_>>()
     });
 
-    let ty_generics = tcx.generics_of(item.owner_id);
+    let ty_generics = tcx.generics_of(item);
 
     let mut res = Ok(());
 
@@ -1886,7 +1886,7 @@ fn check_variances_for_type_defn<'tcx>(
             hir::ParamName::Error => {}
             _ => {
                 let has_explicit_bounds = explicitly_bounded_params.contains(&parameter);
-                res = Err(report_bivariance(tcx, hir_param, has_explicit_bounds, item.kind));
+                res = Err(report_bivariance(tcx, hir_param, has_explicit_bounds, item));
             }
         }
     }
@@ -1897,12 +1897,12 @@ fn report_bivariance(
     tcx: TyCtxt<'_>,
     param: &rustc_hir::GenericParam<'_>,
     has_explicit_bounds: bool,
-    item_kind: ItemKind<'_>,
+    item: LocalDefId,
 ) -> ErrorGuaranteed {
     let param_name = param.name.ident();
 
-    let help = match item_kind {
-        ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) => {
+    let help = match tcx.def_kind(item) {
+        DefKind::Enum | DefKind::Struct | DefKind::Union => {
             if let Some(def_id) = tcx.lang_items().phantom_data() {
                 errors::UnusedGenericParameterHelp::Adt {
                     param_name,
@@ -1912,7 +1912,7 @@ fn report_bivariance(
                 errors::UnusedGenericParameterHelp::AdtNoPhantomData { param_name }
             }
         }
-        ItemKind::TyAlias(..) => errors::UnusedGenericParameterHelp::TyAlias { param_name },
+        DefKind::TyAlias => errors::UnusedGenericParameterHelp::TyAlias { param_name },
         item_kind => bug!("report_bivariance: unexpected item kind: {item_kind:?}"),
     };