keep variance for CanonicalUserTypeAnnotation

Author: lcnr

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1068,15 +1068,19 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             self.user_type_annotations
         );
         for user_annotation in self.user_type_annotations {
-            let CanonicalUserTypeAnnotation { span, ref user_ty, inferred_ty } = *user_annotation;
+            let CanonicalUserTypeAnnotation { span, ref user_ty, inferred_ty, variance } =
+                *user_annotation;
             let inferred_ty = self.normalize(inferred_ty, Locations::All(span));
             let annotation = self.instantiate_canonical_with_fresh_inference_vars(span, user_ty);
             match annotation {
                 UserType::Ty(mut ty) => {
                     ty = self.normalize(ty, Locations::All(span));
 
-                    if let Err(terr) = self.eq_types(
+                    // `ty` and `inferred_ty` are swapped for
+                    // better diagnostics.
+                    if let Err(terr) = self.relate_types(
                         ty,
+                        variance.xform(ty::Variance::Contravariant),
                         inferred_ty,
                         Locations::All(span),
                         ConstraintCategory::BoringNoLocation,

compiler/rustc_middle/src/thir.rs

@@ -552,14 +552,16 @@ impl<'tcx> PatTyProj<'tcx> {
     pub fn user_ty(
         self,
         annotations: &mut CanonicalUserTypeAnnotations<'tcx>,
-        inferred_ty: Ty<'tcx>,
         span: Span,
+        inferred_ty: Ty<'tcx>,
+        variance: ty::Variance,
     ) -> UserTypeProjection {
         UserTypeProjection {
             base: annotations.push(CanonicalUserTypeAnnotation {
                 span,
                 user_ty: self.user_ty,
                 inferred_ty,
+                variance,
             }),
             projs: Vec::new(),
         }

compiler/rustc_middle/src/ty/context.rs

@@ -22,6 +22,7 @@ use crate::ty::{
     FloatVar, FloatVid, GenericParamDefKind, InferConst, InferTy, IntTy, IntVar, IntVid, List,
     ParamConst, ParamTy, PolyFnSig, Predicate, PredicateKind, PredicateS, ProjectionTy, Region,
     RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyS, TyVar, TyVid, TypeAndMut, UintTy,
+    Variance,
 };
 use rustc_ast as ast;
 use rustc_attr as attr;
@@ -833,6 +834,7 @@ pub struct CanonicalUserTypeAnnotation<'tcx> {
     pub user_ty: CanonicalUserType<'tcx>,
     pub span: Span,
     pub inferred_ty: Ty<'tcx>,
+    pub variance: Variance,
 }
 
 /// Canonicalized user type annotation.

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

@@ -4,7 +4,7 @@ use crate::build::Builder;
 use rustc_middle::mir::interpret::{ConstValue, Scalar};
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
-use rustc_middle::ty::CanonicalUserTypeAnnotation;
+use rustc_middle::ty::{CanonicalUserTypeAnnotation, Variance};
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
     /// Compile `expr`, yielding a compile-time constant. Assumes that
@@ -22,6 +22,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         span,
                         user_ty,
                         inferred_ty: ty,
+                        variance: Variance::Invariant,
                     })
                 });
                 assert_eq!(literal.ty(), ty);

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

@@ -493,6 +493,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             span: source_info.span,
                             user_ty,
                             inferred_ty: expr.ty,
+                            variance: Variance::Invariant,
                         });
 
                     let place = place_builder.clone().into_place(this.tcx, this.typeck_results);
@@ -522,6 +523,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                             span: source_info.span,
                             user_ty,
                             inferred_ty: expr.ty,
+                            variance: Variance::Invariant,
                         });
                     this.cfg.push(
                         block,

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

@@ -9,7 +9,7 @@ use rustc_hir as hir;
 use rustc_index::vec::Idx;
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
-use rustc_middle::ty::{self, CanonicalUserTypeAnnotation};
+use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Variance};
 use std::iter;
 
 impl<'a, 'tcx> Builder<'a, 'tcx> {
@@ -364,6 +364,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         span: source_info.span,
                         user_ty: ty,
                         inferred_ty,
+                        variance: Variance::Invariant,
                     })
                 });
                 let adt = Box::new(AggregateKind::Adt(

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

@@ -19,7 +19,7 @@ use rustc_index::bit_set::BitSet;
 use rustc_middle::middle::region;
 use rustc_middle::mir::*;
 use rustc_middle::thir::{self, *};
-use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty};
+use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, Variance};
 use rustc_span::symbol::Symbol;
 use rustc_span::{BytePos, Pos, Span};
 use rustc_target::abi::VariantIdx;
@@ -538,8 +538,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let ty_source_info = self.source_info(user_ty_span);
                 let user_ty = pat_ascription_ty.user_ty(
                     &mut self.canonical_user_type_annotations,
-                    place.ty(&self.local_decls, self.tcx).ty,
                     ty_source_info.span,
+                    place.ty(&self.local_decls, self.tcx).ty,
+                    Variance::Invariant,
                 );
                 self.cfg.push(
                     block,
@@ -796,6 +797,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     span: user_ty_span,
                     user_ty: user_ty.user_ty,
                     inferred_ty: subpattern.ty,
+                    variance: Variance::Invariant,
                 };
                 let projection = UserTypeProjection {
                     base: self.canonical_user_type_annotations.push(annotation),
@@ -2076,8 +2078,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
             let user_ty = ascription.user_ty.user_ty(
                 &mut self.canonical_user_type_annotations,
-                ascription.source.ty(&self.local_decls, self.tcx).ty,
                 source_info.span,
+                ascription.source.ty(&self.local_decls, self.tcx).ty,
+                ascription.variance,
             );
             self.cfg.push(
                 block,

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

@@ -0,0 +1,27 @@
+// Check that incorrect higher ranked subtyping
+// causes an error.
+struct Inv<'a>(fn(&'a ()) -> &'a ());
+fn hr_subtype<'c>(f: for<'a, 'b> fn(Inv<'a>, Inv<'a>)) {
+    // ok
+    let _: for<'a> fn(Inv<'a>, Inv<'a>) = f;
+    let sub: for<'a> fn(Inv<'a>, Inv<'a>) = f;
+    // no
+    let _: for<'a, 'b> fn(Inv<'a>, Inv<'b>) = sub;
+    //~^ ERROR mismatched types
+}
+
+fn simple1<'c>(x: (&'c i32,)) {
+    let _x: (&'static i32,) = x;
+    //~^ ERROR mismatched types
+}
+
+fn simple2<'c>(x: (&'c i32,)) {
+    let _: (&'static i32,) = x;
+    //~^ ERROR mismatched types
+}
+
+fn main() {
+    hr_subtype(|_, _| {});
+    simple1((&3,));
+    simple2((&3,));
+}

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

@@ -0,0 +1,42 @@
+error[E0308]: mismatched types
+  --> $DIR/placeholder-pattern-fail.rs:8:47
+   |
+LL |     let _: for<'a, 'b> fn(Inv<'a>, Inv<'b>) = sub;
+   |                                               ^^^ one type is more general than the other
+   |
+   = note: expected fn pointer `for<'a, 'b> fn(Inv<'a>, Inv<'b>)`
+              found fn pointer `for<'a> fn(Inv<'a>, Inv<'a>)`
+
+error[E0308]: mismatched types
+  --> $DIR/placeholder-pattern-fail.rs:13: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
+   |
+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
+   |
+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
+   |
+LL | fn simple2<'c>(x: (&'c i32,)) {
+   |            ^^
+   = note: ...does not necessarily outlive the static lifetime
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0308`.

src/test/ui/hr-subtype/placeholder-pattern.rs

@@ -0,0 +1,18 @@
+// check-pass
+// Check that higher ranked subtyping correctly works when using
+// placeholder patterns.
+fn hr_subtype<'c>(f: for<'a, 'b> fn(&'a (), &'b ())) {
+    let _: for<'a> fn(&'a (), &'a ()) = f;
+    let _: for<'a, 'b> fn(&'a (), &'b ()) = f;
+    let _: for<'a> fn(&'a (), &'c ()) = f;
+    let _: fn(&'c (), &'c ()) = f;
+}
+
+fn simple<'c>(x: (&'static i32,)) {
+    let _: (&'c i32,) = x;
+}
+
+fn main() {
+    hr_subtype(|_, _| {});
+    simple((&3,));
+}