#![feature(core_intrinsics)]
use std::intrinsics::type_name;

/////////////////////////////////////////////////////////////////////
// Suppose these are the real traits from Serde.

trait Querializer {}

trait Generic {
    // Not object safe because of this generic method.
    fn generic_fn<Q: Querializer>(&self, querializer: Q);
}

impl<'a, T> Querializer for &'a T where T: Querializer + ?Sized {}

impl<'a, T> Generic for Box<T> where T: Generic + ?Sized {
    fn generic_fn<Q: Querializer>(&self, querializer: Q) {
        let name = unsafe { type_name::<T>() };
        println!("impl-1# T=({})#\t\t call to 'generic_fn()' for 'impl<'a, T> Generic for Box<T> where T: Generic + ?Sized'", name);
        (**self).generic_fn(querializer)
    }
}

/////////////////////////////////////////////////////////////////////
// This is an object-safe equivalent that interoperates seamlessly.

trait ErasedGeneric {
    fn erased_fn(&self, querializer: &Querializer);
}

impl Generic for ErasedGeneric {
    // Depending on the trait method signatures and the upstream
    // impls, could also implement for:
    //
    //   - &'a ErasedGeneric
    //   - &'a (ErasedGeneric + Send)
    //   - &'a (ErasedGeneric + Sync)
    //   - &'a (ErasedGeneric + Send + Sync)
    //   - Box<ErasedGeneric>
    //   - Box<ErasedGeneric + Send>
    //   - Box<ErasedGeneric + Sync>
    //   - Box<ErasedGeneric + Send + Sync>
    fn generic_fn<Q: Querializer>(&self, querializer: Q) {
        println!("impl-2# T=([hardcoded]ErasedGeneric)#\t call to 'generic_fn()' for 'impl Generic for ErasedGeneric'");
        self.erased_fn(&querializer)
    }
}

impl<T> ErasedGeneric for T where T: Generic {
    fn erased_fn(&self, querializer: &Querializer) {
        let name = unsafe { type_name::<T>() };
        println!("impl-3# T=({})#\t\t\t call to 'erased_fn()'  for 'impl<T> ErasedGeneric for T where T: Generic'", name);
        self.generic_fn(querializer)
    }
}

fn main() {
    struct T;
    impl Querializer for T {}

    struct S;
    impl Generic for S {
        fn generic_fn<Q: Querializer>(&self, _querializer: Q) {
            println!("impl-4# T=([hard-coded]S)#\t\t call to 'generic_fn()' querying the real S");
        }
    }

    // Construct a trait object.
    let trait_object: Box<ErasedGeneric> = Box::new(S{});

    // Seamlessly invoke the generic method on the trait object.
    //
    // THIS LINE LOOKS LIKE MAGIC. We have a value of type trait
    // object and we are invoking a generic method on it.
    println!("---- call-1# trait_object.generic_fn(T); --\n");
    trait_object.generic_fn(T{});

    println!("\n---- call-2# (*trait_object).generic_fn(T); --\n");
    (*trait_object).generic_fn(T{});
}