Support if-let-guard in matches! and assert_matches!

[SpriteOvO]

Closes #152313, and if-let-guard is stabilized in #141295 just now.

Motivations

Simplify code where match and let-else are used for assertions. For examples, see files:

• https://github.com/rust-lang/rust/blob/e0cb264b814526acb82def4b5810e394a2ed294f/library/coretests/tests/mem/type_info.rs
• https://github.com/9SonSteroids/rust/blob/7287be900699468bb8a2d9b4705f3545aa28c451/library/coretests/tests/mem/fn_ptr.rs (PR Reflection TypeKind::FnPtr #152173)

-    const {
-        match Type::of::<(i8, u8)>().kind {
-            TypeKind::Tuple(tup) => {
-                let [a, b] = tup.fields else { unreachable!() };
-
-                assert!(a.offset == 0);
-                assert!(b.offset == 1);
-
-                match (a.ty.info().kind, b.ty.info().kind) {
-                    (TypeKind::Int(a), TypeKind::Int(b)) => {
-                        assert!(a.bits == 8 && a.signed);
-                        assert!(b.bits == 8 && !b.signed);
-                    }
-                    _ => unreachable!(),
-                }
-            }
-            _ => unreachable!(),
-        }
-    }
+    assert_matches!(
+        const { Type::of::<(i8, u8)>().kind }, TypeKind::Tuple(tup)
+            if let [a, b] = tup.fields
+            && a.offset == 0
+            && b.offset == 1
+            && let (TypeKind::Int(a), TypeKind::Int(b)) = (a.ty.info().kind, b.ty.info().kind)
+            && a.bits == 8 && a.signed
+            && b.bits == 8 && !b.signed
+    );

     struct TestStruct {
         first: u8,
         second: u16,
         reference: &'static u16,
     }
-    const {
-        let Type { kind: Struct(ty), size, .. } = Type::of::<TestStruct>() else { panic!() };
-        assert!(size == Some(size_of::<TestStruct>()));
-        assert!(!ty.non_exhaustive);
-        assert!(ty.fields.len() == 3);
-        assert!(ty.fields[0].name == "first");
-        assert!(ty.fields[0].ty == TypeId::of::<u8>());
-        assert!(ty.fields[0].offset == offset_of!(TestStruct, first));
-        assert!(ty.fields[1].name == "second");
-        assert!(ty.fields[1].ty == TypeId::of::<u16>());
-        assert!(ty.fields[1].offset == offset_of!(TestStruct, second));
-        assert!(ty.fields[2].name == "reference");
-        assert!(ty.fields[2].ty == TypeId::of::<&'static u16>());
-        assert!(ty.fields[2].offset == offset_of!(TestStruct, reference));
-    }
+    assert_matches!(
+        const {Type::of::<TestStruct>() }, Type { kind: Struct(ty), size, .. }
+           if size == Some(size_of::<TestStruct>())
+           && !ty.non_exhaustive
+           && ty.fields.len() == 3
+           && ty.fields[0].name == "first"
+           && ty.fields[0].ty == TypeId::of::<u8>()
+           && ty.fields[0].offset == offset_of!(TestStruct, first)
+           && ty.fields[1].name == "second"
+           && ty.fields[1].ty == TypeId::of::<u16>()
+           && ty.fields[1].offset == offset_of!(TestStruct, second)
+           && ty.fields[2].name == "reference"
+           && ty.fields[2].ty == TypeId::of::<&'static u16>()
+           && ty.fields[2].offset == offset_of!(TestStruct, reference)
+    );

Notes

At the moment, it seems we cannot fully port const-eval only operations (e.g. file https://github.com/rust-lang/rust/blob/e0cb264b814526acb82def4b5810e394a2ed294f/library/coretests/tests/mem/type_info.rs) to use assert_matches! with if-let-guards, because of:

• assert_matches!(
      const { Type::of::<(i8, u8)>().kind }, TypeKind::Tuple(tup)
          if let [a, b] = tup.fields
          && let (TypeKind::Int(a), TypeKind::Int(b)) = (a.ty.info().kind, b.ty.info().kind)
  );

  triggers a runtime panic

  rust/library/core/src/intrinsics/mod.rs

  Lines 2872 to 2874 in e0cb264

  	pub const fn type_of(_id: crate::any::TypeId) -> crate::mem::type_info::Type {
  	panic!("`TypeId::info` can only be called at compile-time")
  	}

• const {
      assert_matches!(
          Type::of::<(i8, u8)>().kind, TypeKind::Tuple(tup)
              if let [a, b] = tup.fields
              && let (TypeKind::Int(a), TypeKind::Int(b)) = (a.ty.info().kind, b.ty.info().kind)
      );
  }

  triggers error[E0015]: cannot call non-const function 'core::panicking::assert_matches_failed::<_>' in constants. (blocked by const functions can assert! but cannot assert_eq! #119826)

Todo

• Documentation updates.

r? theemathas
cc @rustbot ping libs-api

[SpriteOvO]

cc @rust-lang/libs-api

[fmease]

r? libs

[theemathas]

Needs another test for assert_matches!() with a panic message.

[SpriteOvO]

Oh, so looks like we can't simply use $(tt)+ to catch if-let guards because it also catches the comma and panic message.

Does this mean we have to start implementing it as a compiler built-in macro? Especially since we already have 4 arms here.

[Mark-Simulacrum]

Nominating for discussion. It seems like this might be hard to implement (no longer just macro_rules?), so we should offer guidance on whether we want it before any further implementation delta. It seems also possible that we should add (unstable?) $guard:guard to the macro-rules rules, so that std and users have a representation for the full match arm guard, rather than needing to reconstruct it's flexibility manually (though that's at least partially a lang question).