Enable matching on pattern types via constants

Author: oli-obk

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -742,9 +742,17 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
             ProjectionElem::OpaqueCast(ty) => {
                 let ty = self.sanitize_type(place, ty);
                 let ty = self.cx.normalize(ty, location);
+                let compare_ty = match *base.ty.kind() {
+                    ty::Alias(ty::Opaque, _) => base.ty,
+                    ty::Pat(inner, _) => inner,
+                    _ => {
+                        span_mirbug!(self, place, "tried to cast {} to {ty}", base.ty);
+                        base.ty
+                    }
+                };
                 self.cx
                     .eq_types(
-                        base.ty,
+                        compare_ty,
                         ty,
                         location.to_locations(),
                         ConstraintCategory::TypeAnnotation,

compiler/rustc_middle/src/mir/syntax.rs

@@ -959,8 +959,10 @@ pub enum ProjectionElem<V, T> {
     /// The included Symbol is the name of the variant, used for printing MIR.
     Downcast(Option<Symbol>, VariantIdx),
 
-    /// Like an explicit cast from an opaque type to a concrete type, but without
-    /// requiring an intermediate variable.
+    /// Like an explicit cast, but without requiring an intermediate variable.
+    /// Can cast the following things:
+    /// * from an opaque type to a concrete type
+    /// * from a pattern type to its inner type
     OpaqueCast(T),
 }
 

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

@@ -16,6 +16,7 @@ use crate::build::expr::as_place::PlaceBuilder;
 use crate::build::matches::{Ascription, Binding, Candidate, MatchPair};
 use crate::build::Builder;
 use rustc_hir::RangeEnd;
+use rustc_middle::mir::ProjectionElem;
 use rustc_middle::thir::{self, *};
 use rustc_middle::ty;
 use rustc_middle::ty::layout::IntegerExt;
@@ -174,7 +175,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
 
             PatKind::PatTy { ref value } => {
-                candidate.match_pairs.push(MatchPair::new(match_pair.place, value, self));
+                let place = match_pair.place.project(ProjectionElem::OpaqueCast(value.ty));
+                candidate.match_pairs.push(MatchPair::new(place, value, self));
                 Ok(())
             }
 

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

@@ -158,7 +158,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
     ) {
         let place = place_builder.to_place(self);
         let place_ty = place.ty(&self.local_decls, self.tcx);
-        debug!(?place, ?place_ty,);
+        debug!(?place, ?place_ty);
 
         let source_info = self.source_info(test.span);
         match test.kind {

compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs

@@ -229,7 +229,7 @@ impl<'tcx> ConstToPat<'tcx> {
     }
 
     // Recursive helper for `to_pat`; invoke that (instead of calling this directly).
-    #[instrument(skip(self), level = "debug")]
+    #[instrument(skip(self), level = "debug", ret)]
     fn recur(
         &self,
         cv: mir::ConstantKind<'tcx>,

library/core/src/time.rs

@@ -35,6 +35,8 @@ const MICROS_PER_SEC: u64 = 1_000_000;
 #[rustc_layout_scalar_valid_range_end(999_999_999)]
 struct Nanoseconds(u32);
 
+impl crate::marker::StructuralPartialEq for Nanoseconds {}
+
 impl PartialEq for Nanoseconds {
     fn eq(&self, other: &Self) -> bool {
         self.0 as u32 == other.0 as u32

tests/mir-opt/match_pattern_type.rs

@@ -0,0 +1,11 @@
+use std::time::Duration;
+
+// EMIT_MIR match_pattern_type.system_time_math.built.after.mir
+fn system_time_math() {
+    match Duration::ZERO {
+        Duration::ZERO => {}
+        _ => {}
+    }
+}
+
+fn main() {}

tests/mir-opt/match_pattern_type.system_time_math.built.after.mir

@@ -0,0 +1,39 @@
+// MIR for `system_time_math` after built
+
+fn system_time_math() -> () {
+    let mut _0: ();                      // return place in scope 0 at $DIR/match_pattern_type.rs:+0:23: +0:23
+    let mut _1: std::time::Duration;     // in scope 0 at $DIR/match_pattern_type.rs:+1:11: +1:25
+
+    bb0: {
+        StorageLive(_1);                 // scope 0 at $DIR/match_pattern_type.rs:+1:11: +1:25
+        _1 = const _;                    // scope 0 at $DIR/match_pattern_type.rs:+1:11: +1:25
+                                         // mir::Constant
+                                         // + span: $DIR/match_pattern_type.rs:5:11: 5:25
+                                         // + literal: Const { ty: Duration, val: Unevaluated(Duration::ZERO, [], None) }
+        FakeRead(ForMatchedPlace(None), _1); // scope 0 at $DIR/match_pattern_type.rs:+1:11: +1:25
+        switchInt((_1.0: u64)) -> [0: bb1, otherwise: bb3]; // scope 0 at $DIR/match_pattern_type.rs:+1:5: +1:25
+    }
+
+    bb1: {
+        switchInt((((_1.1: core::time::Nanoseconds).0: u32 is 0..=999999999) as u32)) -> [0: bb2, otherwise: bb3]; // scope 0 at $DIR/match_pattern_type.rs:+1:5: +1:25
+    }
+
+    bb2: {
+        falseEdge -> [real: bb4, imaginary: bb3]; // scope 0 at $DIR/match_pattern_type.rs:+2:9: +2:23
+    }
+
+    bb3: {
+        _0 = const ();                   // scope 0 at $DIR/match_pattern_type.rs:+3:14: +3:16
+        goto -> bb5;                     // scope 0 at $DIR/match_pattern_type.rs:+3:14: +3:16
+    }
+
+    bb4: {
+        _0 = const ();                   // scope 0 at $DIR/match_pattern_type.rs:+2:27: +2:29
+        goto -> bb5;                     // scope 0 at $DIR/match_pattern_type.rs:+2:27: +2:29
+    }
+
+    bb5: {
+        StorageDead(_1);                 // scope 0 at $DIR/match_pattern_type.rs:+5:1: +5:2
+        return;                          // scope 0 at $DIR/match_pattern_type.rs:+5:2: +5:2
+    }
+}