Types become compatible after update to version 3.8.1-rc

[FrankEssenberger]

Context

In our project we have type tests using dtslint and if we update the TS version some expected type errors disappear. I have extracted a minimal sample from our project (see code below).
The problem appears for all version after 3.8.1-rc including the latest builds.

Steps to reproduce:

• Take the code snipped
• Execute the snipped in the playground or locally
• Depending on the TS version the error on doSomethingConstructable(...) disappears

Code

export class Field<EntityT> {
    constructor(readonly prop: Constructable<EntityT>) {
    }
}

export interface Constructable<EntityT,NotUsed={}> {
    someField: Field<EntityT>;
}

export class TestEntity1   {
    prop_1!: boolean;
    static someField: Field<TestEntity1> = new Field( TestEntity1)
}

export class TestEntity2  {
    prop_2!: boolean;
    static someField: Field<TestEntity2> = new Field( TestEntity2)
}

function doSomethingEntity<T>(...entity: T[]) { }
//Expected error (present for version 3.7.X and 3.8.X)
doSomethingEntity(TestEntity1,TestEntity2)

function doSomethingConstructable<T>(...entity: Constructable<T>[]) { }
//Expected error  (this one disappears if you update to version 3.8.1-rc)
doSomethingConstructable(TestEntity1,TestEntity2)

Thank you for support on this issue. Perhaps we are using something wrong. I realized, that the issue is somehow related to the default generic type. When I remove it, I get the same behavior for the 3.7.X and 3.8.X version. I think I can fix the problem by not using the default type and passing around the second paramter everywhere. But this would lead to a major code change in our project and it also worked in the version prior to 3.8.1-rc.

Expected behavior:
Type error for doSomethingEntity() and doSomethingConstructable(...) independent of the TS version.

Actual behavior:
When you use version 3.8.1-rc and above the error on doSomethingConstructable(...) disappears.

Playground Link: link

[RyanCavanaugh]

This is the intended behavior and I'm not sure why it was an error before. The question at hand is whether typeof TestEntity2 is a valid Constructable<TestEntity1>, and it is -- a structural examination of this would reveal no contradiction of that. Constructable<TestEntity1> requires an infinite sequence of .someField.prop.someField.prop...., and typeof TestEntity2 satisfies that.

[FrankEssenberger]

Thanks Ryan for your quick response and the analysis. I see your point and I think I simplified the example a bit too much. The actual problem we have in our Project is on a related class called Field. I adjusted the playground with an extended example to illustrate the issue.

Code:

export class Field<EntityT> {
    // private myEntity:EntityT;
    constructor(readonly prop: Constructable<EntityT>) {
    }
}

export class DummyField<EntityT> {
    constructor(readonly prop2: Constructable<EntityT>) {
    }
}

type UnionFields<EntityT> = Field<EntityT> | DummyField<EntityT>

export interface Constructable<EntityT ,NotUsed={}> { //When you remove the NotUsed={} the type error is present.
    someFields: UnionFields<EntityT>;
    myEntity:EntityT
}

export class TestEntity1   {
    prop_1!: boolean;
    static myEntity:TestEntity1;
    static someFields: UnionFields<TestEntity1> = new Field( TestEntity1)
}

export class TestEntity2  {
    prop_2!: boolean;
    static myEntity:TestEntity2;
    static someFields: UnionFields<TestEntity2>= new Field( TestEntity2)
}

//Expected Error
function doSomethingEntity<T>(...entity:T[]){}
doSomethingEntity(TestEntity1,TestEntity2)

//Expected Error
function doSomethingConstructable<T>(...entity:Constructable<T>[]){}
doSomethingConstructable(TestEntity1,TestEntity2)

//Expected Error (disappears if you add a second Field AND you have the NotUsed={} in the generic)
function doSomethingFields<T>(...fields:Field<T>[]){}
doSomethingFields(new Field(TestEntity1),new Field(TestEntity2))

So I added a property myEntity to the Constructable so that they are not compatible. This is also found by the three "doSomething" methods in 3.7.X and 3.8.3. So far so good. However, when I have a default value for the generic NotUsed={} AND a union type including the DummyField the type error doSomethingFields() disappears in version 3.8.3 but is present in 3.7.X. Note that the second generic parameter is not used at all and the dummy field also not used in the entities explicitly.

So it seems strange to me why this has an effect on the type compatibility. Especially the unused generic parameter with the default value should not make any difference.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.

[RyanCavanaugh]

Wesley Wigham (@weswigham) the thing we need investigated is why removing the unused NotUsed = {} type parameter changes the errorness of the last line

[FrankEssenberger]

Cool, thanks for looking into it.