Check variances for validity in variances_of query

Author: oli-obk

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -308,22 +308,21 @@ 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) => check_type_defn(tcx, item, false)
-            .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.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.owner_id.def_id, hir_generics)),
+        hir::ItemKind::Struct(..) => check_type_defn(tcx, item, false),
+        hir::ItemKind::Union(..) => check_type_defn(tcx, item, true),
+        hir::ItemKind::Enum(..) => check_type_defn(tcx, item, true),
+
         hir::ItemKind::Trait(..) => check_trait(tcx, item),
         hir::ItemKind::TraitAlias(..) => check_trait(tcx, item),
         // `ForeignItem`s are handled separately.
         hir::ItemKind::ForeignMod { .. } => Ok(()),
-        hir::ItemKind::TyAlias(hir_ty, hir_generics) => {
+        hir::ItemKind::TyAlias(hir_ty, ..) => {
             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);`.
-                check_item_type(tcx, def_id, hir_ty.span, UnsizedHandling::Allow)
-                    .and(check_variances_for_type_defn(tcx, item.owner_id.def_id, hir_generics))
+                let res = check_item_type(tcx, def_id, hir_ty.span, UnsizedHandling::Allow);
+                let _ = tcx.variances_of(def_id);
+                res
             } else {
                 Ok(())
             }
@@ -1062,6 +1061,7 @@ fn check_type_defn<'tcx>(
     all_sized: bool,
 ) -> Result<(), ErrorGuaranteed> {
     let _ = tcx.representability(item.owner_id.def_id);
+    let _ = tcx.variances_of(item.owner_id.def_id);
     let adt_def = tcx.adt_def(item.owner_id);
 
     enter_wf_checking_ctxt(tcx, item.span, item.owner_id.def_id, |wfcx| {
@@ -1799,10 +1799,10 @@ fn receiver_is_implemented<'tcx>(
     }
 }
 
-fn check_variances_for_type_defn<'tcx>(
+pub fn check_variances_for_type_defn<'tcx>(
     tcx: TyCtxt<'tcx>,
     item: LocalDefId,
-    hir_generics: &hir::Generics<'tcx>,
+    variances: &[ty::Variance],
 ) -> Result<(), ErrorGuaranteed> {
     let identity_args = ty::GenericArgs::identity_for_item(tcx, item);
 
@@ -1819,12 +1819,11 @@ fn check_variances_for_type_defn<'tcx>(
             );
             tcx.type_of(item).skip_binder().error_reported()?;
         }
-        kind => span_bug!(tcx.def_span(item), "cannot compute the variances of {kind:?}"),
+        _ => return Ok(()),
     }
 
     let ty_predicates = tcx.predicates_of(item);
     assert_eq!(ty_predicates.parent, None);
-    let variances = tcx.variances_of(item);
 
     let mut constrained_parameters: FxHashSet<_> = variances
         .iter()
@@ -1835,6 +1834,8 @@ fn check_variances_for_type_defn<'tcx>(
 
     identify_constrained_generic_params(tcx, ty_predicates, None, &mut constrained_parameters);
 
+    let hir_generics = tcx.hir_node_by_def_id(item).generics().unwrap();
+
     // 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);

compiler/rustc_hir_analysis/src/variance/mod.rs

@@ -45,7 +45,7 @@ fn variances_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Variance] {
         return &[];
     }
 
-    match tcx.def_kind(item_def_id) {
+    let variances = match tcx.def_kind(item_def_id) {
         DefKind::Fn
         | DefKind::AssocFn
         | DefKind::Enum
@@ -55,21 +55,25 @@ fn variances_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId) -> &[ty::Variance] {
         | DefKind::Ctor(..) => {
             // These are inferred.
             let crate_map = tcx.crate_variances(());
-            return crate_map.variances.get(&item_def_id.to_def_id()).copied().unwrap_or(&[]);
+            crate_map.variances.get(&item_def_id.to_def_id()).copied().unwrap_or(&[])
         }
         DefKind::TyAlias if tcx.type_alias_is_lazy(item_def_id) => {
             // These are inferred.
             let crate_map = tcx.crate_variances(());
-            return crate_map.variances.get(&item_def_id.to_def_id()).copied().unwrap_or(&[]);
+            crate_map.variances.get(&item_def_id.to_def_id()).copied().unwrap_or(&[])
         }
-        DefKind::OpaqueTy => {
-            return variance_of_opaque(tcx, item_def_id);
+        DefKind::OpaqueTy => variance_of_opaque(tcx, item_def_id),
+        _ => {
+            // Variance not relevant.
+            span_bug!(
+                tcx.def_span(item_def_id),
+                "asked to compute variance for wrong kind of item"
+            );
         }
-        _ => {}
-    }
+    };
 
-    // Variance not relevant.
-    span_bug!(tcx.def_span(item_def_id), "asked to compute variance for wrong kind of item");
+    let _ = crate::check::wfcheck::check_variances_for_type_defn(tcx, item_def_id, variances);
+    variances
 }
 
 #[instrument(level = "trace", skip(tcx), ret)]

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -730,16 +730,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     /// Resolves an associated value path into a base type and associated constant, or method
     /// resolution. The newly resolved definition is written into `type_dependent_defs`.
+    #[instrument(level = "trace", skip(self), ret)]
     pub fn resolve_ty_and_res_fully_qualified_call(
         &self,
         qpath: &'tcx QPath<'tcx>,
         hir_id: HirId,
         span: Span,
     ) -> (Res, Option<LoweredTy<'tcx>>, &'tcx [hir::PathSegment<'tcx>]) {
-        debug!(
-            "resolve_ty_and_res_fully_qualified_call: qpath={:?} hir_id={:?} span={:?}",
-            qpath, hir_id, span
-        );
         let (ty, qself, item_segment) = match *qpath {
             QPath::Resolved(ref opt_qself, path) => {
                 return (

tests/ui/issues/issue-34373.stderr

@@ -17,6 +17,15 @@ LL | pub struct Foo<T = Box<Trait<DefaultFoo>>>;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
+error[E0392]: type parameter `T` is never used
+  --> $DIR/issue-34373.rs:7:16
+   |
+LL | pub struct Foo<T = Box<Trait<DefaultFoo>>>;
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^ unused type parameter
+   |
+   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
+   = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead
+
 error[E0038]: the trait `Trait` cannot be made into an object
   --> $DIR/issue-34373.rs:7:24
    |
@@ -39,15 +48,6 @@ help: alternatively, consider constraining `foo` so it does not apply to trait o
 LL |     fn foo(_: T) where Self: Sized {}
    |                  +++++++++++++++++
 
-error[E0392]: type parameter `T` is never used
-  --> $DIR/issue-34373.rs:7:16
-   |
-LL | pub struct Foo<T = Box<Trait<DefaultFoo>>>;
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^ unused type parameter
-   |
-   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
-   = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead
-
 error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0038, E0391, E0392.

tests/ui/lifetimes/issue-64173-unused-lifetimes.stderr

@@ -7,12 +7,6 @@ LL |     beta: [(); foo::<&'a ()>()],
    = note: lifetime parameters may not be used in const expressions
    = help: add `#![feature(generic_const_exprs)]` to allow generic const expressions
 
-error: generic `Self` types are currently not permitted in anonymous constants
-  --> $DIR/issue-64173-unused-lifetimes.rs:4:28
-   |
-LL |     array: [(); size_of::<&Self>()],
-   |                            ^^^^
-
 error[E0392]: lifetime parameter `'s` is never used
   --> $DIR/issue-64173-unused-lifetimes.rs:3:12
    |
@@ -21,6 +15,12 @@ LL | struct Foo<'s> {
    |
    = help: consider removing `'s`, referring to it in a field, or using a marker such as `PhantomData`
 
+error: generic `Self` types are currently not permitted in anonymous constants
+  --> $DIR/issue-64173-unused-lifetimes.rs:4:28
+   |
+LL |     array: [(); size_of::<&Self>()],
+   |                            ^^^^
+
 error[E0392]: lifetime parameter `'a` is never used
   --> $DIR/issue-64173-unused-lifetimes.rs:15:12
    |

tests/ui/regions/region-bounds-on-objects-and-type-parameters.stderr

@@ -4,6 +4,14 @@ error[E0226]: only a single explicit lifetime bound is permitted
 LL |     z: Box<dyn Is<'a>+'b+'c>,
    |                          ^^
 
+error[E0392]: lifetime parameter `'c` is never used
+  --> $DIR/region-bounds-on-objects-and-type-parameters.rs:11:18
+   |
+LL | struct Foo<'a,'b,'c> {
+   |                  ^^ unused lifetime parameter
+   |
+   = help: consider removing `'c`, referring to it in a field, or using a marker such as `PhantomData`
+
 error[E0478]: lifetime bound not satisfied
   --> $DIR/region-bounds-on-objects-and-type-parameters.rs:21:8
    |
@@ -21,14 +29,6 @@ note: but lifetime parameter must outlive the lifetime `'a` as defined here
 LL | struct Foo<'a,'b,'c> {
    |            ^^
 
-error[E0392]: lifetime parameter `'c` is never used
-  --> $DIR/region-bounds-on-objects-and-type-parameters.rs:11:18
-   |
-LL | struct Foo<'a,'b,'c> {
-   |                  ^^ unused lifetime parameter
-   |
-   = help: consider removing `'c`, referring to it in a field, or using a marker such as `PhantomData`
-
 error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0226, E0392, E0478.