},
..
},
- user_ty: ascription_user_ty,
+ user_ty: pat_ascription_ty,
user_ty_span,
} => {
let place =
kind: StatementKind::AscribeUserType(
place,
ty::Variance::Invariant,
- box ascription_user_ty,
+ box pat_ascription_ty.user_ty(),
),
},
);
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,
NodeId,
Span,
Ty<'tcx>,
- Option<(UserTypeAnnotation<'tcx>, Span)>,
+ Option<(PatternTypeAnnotation<'tcx>, Span)>,
),
) {
match *pattern.kind {
struct Ascription<'tcx> {
span: Span,
source: Place<'tcx>,
- user_ty: UserTypeAnnotation<'tcx>,
+ user_ty: PatternTypeAnnotation<'tcx>,
}
#[derive(Clone, Debug)]
kind: StatementKind::AscribeUserType(
ascription.source.clone(),
ty::Variance::Covariant,
- box ascription.user_ty,
+ box ascription.user_ty.user_ty(),
),
},
);
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,
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,
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
})
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;
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,
},
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,
};
}
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> {