#![feature(allocator_api)]

use std::alloc::{Allocator, Global, Layout, System};

// upstream function using PartialEq guarantees
fn safe_func<A: Allocator + PartialEq + ?Sized>(x: &A, y: &A) {
    let layout = Layout::from_size_align(10000, 512).unwrap();
    let block = x.allocate(layout).unwrap();
    assert_eq!(x, y);
    // SAFETY:
    // - Deallocating `block` with `x` is trivially safe
    // - x == y, so the allocators can be used interchangably
    unsafe { y.deallocate(block.cast(), layout) };
}

// downstream crate without `unsafe`
trait NewTrait: Allocator {}
impl<A: Allocator> NewTrait for A {}

impl PartialEq for dyn NewTrait + '_ {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

fn confuse_allocators<A: Allocator, B: Allocator>(a: &A, b: &B) {
    safe_func::<dyn NewTrait>(a, b);

    // Version that also works without `+ ?Sized`:
    safe_func::<&dyn NewTrait>(&(a as _), &(b as _));
}

use jemallocator::Jemalloc;

#[global_allocator]
static GLOBAL: Jemalloc = Jemalloc;

fn main() {
    confuse_allocators(&Global, &System);
}