change how ascribe user ty deals with variance

Author: lcnr

compiler/rustc_borrowck/src/constraint_generation.rs

@@ -151,7 +151,6 @@ impl<'cg, 'cx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'cx, 'tcx> {
     fn visit_ascribe_user_ty(
         &mut self,
         _place: &Place<'tcx>,
-        _variance: &ty::Variance,
         _user_ty: &UserTypeProjection,
         _location: Location,
     ) {

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -365,7 +365,6 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
         if let Some(annotation_index) = constant.user_ty {
             if let Err(terr) = self.cx.relate_type_and_user_type(
                 constant.literal.ty(),
-                ty::Variance::Invariant,
                 &UserTypeProjection { base: annotation_index, projs: vec![] },
                 location.to_locations(),
                 ConstraintCategory::Boring,
@@ -425,6 +424,7 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
                         ConstraintCategory::Boring,
                         self.cx.param_env.and(type_op::ascribe_user_type::AscribeUserType::new(
                             constant.literal.ty(),
+                            ty::Variance::Invariant,
                             uv.def.did,
                             UserSubsts { substs: uv.substs, user_self_ty: None },
                         )),
@@ -492,7 +492,6 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for TypeVerifier<'a, 'b, 'tcx> {
 
                 if let Err(terr) = self.cx.relate_type_and_user_type(
                     ty,
-                    ty::Variance::Invariant,
                     user_ty,
                     Locations::All(*span),
                     ConstraintCategory::TypeAnnotation,
@@ -1108,6 +1107,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                         ConstraintCategory::BoringNoLocation,
                         self.param_env.and(type_op::ascribe_user_type::AscribeUserType::new(
                             inferred_ty,
+                            variance,
                             def_id,
                             user_substs,
                         )),
@@ -1178,7 +1178,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
     fn relate_type_and_user_type(
         &mut self,
         a: Ty<'tcx>,
-        v: ty::Variance,
         user_ty: &UserTypeProjection,
         locations: Locations,
         category: ConstraintCategory,
@@ -1206,7 +1205,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         );
 
         let ty = curr_projected_ty.ty;
-        self.relate_types(ty, v.xform(ty::Variance::Contravariant), a, locations, category)?;
+        self.relate_types(ty, ty::Variance::Invariant, a, locations, category)?;
 
         Ok(())
     }
@@ -1401,7 +1400,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 if let Some(annotation_index) = self.rvalue_user_ty(rv) {
                     if let Err(terr) = self.relate_type_and_user_type(
                         rv_ty,
-                        ty::Variance::Invariant,
                         &UserTypeProjection { base: annotation_index, projs: vec![] },
                         location.to_locations(),
                         ConstraintCategory::Boring,
@@ -1453,11 +1451,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                     );
                 };
             }
-            StatementKind::AscribeUserType(box (ref place, ref projection), variance) => {
+            StatementKind::AscribeUserType(box (ref place, ref projection)) => {
                 let place_ty = place.ty(body, tcx).ty;
                 if let Err(terr) = self.relate_type_and_user_type(
                     place_ty,
-                    variance,
                     projection,
                     Locations::All(stmt.source_info.span),
                     ConstraintCategory::TypeAnnotation,

compiler/rustc_middle/src/mir/mod.rs

@@ -1581,7 +1581,7 @@ pub enum StatementKind<'tcx> {
     /// - `Contravariant` -- requires that `T_y :> T`
     /// - `Invariant` -- requires that `T_y == T`
     /// - `Bivariant` -- no effect
-    AscribeUserType(Box<(Place<'tcx>, UserTypeProjection)>, ty::Variance),
+    AscribeUserType(Box<(Place<'tcx>, UserTypeProjection)>),
 
     /// Marks the start of a "coverage region", injected with '-Cinstrument-coverage'. A
     /// `Coverage` statement carries metadata about the coverage region, used to inject a coverage
@@ -1705,8 +1705,8 @@ impl Debug for Statement<'_> {
             SetDiscriminant { ref place, variant_index } => {
                 write!(fmt, "discriminant({:?}) = {:?}", place, variant_index)
             }
-            AscribeUserType(box (ref place, ref c_ty), ref variance) => {
-                write!(fmt, "AscribeUserType({:?}, {:?}, {:?})", place, variance, c_ty)
+            AscribeUserType(box (ref place, ref c_ty)) => {
+                write!(fmt, "AscribeUserType({:?}, {:?})", place, c_ty)
             }
             Coverage(box self::Coverage { ref kind, code_region: Some(ref rgn) }) => {
                 write!(fmt, "Coverage::{:?} for {:?}", kind, rgn)

compiler/rustc_middle/src/mir/visit.rs

@@ -128,10 +128,9 @@ macro_rules! make_mir_visitor {
 
             fn visit_ascribe_user_ty(&mut self,
                                      place: & $($mutability)? Place<'tcx>,
-                                     variance: & $($mutability)? ty::Variance,
                                      user_ty: & $($mutability)? UserTypeProjection,
                                      location: Location) {
-                self.super_ascribe_user_ty(place, variance, user_ty, location);
+                self.super_ascribe_user_ty(place, user_ty, location);
             }
 
             fn visit_coverage(&mut self,
@@ -413,9 +412,8 @@ macro_rules! make_mir_visitor {
                     }
                     StatementKind::AscribeUserType(
                         box(ref $($mutability)? place, ref $($mutability)? user_ty),
-                        variance
                     ) => {
-                        self.visit_ascribe_user_ty(place, variance, user_ty, location);
+                        self.visit_ascribe_user_ty(place, user_ty, location);
                     }
                     StatementKind::Coverage(coverage) => {
                         self.visit_coverage(
@@ -775,7 +773,6 @@ macro_rules! make_mir_visitor {
 
             fn super_ascribe_user_ty(&mut self,
                                      place: & $($mutability)? Place<'tcx>,
-                                     _variance: & $($mutability)? ty::Variance,
                                      user_ty: & $($mutability)? UserTypeProjection,
                                      location: Location) {
                 self.visit_place(

compiler/rustc_middle/src/traits/query.rs

@@ -20,20 +20,26 @@ use std::mem;
 pub mod type_op {
     use crate::ty::fold::TypeFoldable;
     use crate::ty::subst::UserSubsts;
-    use crate::ty::{Predicate, Ty};
+    use crate::ty::{self, Predicate, Ty};
     use rustc_hir::def_id::DefId;
     use std::fmt;
 
     #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, HashStable, TypeFoldable, Lift)]
     pub struct AscribeUserType<'tcx> {
         pub mir_ty: Ty<'tcx>,
+        pub variance: ty::Variance,
         pub def_id: DefId,
         pub user_substs: UserSubsts<'tcx>,
     }
 
     impl<'tcx> AscribeUserType<'tcx> {
-        pub fn new(mir_ty: Ty<'tcx>, def_id: DefId, user_substs: UserSubsts<'tcx>) -> Self {
-            Self { mir_ty, def_id, user_substs }
+        pub fn new(
+            mir_ty: Ty<'tcx>,
+            variance: ty::Variance,
+            def_id: DefId,
+            user_substs: UserSubsts<'tcx>,
+        ) -> Self {
+            Self { mir_ty, variance, def_id, user_substs }
         }
     }
 

compiler/rustc_mir_build/src/build/expr/as_place.rs

@@ -501,13 +501,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         block,
                         Statement {
                             source_info,
-                            kind: StatementKind::AscribeUserType(
-                                Box::new((
-                                    place,
-                                    UserTypeProjection { base: annotation_index, projs: vec![] },
-                                )),
-                                Variance::Invariant,
-                            ),
+                            kind: StatementKind::AscribeUserType(Box::new((
+                                place,
+                                UserTypeProjection { base: annotation_index, projs: vec![] },
+                            ))),
                         },
                     );
                 }
@@ -529,13 +526,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         block,
                         Statement {
                             source_info,
-                            kind: StatementKind::AscribeUserType(
-                                Box::new((
-                                    Place::from(temp),
-                                    UserTypeProjection { base: annotation_index, projs: vec![] },
-                                )),
-                                Variance::Invariant,
-                            ),
+                            kind: StatementKind::AscribeUserType(Box::new((
+                                Place::from(temp),
+                                UserTypeProjection { base: annotation_index, projs: vec![] },
+                            ))),
                         },
                     );
                 }

compiler/rustc_mir_build/src/build/matches/mod.rs

@@ -546,24 +546,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     block,
                     Statement {
                         source_info: ty_source_info,
-                        kind: StatementKind::AscribeUserType(
-                            Box::new((place, user_ty)),
-                            // We always use invariant as the variance here. This is because the
-                            // variance field from the ascription refers to the variance to use
-                            // when applying the type to the value being matched, but this
-                            // ascription applies rather to the type of the binding. e.g., in this
-                            // example:
-                            //
-                            // ```
-                            // let x: T = <expr>
-                            // ```
-                            //
-                            // We are creating an ascription that defines the type of `x` to be
-                            // exactly `T` (i.e., with invariance). The variance field, in
-                            // contrast, is intended to be used to relate `T` to the type of
-                            // `<expr>`.
-                            ty::Variance::Invariant,
-                        ),
+                        kind: StatementKind::AscribeUserType(Box::new((place, user_ty))),
                     },
                 );
 
@@ -2086,10 +2069,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 block,
                 Statement {
                     source_info,
-                    kind: StatementKind::AscribeUserType(
-                        Box::new((ascription.source, user_ty)),
-                        ascription.variance,
-                    ),
+                    kind: StatementKind::AscribeUserType(Box::new((ascription.source, user_ty))),
                 },
             );
         }

compiler/rustc_mir_transform/src/coverage/spans.rs

@@ -833,7 +833,7 @@ pub(super) fn filtered_statement_span(statement: &Statement<'_>) -> Option<Span>
         | StatementKind::Assign(_)
         | StatementKind::SetDiscriminant { .. }
         | StatementKind::Retag(_, _)
-        | StatementKind::AscribeUserType(_, _) => {
+        | StatementKind::AscribeUserType(_) => {
             Some(statement.source_info.span)
         }
     }

compiler/rustc_mir_transform/src/separate_const_switch.rs

@@ -244,7 +244,7 @@ fn is_likely_const<'tcx>(mut tracked_place: Place<'tcx>, block: &BasicBlockData<
             StatementKind::FakeRead(_)
             | StatementKind::StorageLive(_)
             | StatementKind::Retag(_, _)
-            | StatementKind::AscribeUserType(_, _)
+            | StatementKind::AscribeUserType(_)
             | StatementKind::Coverage(_)
             | StatementKind::StorageDead(_)
             | StatementKind::CopyNonOverlapping(_)
@@ -311,7 +311,7 @@ fn find_determining_place<'tcx>(
             | StatementKind::StorageLive(_)
             | StatementKind::StorageDead(_)
             | StatementKind::Retag(_, _)
-            | StatementKind::AscribeUserType(_, _)
+            | StatementKind::AscribeUserType(_)
             | StatementKind::Coverage(_)
             | StatementKind::CopyNonOverlapping(_)
             | StatementKind::Nop => {}

compiler/rustc_traits/src/type_op.rs

@@ -53,14 +53,14 @@ pub fn type_op_ascribe_user_type_with_span<'a, 'tcx: 'a>(
     key: ParamEnvAnd<'tcx, AscribeUserType<'tcx>>,
     span: Option<Span>,
 ) -> Result<(), NoSolution> {
-    let (param_env, AscribeUserType { mir_ty, def_id, user_substs }) = key.into_parts();
+    let (param_env, AscribeUserType { mir_ty, variance, def_id, user_substs }) = key.into_parts();
     debug!(
         "type_op_ascribe_user_type: mir_ty={:?} def_id={:?} user_substs={:?}",
         mir_ty, def_id, user_substs
     );
 
     let mut cx = AscribeUserTypeCx { infcx, param_env, fulfill_cx };
-    cx.relate_mir_and_user_ty(mir_ty, def_id, user_substs, span)?;
+    cx.relate_mir_and_user_ty(mir_ty, variance, def_id, user_substs, span)?;
     Ok(())
 }
 
@@ -121,6 +121,7 @@ impl<'me, 'tcx> AscribeUserTypeCx<'me, 'tcx> {
     fn relate_mir_and_user_ty(
         &mut self,
         mir_ty: Ty<'tcx>,
+        variance: ty::Variance,
         def_id: DefId,
         user_substs: UserSubsts<'tcx>,
         span: Option<Span>,
@@ -133,7 +134,7 @@ impl<'me, 'tcx> AscribeUserTypeCx<'me, 'tcx> {
         debug!("relate_type_and_user_type: ty of def-id is {:?}", ty);
         let ty = self.normalize(ty);
 
-        self.relate(mir_ty, Variance::Invariant, ty)?;
+        self.relate(mir_ty, variance, ty)?;
 
         // Prove the predicates coming along with `def_id`.
         //

compiler/rustc_type_ir/src/lib.rs

@@ -447,7 +447,7 @@ impl UnifyKey for FloatVid {
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Decodable, Encodable, Hash)]
+#[derive(Copy, Clone, Decodable, Encodable, Hash, PartialEq, Eq)]
 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

src/test/ui/hr-subtype/placeholder-pattern-fail.stderr

@@ -1,5 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/placeholder-pattern-fail.rs:8:47
+  --> $DIR/placeholder-pattern-fail.rs:9:47
    |
 LL |     let _: for<'a, 'b> fn(Inv<'a>, Inv<'b>) = sub;
    |                                               ^^^ one type is more general than the other
@@ -8,30 +8,30 @@ LL |     let _: for<'a, 'b> fn(Inv<'a>, Inv<'b>) = sub;
               found fn pointer `for<'a> fn(Inv<'a>, Inv<'a>)`
 
 error[E0308]: mismatched types
-  --> $DIR/placeholder-pattern-fail.rs:13:31
+  --> $DIR/placeholder-pattern-fail.rs:14:31
    |
 LL |     let _x: (&'static i32,) = x;
    |                               ^ lifetime mismatch
    |
    = note: expected tuple `(&'static i32,)`
               found tuple `(&'c i32,)`
 note: the lifetime `'c` as defined here...
-  --> $DIR/placeholder-pattern-fail.rs:12:12
+  --> $DIR/placeholder-pattern-fail.rs:13:12
    |
 LL | fn simple1<'c>(x: (&'c i32,)) {
    |            ^^
    = note: ...does not necessarily outlive the static lifetime
 
 error[E0308]: mismatched types
-  --> $DIR/placeholder-pattern-fail.rs:18:30
+  --> $DIR/placeholder-pattern-fail.rs:19:30
    |
 LL |     let _: (&'static i32,) = x;
    |                              ^ lifetime mismatch
    |
    = note: expected tuple `(&'static i32,)`
               found tuple `(&'c i32,)`
 note: the lifetime `'c` as defined here...
-  --> $DIR/placeholder-pattern-fail.rs:17:12
+  --> $DIR/placeholder-pattern-fail.rs:18:12
    |
 LL | fn simple2<'c>(x: (&'c i32,)) {
    |            ^^