`A should be B` when passing a bare `Class` reference to an abstract enum wrapper

[T1mL3arn]

When passing a bare class reference identifier (e.g., Foo) directly into a function parameter typed as an abstract enum wrapper OneOf<String, Class<Any>> @:from should return Right. But instead compiler throws Class<Foo> should be OneOf<String, Class<Any>>.

No error if class is stored in a typed variable.

https://try.haxe.org/#E9de3B35

import haxe.ds.Either;

class Test {
	static function main() {
		// works
		test('hi');

		// works
		var c:Class<Foo> = Foo;
		test(c);

		// doesnt work
		test(Foo);

		// works
		test(cast Right(Foo));
	}

	static function test(val:OneOf<String, Class<Any>>) {}
}

class Foo {}

abstract OneOf<A, B>(Either<A, B>) from Either<A, B> to Either<A, B> {
	@:from inline static function fromA<A, B>(a:A):OneOf<A, B> {
		return Left(a);
	}

	@:from inline static function fromB<A, B>(b:B):OneOf<A, B> {
		return Right(b);
	}
}

[ERROR] Test.hx:13: characters 8-11

 13 |   test(Foo);
    |        ^^^
    | Class<Foo> should be OneOf<String, Class<Any>>
    | For function argument 'val'

[kLabz]

Not sure at what point the Foo => Class<Foo> happens, but that plus @:from is too much for the compiler at the moment.

A workaround is to explicitly handle such cases:

abstract OneOf<A, B>(Either<A, B>) from Either<A, B> to Either<A, B> {
	@:from inline static function fromA<A, B>(a:A):OneOf<A, B> {
		return Left(a);
	}

	@:from inline static function fromB<A, B>(b:B):OneOf<A, B> {
		return Right(b);
	}
  
	@:from inline static function fromClassA<A, B>(a:Class<A>):OneOf<Class<A>, B> {
		return Left(a);
	}
  
	@:from inline static function fromClassB<A, B>(b:Class<B>):OneOf<A, Class<B>> {
		return Right(b);
	}
}

[T1mL3arn]

Thanks for the workaround.