class extends basis class with generic compile error

[HerrCai0907]

Hello,
Is this compile error reasonable? I'm not sure whether assemblyscript supports the way of following inheritance.

ERROR TS2322: Type '(this: assembly/index/B<f64,~lib/string/String>, f64) => void' is not assignable to type '(this: assembly/index/A, i32) => void'.

 foo(a:T):void{

class A<T>{
    foo(a:T):void{
        trace(`class A ${a}`)
    }
}
class B<T,V> extends A<T>{
    foo(a:T):void{
        trace(`class B ${a}`)
    }
}
export function test_foo():void{
    let v = new B<i32,f64>()
    let v2 = new B<i32,string>()
    let v3 = new B<f64,string>() // if comment this line, compile OK
    const v_usize = changetype<usize>(v)
    changetype<A<i32>>(v_usize).foo(1)
}

[HerrCai0907]

replace const v_usize = changetype<usize>(v); changetype<A<i32>>(v_usize).foo(1); with (<A<i32>>v).foo(1);, it still compiles error.

[willemneal]

I've seen this error before too and it is not reasonable. The presence of a different implementation of the class shouldn't affect the type resolution of another. I also found that if I change to casting instead of using changetype the same thing happens:

class A<T>{
    foo(a:T):void{
        trace(`class A ${a}`)
    }
}
class B<T,V> extends A<T>{
    foo(a:T):void{
        trace(`class B ${a}`)
    }
}
export function test_foo():void{
    let v = new B<i32,f64>();
    let v2 = new B<i32,string>();
    let v3 = new B<f64,string>(); // if comment this line, compile OK
    (<A<i32>>v).foo(1)
}

[willemneal]

Digging into the compiler it seems that concrete instances of A<T>, e.g. A<i32> share's the same mapping of instances of all instances. All instances are checked against it regardless thus causing this error.

[trusktr]

I think I ran into an issue like this when extending from Map<T>'s and passing different types from the Subclass<T> to the Map<T>: the type system would complain about the type of an unrelated class being wrong.

In my particular case, I solved it by wrapping/containing a Map<t> in a non-subclass, instead of extending from Map<T>. This works but is more work to implement all the proxy methods (otherwise they would simply be inherited).

[willemneal]

@trusktr, my linked PR should fix this so you can try checking out that branch if you want to get around it now.