Regression of incorrect literal inference in generic function in 3.4

[fantaclaus]

TypeScript Version: 3.4.1 ... 3.4.5, 3.5.0-dev.20190517
Search Terms: enum is not assignable to type

Code

class M<T>
{
}

function test<V>(m: M<V>, f: () => V)
{
}

enum Enum
{
	A,
	B,
}

class ClassWithConvert<T>
{
	constructor(init: T)
	{
	}
	convert<U>(converter: { to: (v: T) => U; from: (v: U) => T; })
	{
	}
}

const m2 = new M<ClassWithConvert<Enum>>();
test(m2, () => new ClassWithConvert(Enum.A));

Expected behavior:
no errors

Actual behavior:
Error:

Type 'ClassWithConvert<Enum.A>' is not assignable to type 'ClassWithConvert<Enum>'.
  Type 'Enum' is not assignable to type 'Enum.A'.

Playground Link (Note: Option strictFunctionTypes must be checked!)

Related Issues:
These issues look similar: #31204 #28102

When I tried to compile with typescript@next (3.5.0-dev.20190517) I've got more detailed error description:

error TS2322: Type 'ClassWithConvert<Enum.A>' is not assignable to type 'ClassWithConvert<Enum>'.
  Types of property 'convert' are incompatible.
    Type '<U>(converter: { to: (v: Enum.A) => U; from: (v: U) => Enum.A; }) => void' is not assignable to type '<U>(converter: { to: (v: Enum) => U; from: (v: U) => Enum; }) => void'.
      Types of parameters 'converter' and 'converter' are incompatible.
        Type '{ to: (v: Enum) => any; from: (v: any) => Enum; }' is not assignable to type '{ to: (v: Enum.A) => any; from: (v: any) => Enum.A; }'.
          Types of property 'from' are incompatible.
            Type '(v: any) => Enum' is not assignable to type '(v: any) => Enum.A'.
              Type 'Enum' is not assignable to type 'Enum.A'.

[RyanCavanaugh]

The error and its explanation are correct

[dragomirtitian]

@RyanCavanaugh are you sure this is working as intended? This behavior is a breaking change from 3.3 link.

In 3.4 T in ClassWithConvert gets inferred to the enum literal Enum.A while in 3.3 it is inferred to the enum Enum. I find this odd since there is no constraint on T and I thought that was the hint the compiler would look for in inferring literal types.

[RyanCavanaugh]

Here's the "obviously wrong" version that regressed at 3.4:

// @strictFunctionTypes: true
enum Enum { A, B }

class ClassWithConvert<T> {
  constructor(val: T) { }
  convert(converter: { to: (v: T) => T; }) { }
}

function fn<T>(arg: ClassWithConvert<T>, f: () => ClassWithConvert<T>) { }
fn(new ClassWithConvert(Enum.A), () => new ClassWithConvert(Enum.A));

[ahejlsberg]

Even simpler example:

// @strictFunctionTypes: true

enum Enum { A, B }

class Contra<T> {
  f: (x: T) => void;
  constructor(x: T) {}
}

let zz: Contra<Enum> = new Contra(Enum.A);

The constructor argument is contextually typed by type Enum and we therefore preserve the enum literal type Enum.A. But, since T is contravariant in Contra<T>, Contra<Enum.A> is not assignable to Contra<Enum>.

It worked in 3.3 because we didn't contextually type through generic return types and therefore promoted the Enum.A argument to type Enum.

[fantaclaus]

Could you please tell me why Enum is regarded as equal to Enum.A, when Enum contains the only member A?

In such case there is no error in all these samples.

[RyanCavanaugh]

Enums defined with that syntax are basically aliases for the union of their members, i.e. Enum is short for Enum.A | Enum.B. So the single-member enum Enum { A } is equivalent to Enum.A

[fantaclaus]

Thank you. Now I see.