#![feature(raw)]
#![deny(bare_trait_objects)]

macro_rules! const_transmute {(
    [$src:ty => $dst:ty] ($expr:expr)
) => ({
    const _GUARD: [();
        mem::size_of::<$src>()
    ] = [();
        mem::size_of::<$dst>()
    ];

    union Transmute {
        src: $src,
        dst: $dst,
    }

    Transmute {
        src: $expr,
    }.dst
})}

use ::std::*;

pub
trait Trait {
    fn method_1 (&'_ self);
    fn method_2 (&'_ self, _: i32) -> i32;
}

struct Double;
impl Trait for Double {
    fn method_1 (self: &'_ Self)
    {
        eprintln!("Double");
    }
    fn method_2 (self: &'_ Self, x: i32) -> i32 { 2 * x }
}

struct Triple;
impl Trait for Triple {
    fn method_1 (self: &'_ Self)
    {
        eprintln!("Triple");
    }
    fn method_2 (self: &'_ Self, x: i32) -> i32 { 3 * x }
}

fn foo (object: &'_ dyn Trait)
{
    object.method_1();
    let _ = object.method_2(42);
}

const DOUBLE: Double = Double; // this is the hard part

const AT_DYN_TRAIT: &'static dyn Trait = (&DOUBLE);
const DYN_TRAIT_VTABLE: *mut () = unsafe {
    const_transmute!([&'static dyn Trait => raw::TraitObject](
        AT_DYN_TRAIT
    )).vtable
};

fn main ()
{
    dbg!(DYN_TRAIT_VTABLE);
    foo(&Double);
    eprintln!("vtable: {:p}",
        unsafe { mem::transmute::<&dyn Trait, raw::TraitObject>(&Double) }.vtable,
        // unsafe { **(mem::transmute::<&dyn Trait, raw::TraitObject>(&Double).vtable as *mut *mut usize) },
    );
    foo(&Triple);
    eprintln!("vtable: {:p}",
        unsafe { mem::transmute::<&dyn Trait, raw::TraitObject>(&Triple) }.vtable,
    );
}