static extension with @:generic type

[Antriel]

All works if Data is not made @:generic. Two issues:

• Is Data<String> not supposed to work with function foo<T>(d:Data<T>), if it's generic?
• The difference in behavior between explicit using Extension; vs default @:using(Extension).

using Test.ExtensionA;
class Test {
    static function main() {
        var p = new Data("foo");
        ExtensionA.getDataA_A(p); // Error. `Data_String should be Data<Unknown<0>>` why?
        ExtensionA.getDataA_B(p); // Works.
        ExtensionB.getDataB_A(p); // Error. Same behavior for explicit or metadata `using`.
        ExtensionB.getDataB_B(p); // Works.
        p.getDataA_A(); // Error. Basically the same behavior as with direct calls.
        p.getDataA_B(); // Works.
        p.getDataB_A(); // Error.
        p.getDataB_B(); // Error. Just because it's a default extension via `@:using`?
    }
}

@:using(Test.ExtensionB)
@:generic class Data<T> {
    public var data:T;
    public function new(data) this.data = data;
}

class ExtensionA {
    @:generic public static function getDataA_A<T>(d:Data<T>) return d.data;
    @:generic public static function getDataA_B<T, D:{data:T}>(d:D) return d.data;
}

class ExtensionB {
    @:generic public static function getDataB_A<T>(d:Data<T>) return d.data;
    @:generic public static function getDataB_B<T, D:{data:T}>(d:D) return d.data;
}

[Simn]

This issue is a convoluted mess.

The difference between normal/default using can be seen here:

using Main.ExtensionA;

class Main {
	static function main() {
		var p = new Data("foo");
		p.normalUsing();
		p.defaultUsing(); // Data_String has no field defaultUsing
	}
}

@:using(Main.ExtensionB)
@:generic
class Data<T> {
	public var data:T;

	public function new(data)
		this.data = data;
}

class ExtensionA {
	public static function normalUsing<D>(d:D) {
		return null;
	}
}

class ExtensionB {
	public static function defaultUsing<D>(d:D) {
		return null;
	}
}

I expected this to work after d1a2bd1, but it doesn't.