Add an error variance, but don't use it yet

Author: oli-obk

compiler/rustc_borrowck/src/type_check/relate_tys.rs

@@ -106,14 +106,14 @@ impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {
     fn ambient_covariance(&self) -> bool {
         match self.ambient_variance {
             ty::Variance::Covariant | ty::Variance::Invariant => true,
-            ty::Variance::Contravariant | ty::Variance::Bivariant => false,
+            ty::Variance::Contravariant | ty::Variance::Bivariant | ty::Errvariant(_) => false,
         }
     }
 
     fn ambient_contravariance(&self) -> bool {
         match self.ambient_variance {
             ty::Variance::Contravariant | ty::Variance::Invariant => true,
-            ty::Variance::Covariant | ty::Variance::Bivariant => false,
+            ty::Variance::Covariant | ty::Variance::Bivariant | ty::Errvariant(_) => false,
         }
     }
 
@@ -526,7 +526,7 @@ impl<'bccx, 'tcx> TypeRelation<'tcx> for NllTypeRelating<'_, 'bccx, 'tcx> {
                 })?;
             }
 
-            ty::Variance::Bivariant => {}
+            ty::Variance::Errvariant(_) | ty::Variance::Bivariant => {}
         }
 
         Ok(a)
@@ -591,7 +591,7 @@ impl<'bccx, 'tcx> ObligationEmittingRelation<'tcx> for NllTypeRelating<'_, 'bccx
                 b.into(),
                 ty::AliasRelationDirection::Equate,
             ),
-            ty::Variance::Bivariant => {
+            ty::Variance::Errvariant(_) | ty::Variance::Bivariant => {
                 unreachable!("cannot defer an alias-relate goal with Bivariant variance (yet?)")
             }
         })]);

compiler/rustc_hir_analysis/src/variance/constraints.rs

@@ -174,6 +174,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {
             ty::Invariant => self.invariant,
             ty::Contravariant => self.contravariant,
             ty::Bivariant => self.bivariant,
+            ty::Errvariant(_) => &*self.terms_cx.arena.alloc(ConstantTerm(v)),
         }
     }
 

compiler/rustc_hir_analysis/src/variance/xform.rs

@@ -8,6 +8,7 @@ pub fn glb(v1: ty::Variance, v2: ty::Variance) -> ty::Variance {
     //    -     +
     //       o
     match (v1, v2) {
+        (ty::Errvariant(guar), _) | (_, ty::Errvariant(guar)) => ty::Errvariant(guar),
         (ty::Invariant, _) | (_, ty::Invariant) => ty::Invariant,
 
         (ty::Covariant, ty::Contravariant) => ty::Invariant,

compiler/rustc_infer/src/infer/at.rs

@@ -207,6 +207,7 @@ impl<'a, 'tcx> At<'a, 'tcx> {
             ty::Variance::Covariant => self.sub(define_opaque_types, expected, actual),
             ty::Variance::Invariant => self.eq(define_opaque_types, expected, actual),
             ty::Variance::Contravariant => self.sup(define_opaque_types, expected, actual),
+            ty::Variance::Errvariant(_) => unreachable!(),
 
             // We could make this make sense but it's not readily
             // exposed and I don't feel like dealing with it. Note

compiler/rustc_infer/src/infer/relate/generalize.rs

@@ -91,6 +91,7 @@ impl<'tcx> InferCtxt<'tcx> {
                     ty::Variance::Contravariant => {
                         (source_ty.into(), generalized_ty.into(), AliasRelationDirection::Subtype)
                     }
+                    ty::Errvariant(_) => unreachable!(),
                     ty::Variance::Bivariant => unreachable!("bivariant generalization"),
                 };
 
@@ -495,7 +496,7 @@ impl<'tcx> TypeRelation<'tcx> for Generalizer<'_, 'tcx> {
 
                                 // Co/contravariant: this will be
                                 // sufficiently constrained later on.
-                                ty::Covariant | ty::Contravariant => (),
+                                ty::Errvariant(_) | ty::Covariant | ty::Contravariant => (),
                             }
 
                             let origin = inner.type_variables().var_origin(vid);

compiler/rustc_infer/src/infer/relate/glb.rs

@@ -40,6 +40,8 @@ impl<'tcx> TypeRelation<'tcx> for Glb<'_, '_, 'tcx> {
         match variance {
             ty::Invariant => self.fields.equate(StructurallyRelateAliases::No).relate(a, b),
             ty::Covariant => self.relate(a, b),
+            // TODO: report a new error kind
+            ty::Errvariant(_) => Ok(a),
             // FIXME(#41044) -- not correct, need test
             ty::Bivariant => Ok(a),
             ty::Contravariant => self.fields.lub().relate(a, b),

compiler/rustc_infer/src/infer/relate/lub.rs

@@ -40,6 +40,8 @@ impl<'tcx> TypeRelation<'tcx> for Lub<'_, '_, 'tcx> {
         match variance {
             ty::Invariant => self.fields.equate(StructurallyRelateAliases::No).relate(a, b),
             ty::Covariant => self.relate(a, b),
+            // TODO: report a new kind of type error that preserves the `ErrorGuaranteed`?
+            ty::Errvariant(_) => Ok(a),
             // FIXME(#41044) -- not correct, need test
             ty::Bivariant => Ok(a),
             ty::Contravariant => self.fields.glb().relate(a, b),

compiler/rustc_infer/src/infer/relate/type_relating.rs

@@ -117,7 +117,7 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {
                     ty::Invariant => {
                         infcx.inner.borrow_mut().type_variables().equate(a_id, b_id);
                     }
-                    ty::Bivariant => {
+                    ty::Errvariant(_) | ty::Bivariant => {
                         unreachable!("Expected bivariance to be handled in relate_with_variance")
                     }
                 }
@@ -204,7 +204,7 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {
                     .unwrap_region_constraints()
                     .make_eqregion(origin, a, b);
             }
-            ty::Bivariant => {
+            ty::Errvariant(_) | ty::Bivariant => {
                 unreachable!("Expected bivariance to be handled in relate_with_variance")
             }
         }
@@ -289,7 +289,7 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {
                         self.relate(a, b)
                     })?;
                 }
-                ty::Bivariant => {
+                ty::Errvariant(_) | ty::Bivariant => {
                     unreachable!("Expected bivariance to be handled in relate_with_variance")
                 }
             }
@@ -341,7 +341,7 @@ impl<'tcx> ObligationEmittingRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {
                 b.into(),
                 ty::AliasRelationDirection::Equate,
             ),
-            ty::Variance::Bivariant => {
+            ty::Variance::Errvariant(_) | ty::Variance::Bivariant => {
                 unreachable!("Expected bivariance to be handled in relate_with_variance")
             }
         })]);

compiler/rustc_smir/src/rustc_smir/convert/ty.rs

@@ -870,6 +870,7 @@ impl<'tcx> Stable<'tcx> for ty::Variance {
             ty::Variance::Contravariant => stable_mir::mir::Variance::Contravariant,
             ty::Variance::Covariant => stable_mir::mir::Variance::Covariant,
             ty::Variance::Invariant => stable_mir::mir::Variance::Invariant,
+            ty::Variance::Errvariant(_) => stable_mir::mir::Variance::Bivariant,
         }
     }
 }

compiler/rustc_span/src/lib.rs

@@ -39,7 +39,7 @@
 extern crate self as rustc_span;
 
 use rustc_data_structures::{outline, AtomicRef};
-use rustc_macros::{Decodable, Encodable, HashStable_Generic};
+use rustc_macros::{Decodable, Encodable, HashStable_Generic, HashStable_NoContext};
 use rustc_serialize::opaque::{FileEncoder, MemDecoder};
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use tracing::debug;
@@ -2573,7 +2573,7 @@ where
 /// The `()` field is necessary: it is non-`pub`, which means values of this
 /// type cannot be constructed outside of this crate.
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_NoContext)]
 pub struct ErrorGuaranteed(());
 
 impl ErrorGuaranteed {