Make check_variances_for_type_defn fallible

Author: oli-obk

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -308,21 +308,12 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
         hir::ItemKind::Const(ty, ..) => {
             check_item_type(tcx, def_id, ty.span, UnsizedHandling::Forbid)
         }
-        hir::ItemKind::Struct(_, hir_generics) => {
-            let res = check_type_defn(tcx, item, false);
-            check_variances_for_type_defn(tcx, item, hir_generics);
-            res
-        }
-        hir::ItemKind::Union(_, hir_generics) => {
-            let res = check_type_defn(tcx, item, true);
-            check_variances_for_type_defn(tcx, item, hir_generics);
-            res
-        }
-        hir::ItemKind::Enum(_, hir_generics) => {
-            let res = check_type_defn(tcx, item, true);
-            check_variances_for_type_defn(tcx, item, hir_generics);
-            res
-        }
+        hir::ItemKind::Struct(_, hir_generics) => check_type_defn(tcx, item, false)
+            .and(check_variances_for_type_defn(tcx, item, hir_generics)),
+        hir::ItemKind::Union(_, hir_generics) => check_type_defn(tcx, item, true)
+            .and(check_variances_for_type_defn(tcx, item, hir_generics)),
+        hir::ItemKind::Enum(_, hir_generics) => check_type_defn(tcx, item, true)
+            .and(check_variances_for_type_defn(tcx, item, hir_generics)),
         hir::ItemKind::Trait(..) => check_trait(tcx, item),
         hir::ItemKind::TraitAlias(..) => check_trait(tcx, item),
         // `ForeignItem`s are handled separately.
@@ -331,9 +322,8 @@ fn check_item<'tcx>(tcx: TyCtxt<'tcx>, item: &'tcx hir::Item<'tcx>) -> Result<()
             if tcx.type_alias_is_lazy(item.owner_id) {
                 // 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);`.
-                let res = check_item_type(tcx, def_id, hir_ty.span, UnsizedHandling::Allow);
-                check_variances_for_type_defn(tcx, item, hir_generics);
-                res
+                check_item_type(tcx, def_id, hir_ty.span, UnsizedHandling::Allow)
+                    .and(check_variances_for_type_defn(tcx, item, hir_generics))
             } else {
                 Ok(())
             }
@@ -1813,25 +1803,21 @@ fn check_variances_for_type_defn<'tcx>(
     tcx: TyCtxt<'tcx>,
     item: &hir::Item<'tcx>,
     hir_generics: &hir::Generics<'tcx>,
-) {
+) -> Result<(), ErrorGuaranteed> {
     let identity_args = ty::GenericArgs::identity_for_item(tcx, item.owner_id);
 
     match item.kind {
         ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) => {
             for field in tcx.adt_def(item.owner_id).all_fields() {
-                if field.ty(tcx, identity_args).references_error() {
-                    return;
-                }
+                field.ty(tcx, identity_args).error_reported()?;
             }
         }
         ItemKind::TyAlias(..) => {
             assert!(
                 tcx.type_alias_is_lazy(item.owner_id),
                 "should not be computing variance of non-weak type alias"
             );
-            if tcx.type_of(item.owner_id).skip_binder().references_error() {
-                return;
-            }
+            tcx.type_of(item.owner_id).skip_binder().error_reported()?;
         }
         kind => span_bug!(item.span, "cannot compute the variances of {kind:?}"),
     }
@@ -1869,6 +1855,8 @@ fn check_variances_for_type_defn<'tcx>(
 
     let ty_generics = tcx.generics_of(item.owner_id);
 
+    let mut res = Ok(());
+
     for (index, _) in variances.iter().enumerate() {
         let parameter = Parameter(index as u32);
 
@@ -1895,13 +1883,14 @@ fn check_variances_for_type_defn<'tcx>(
         }
 
         match hir_param.name {
-            hir::ParamName::Error(_guar) => {}
+            hir::ParamName::Error(guar) => res = Err(guar),
             _ => {
                 let has_explicit_bounds = explicitly_bounded_params.contains(&parameter);
-                report_bivariance(tcx, hir_param, has_explicit_bounds, item.kind);
+                res = Err(report_bivariance(tcx, hir_param, has_explicit_bounds, item.kind));
             }
         }
     }
+    res
 }
 
 fn report_bivariance(