class Test {
    static function main() {
        // should trace "C"
        trace(new A<Int>()); // "C"
        // should trace "D"
        trace(new A<String>()); // "[object B_Impl_]", issues with double inlined @:to
    }
}

@:multiType(T)
@:forward
abstract A<T>(B<T>) {
    public function new();
    @:to static function aToC<T:Int>(b:B<T>):B<Int> { return new B<Int>(); }
    @:to static inline function aToD<T:String>(b:B<T>):B<String> { return new B<String>(); }
}

@:multiType(T)
@:forward
abstract B<T>(I<T>) {
    public function new();
    @:to static function bToC<T:Int>(c:I<T>):C { return new C(); }
    @:to static function bToD<T:String>(d:I<T>):D { return new D(); }
}

class C implements I<Int> {
    public function new() { }
    public function toString():String { return "C"; }
}

class D implements I<String> {
    public function new() { }
    public function toString():String { return "D"; }
}

interface I<T> {
    function toString():String;
}