ICE when pattern matching on `&dyn PartialEq`.

[lcnr]

const F: &'static dyn PartialEq<u32> = &7u32;

fn main() {
    let a: &dyn PartialEq<u32> = &7u32;
    match a {
        F => panic!(),
        _ => {}
    }
}

causes an ICE on the current nightly

error: internal compiler error: src/librustc_mir_build/hair/pattern/_match.rs:363: cannot deref ByRef {
    alloc: Allocation {
        bytes: [
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
            0,
        ],
        relocations: Relocations(
            SortedMap {
                data: [
                    (
                        Size {
                            raw: 0,
                        },
                        (
                            (),
                            a2,
                        ),
                    ),
                    (
                        Size {
                            raw: 8,
                        },
                        (
                            (),
                            a4,
                        ),
                    ),
                ],
            },
        ),
        init_mask: InitMask {
            blocks: [
                65535,
            ],
            len: Size {
                raw: 16,
            },
        },
        size: Size {
            raw: 16,
        },
        align: Align {
            pow2: 3,
        },
        mutability: Not,
        extra: (),
    },
    offset: Size {
        raw: 0,
    },
}, dyn std::cmp::PartialEq<u32> -> dyn std::cmp::PartialEq<u32>

thread 'rustc' panicked at 'Box<Any>', src/librustc_errors/lib.rs:907:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Afaik this is caused by ty_is_partial_eq being slightly too permissive

rust/src/librustc_mir_build/hair/pattern/const_to_pat.rs

Lines 143 to 157 in 997d953

	let ty_is_partial_eq: bool = {
	let partial_eq_trait_id =
	self.tcx().require_lang_item(EqTraitLangItem, Some(self.span));
	let obligation: PredicateObligation<'_> = predicate_for_trait_def(
	self.tcx(),
	self.param_env,
	ObligationCause::misc(self.span, self.id),
	partial_eq_trait_id,
	0,
	cv.ty,
	&[],
	);
	// FIXME: should this call a `predicate_must_hold` variant instead?
	self.infcx.predicate_may_hold(&obligation)
	};

See #71038 (comment) for more details.

[Alexendoo]

No longer ICEs after #70743, needs a test