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

oli-obk · oli-obk · commit 9a97790a3b31 · 2024-06-07T15:46:15.000Z
diff --git a/compiler/rustc_borrowck/src/type_check/relate_tys.rs b/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,6 +526,7 @@ impl<'bccx, 'tcx> TypeRelation<'tcx> for NllTypeRelating<'_, 'bccx, 'tcx> {
                 })?;
             }
 
+            ty::Variance::Errvariant(guar) => self.type_checker.infcx.set_tainted_by_errors(guar),
             ty::Variance::Bivariant => {}
         }
 
@@ -591,7 +592,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?)")
             }
         })]);
diff --git a/compiler/rustc_hir_analysis/src/variance/constraints.rs b/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)),
         }
     }
 
diff --git a/compiler/rustc_hir_analysis/src/variance/xform.rs b/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,
diff --git a/compiler/rustc_infer/src/infer/at.rs b/compiler/rustc_infer/src/infer/at.rs
@@ -207,6 +207,10 @@ 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(guar) => {
+                self.infcx.set_tainted_by_errors(guar);
+                Ok(InferOk { value: (), obligations: vec![] })
+            }
 
             // We could make this make sense but it's not readily
             // exposed and I don't feel like dealing with it. Note
diff --git a/compiler/rustc_infer/src/infer/relate/generalize.rs b/compiler/rustc_infer/src/infer/relate/generalize.rs
@@ -91,6 +91,14 @@ impl<'tcx> InferCtxt<'tcx> {
                     ty::Variance::Contravariant => {
                         (source_ty.into(), generalized_ty.into(), AliasRelationDirection::Subtype)
                     }
+                    ty::Errvariant(guar) => {
+                        self.set_tainted_by_errors(guar);
+                        (
+                            Ty::new_error(self.tcx, guar).into(),
+                            generalized_ty.into(),
+                            AliasRelationDirection::Equate,
+                        )
+                    }
                     ty::Variance::Bivariant => unreachable!("bivariant generalization"),
                 };
 
diff --git a/compiler/rustc_infer/src/infer/relate/glb.rs b/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),
diff --git a/compiler/rustc_infer/src/infer/relate/lub.rs 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),
diff --git a/compiler/rustc_infer/src/infer/relate/type_relating.rs 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,11 +289,15 @@ 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")
                 }
             }
-        }
+                ty::Errvariant(guar) => {
+                    infcx.set_tainted_by_errors(guar);
+                    return self.relate(a, b);
+                }
+                ty::Bivariant => {
 
         Ok(a)
     }
@@ -341,9 +345,13 @@ 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")
             }
         })]);
-    }
+            ty::Variance::Errvariant(guar) => {
+                self.fields.infcx.set_tainted_by_errors(guar);
+                ty::PredicateKind::Ambiguous
+            }
+            ty::Variance::Bivariant => {
 }
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/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,
         }
     }
 }
diff --git a/compiler/rustc_span/src/lib.rs b/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 {
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
@@ -14,6 +14,7 @@ use rustc_data_structures::sso::SsoHashSet;
 use rustc_data_structures::sync::Lrc;
 #[cfg(feature = "nightly")]
 use rustc_macros::{Decodable, Encodable, HashStable_NoContext};
+use rustc_span::ErrorGuaranteed;
 #[cfg(not(feature = "nightly"))]
 use std::collections::HashSet as SsoHashSet;
 use std::fmt;
@@ -200,10 +201,16 @@ pub fn debug_bound_var<T: std::fmt::Write>(
 #[cfg_attr(feature = "nightly", derive(Decodable, Encodable, Hash, HashStable_NoContext))]
 #[cfg_attr(feature = "nightly", rustc_pass_by_value)]
 pub enum Variance {
-    Covariant,     // T<A> <: T<B> iff A <: B -- e.g., function return type
-    Invariant,     // T<A> <: T<B> iff B == A -- e.g., type of mutable cell
-    Contravariant, // T<A> <: T<B> iff B <: A -- e.g., function param type
-    Bivariant,     // T<A> <: T<B>            -- e.g., unused type parameter
+    /// T<A> <: T<B> iff A <: B -- e.g., function return type
+    Covariant,
+    /// T<A> <: T<B> iff B == A -- e.g., type of mutable cell
+    Invariant,
+    /// T<A> <: T<B> iff B <: A -- e.g., function param type
+    Contravariant,
+    /// T<A> <: T<B>            -- e.g., unused type parameter
+    Bivariant,
+    /// Oddly named since these are all glob exported in various places in the compiler
+    Errvariant(ErrorGuaranteed),
 }
 
 impl Variance {
@@ -245,6 +252,10 @@ impl Variance {
     /// Combining Definition- and Use-Site Variance" published in PLDI'11.
     pub fn xform(self, v: Variance) -> Variance {
         match (self, v) {
+            (Variance::Errvariant(guar), _) | (_, Variance::Errvariant(guar)) => {
+                Variance::Errvariant(guar)
+            }
+
             // Figure 1, column 1.
             (Variance::Covariant, Variance::Covariant) => Variance::Covariant,
             (Variance::Covariant, Variance::Contravariant) => Variance::Contravariant,
@@ -273,6 +284,7 @@ impl fmt::Debug for Variance {
             Variance::Contravariant => "-",
             Variance::Invariant => "o",
             Variance::Bivariant => "*",
+            Variance::Errvariant(_) => "{error}",
         })
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -106,14 +106,14 @@ impl<'me, 'bccx, 'tcx> NllTypeRelating<'me, 'bccx, 'tcx> {`
`106`	`106`	`fn ambient_covariance(&self) -> bool {`
`107`	`107`	`match self.ambient_variance {`
`108`	`108`	`ty::Variance::Covariant \| ty::Variance::Invariant => true,`
`109`		`- ty::Variance::Contravariant \| ty::Variance::Bivariant => false,`
	`109`	`+ ty::Variance::Contravariant \| ty::Variance::Bivariant \| ty::Errvariant(_) => false,`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`fn ambient_contravariance(&self) -> bool {`
`114`	`114`	`match self.ambient_variance {`
`115`	`115`	`ty::Variance::Contravariant \| ty::Variance::Invariant => true,`
`116`		`- ty::Variance::Covariant \| ty::Variance::Bivariant => false,`
	`116`	`+ ty::Variance::Covariant \| ty::Variance::Bivariant \| ty::Errvariant(_) => false,`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
`@@ -526,6 +526,7 @@ impl<'bccx, 'tcx> TypeRelation<'tcx> for NllTypeRelating<'_, 'bccx, 'tcx> {`
`526`	`526`	`})?;`
`527`	`527`	`}`
`528`	`528`
	`529`	`+ ty::Variance::Errvariant(guar) => self.type_checker.infcx.set_tainted_by_errors(guar),`
`529`	`530`	`ty::Variance::Bivariant => {}`
`530`	`531`	`}`
`531`	`532`
`@@ -591,7 +592,7 @@ impl<'bccx, 'tcx> ObligationEmittingRelation<'tcx> for NllTypeRelating<'_, 'bccx`
`591`	`592`	`b.into(),`
`592`	`593`	`ty::AliasRelationDirection::Equate,`
`593`	`594`	`),`
`594`		`- ty::Variance::Bivariant => {`
	`595`	`+ ty::Variance::Errvariant(_) \| ty::Variance::Bivariant => {`
`595`	`596`	`unreachable!("cannot defer an alias-relate goal with Bivariant variance (yet?)")`
`596`	`597`	`}`
`597`	`598`	`})]);`
Original file line number	Diff line number	Diff line change
`@@ -174,6 +174,7 @@ impl<'a, 'tcx> ConstraintContext<'a, 'tcx> {`
`174`	`174`	`ty::Invariant => self.invariant,`
`175`	`175`	`ty::Contravariant => self.contravariant,`
`176`	`176`	`ty::Bivariant => self.bivariant,`
	`177`	`+ ty::Errvariant(_) => &*self.terms_cx.arena.alloc(ConstantTerm(v)),`
`177`	`178`	`}`
`178`	`179`	`}`
`179`	`180`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {`
`117`	`117`	`ty::Invariant => {`
`118`	`118`	`infcx.inner.borrow_mut().type_variables().equate(a_id, b_id);`
`119`	`119`	`}`
`120`		`- ty::Bivariant => {`
	`120`	`+ ty::Errvariant(_) \| ty::Bivariant => {`
`121`	`121`	`unreachable!("Expected bivariance to be handled in relate_with_variance")`
`122`	`122`	`}`
`123`	`123`	`}`
`@@ -204,7 +204,7 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {`
`204`	`204`	`.unwrap_region_constraints()`
`205`	`205`	`.make_eqregion(origin, a, b);`
`206`	`206`	`}`
`207`		`- ty::Bivariant => {`
	`207`	`+ ty::Errvariant(_) \| ty::Bivariant => {`
`208`	`208`	`unreachable!("Expected bivariance to be handled in relate_with_variance")`
`209`	`209`	`}`
`210`	`210`	`}`
`@@ -289,11 +289,15 @@ impl<'tcx> TypeRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {`
`289`	`289`	`self.relate(a, b)`
`290`	`290`	`})?;`
`291`	`291`	`}`
`292`		`- ty::Bivariant => {`
	`292`	`+ ty::Errvariant(_) \| ty::Bivariant => {`
`293`	`293`	`unreachable!("Expected bivariance to be handled in relate_with_variance")`
`294`	`294`	`}`
`295`	`295`	`}`
`296`		`- }`
	`296`	`+ ty::Errvariant(guar) => {`
	`297`	`+ infcx.set_tainted_by_errors(guar);`
	`298`	`+ return self.relate(a, b);`
	`299`	`+ }`
	`300`	`+ ty::Bivariant => {`
`297`	`301`
`298`	`302`	`Ok(a)`
`299`	`303`	`}`
`@@ -341,9 +345,13 @@ impl<'tcx> ObligationEmittingRelation<'tcx> for TypeRelating<'_, '_, 'tcx> {`
`341`	`345`	`b.into(),`
`342`	`346`	`ty::AliasRelationDirection::Equate,`
`343`	`347`	`),`
`344`		`- ty::Variance::Bivariant => {`
	`348`	`+ ty::Variance::Errvariant(_) \| ty::Variance::Bivariant => {`
`345`	`349`	`unreachable!("Expected bivariance to be handled in relate_with_variance")`
`346`	`350`	`}`
`347`	`351`	`})]);`
`348`		`- }`
	`352`	`+ ty::Variance::Errvariant(guar) => {`
	`353`	`+ self.fields.infcx.set_tainted_by_errors(guar);`
	`354`	`+ ty::PredicateKind::Ambiguous`
	`355`	`+ }`
	`356`	`+ ty::Variance::Bivariant => {`
`349`	`357`	`}`
Original file line number	Diff line number	Diff line change
`@@ -870,6 +870,7 @@ impl<'tcx> Stable<'tcx> for ty::Variance {`
`870`	`870`	`ty::Variance::Contravariant => stable_mir::mir::Variance::Contravariant,`
`871`	`871`	`ty::Variance::Covariant => stable_mir::mir::Variance::Covariant,`
`872`	`872`	`ty::Variance::Invariant => stable_mir::mir::Variance::Invariant,`
	`873`	`+ ty::Variance::Errvariant(_) => stable_mir::mir::Variance::Bivariant,`
`873`	`874`	`}`
`874`	`875`	`}`
`875`	`876`	`}`