Refactoring: added PatternTypeAnnotation wrapper around UserTypeAnnotation to ease future changes.

Author: pnkfelix

src/librustc_mir/build/matches/mod.rs

@@ -291,7 +291,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
                     },
                     ..
                 },
-                user_ty: ascription_user_ty,
+                user_ty: pat_ascription_ty,
                 user_ty_span,
             } => {
                 let place =
@@ -316,7 +316,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
                         kind: StatementKind::AscribeUserType(
                             place,
                             ty::Variance::Invariant,
-                            box ascription_user_ty,
+                            box pat_ascription_ty.user_ty(),
                         ),
                     },
                 );
@@ -491,7 +491,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
     pub(super) fn visit_bindings(
         &mut self,
         pattern: &Pattern<'tcx>,
-        mut pattern_user_ty: Option<(UserTypeAnnotation<'tcx>, Span)>,
+        mut pattern_user_ty: Option<(PatternTypeAnnotation<'tcx>, Span)>,
         f: &mut impl FnMut(
             &mut Self,
             Mutability,
@@ -500,7 +500,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
             NodeId,
             Span,
             Ty<'tcx>,
-            Option<(UserTypeAnnotation<'tcx>, Span)>,
+            Option<(PatternTypeAnnotation<'tcx>, Span)>,
         ),
     ) {
         match *pattern.kind {
@@ -626,7 +626,7 @@ struct Binding<'tcx> {
 struct Ascription<'tcx> {
     span: Span,
     source: Place<'tcx>,
-    user_ty: UserTypeAnnotation<'tcx>,
+    user_ty: PatternTypeAnnotation<'tcx>,
 }
 
 #[derive(Clone, Debug)]
@@ -1323,7 +1323,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
                     kind: StatementKind::AscribeUserType(
                         ascription.source.clone(),
                         ty::Variance::Covariant,
-                        box ascription.user_ty,
+                        box ascription.user_ty.user_ty(),
                     ),
                 },
             );
@@ -1470,7 +1470,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
         num_patterns: usize,
         var_id: NodeId,
         var_ty: Ty<'tcx>,
-        user_var_ty: Option<(UserTypeAnnotation<'tcx>, Span)>,
+        user_var_ty: Option<(PatternTypeAnnotation<'tcx>, Span)>,
         has_guard: ArmHasGuard,
         opt_match_place: Option<(Option<Place<'tcx>>, Span)>,
         pat_span: Span,
@@ -1489,7 +1489,7 @@ impl<'a, 'gcx, 'tcx> Builder<'a, 'gcx, 'tcx> {
         let local = LocalDecl::<'tcx> {
             mutability,
             ty: var_ty,
-            user_ty: user_var_ty,
+            user_ty: user_var_ty.map(|(pat_ty, span)|(pat_ty.user_ty(), span)),
             name: Some(name),
             source_info,
             visibility_scope,

src/librustc_mir/hair/cx/block.rs

@@ -91,7 +91,7 @@ fn mirror_stmts<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
                                     ty: pattern.ty,
                                     span: pattern.span,
                                     kind: Box::new(PatternKind::AscribeUserType {
-                                        user_ty: UserTypeAnnotation::Ty(user_ty),
+                                        user_ty: PatternTypeAnnotation::from_c_ty(user_ty),
                                         user_ty_span: ty.span,
                                         subpattern: pattern
                                     })

src/librustc_mir/hair/mod.rs

@@ -27,7 +27,7 @@ use self::cx::Cx;
 pub mod cx;
 
 pub mod pattern;
-pub use self::pattern::{BindingMode, Pattern, PatternKind, FieldPattern};
+pub use self::pattern::{BindingMode, Pattern, PatternKind, PatternTypeAnnotation, FieldPattern};
 
 mod util;
 

src/librustc_mir/hair/pattern/mod.rs

@@ -64,12 +64,26 @@ pub struct Pattern<'tcx> {
     pub kind: Box<PatternKind<'tcx>>,
 }
 
+#[derive(Copy, Clone, Debug)]
+pub struct PatternTypeAnnotation<'tcx>(UserTypeAnnotation<'tcx>);
+
+impl<'tcx> PatternTypeAnnotation<'tcx> {
+    pub(crate) fn from_c_ty(c_ty: ty::CanonicalTy<'tcx>) -> Self {
+        Self::from_u_ty(UserTypeAnnotation::Ty(c_ty))
+    }
+    pub(crate) fn from_u_ty(u_ty: UserTypeAnnotation<'tcx>) -> Self {
+        PatternTypeAnnotation(u_ty)
+    }
+
+    pub(crate) fn user_ty(self) -> UserTypeAnnotation<'tcx> { self.0 }
+}
+
 #[derive(Clone, Debug)]
 pub enum PatternKind<'tcx> {
     Wild,
 
     AscribeUserType {
-        user_ty: UserTypeAnnotation<'tcx>,
+        user_ty: PatternTypeAnnotation<'tcx>,
         subpattern: Pattern<'tcx>,
         user_ty_span: Span,
     },
@@ -690,9 +704,10 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> {
 
             debug!("pattern user_ty = {:?} for pattern at {:?}", user_ty, span);
 
+            let pat_ty = PatternTypeAnnotation::from_u_ty(user_ty);
             kind = PatternKind::AscribeUserType {
                 subpattern,
-                user_ty,
+                user_ty: pat_ty,
                 user_ty_span: span,
             };
         }
@@ -980,7 +995,7 @@ macro_rules! CloneImpls {
 CloneImpls!{ <'tcx>
     Span, Field, Mutability, ast::Name, ast::NodeId, usize, &'tcx ty::Const<'tcx>,
     Region<'tcx>, Ty<'tcx>, BindingMode<'tcx>, &'tcx AdtDef,
-    &'tcx Substs<'tcx>, &'tcx Kind<'tcx>, UserTypeAnnotation<'tcx>
+    &'tcx Substs<'tcx>, &'tcx Kind<'tcx>, UserTypeAnnotation<'tcx>, PatternTypeAnnotation<'tcx>
 }
 
 impl<'tcx> PatternFoldable<'tcx> for FieldPattern<'tcx> {