Generic type no longer narrowed as expected without extends object

[mjbvz]

Bug Report

🔎 Search Terms

🕗 Version & Regression Information

• Regression in: 4.7.0-dev.20220325
• Works in 4.7.0-dev.20220323

⏯ Playground Link

Playground currently doesn't show the error:

Playground link

💻 Code

function deepEquals<T>(a: T, b: T): boolean {
    if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
        return false;
    }
    if (Array.isArray(a) || Array.isArray(b)) {
        return false;
    }
    if (Object.keys(a).length !== Object.keys(b).length) { // Error here
        return false;
    }
    return true;
}

🙁 Actual behavior

The calls to Object.keys generate errors:

No overload matches this call.
  Overload 1 of 2, '(o: {}): string[]', gave the following error.
    Argument of type 'T' is not assignable to parameter of type '{}'.
  Overload 2 of 2, '(o: object): string[]', gave the following error.
    Argument of type 'T' is not assignable to parameter of type 'object'.

🙂 Expected behavior

No errors

[mjbvz]

This code previously worked for us in VS Code but is now causing around 11 errors in our codebase. Not sure if simply adding a extends object constraint is the correct fix in all cases

[whzx5byb]

It seems to be caused by #48366, which is tagged as "Breaking Change".

Now you can't assign a unconstrained type parameter T to T extends {} or T extends object. See also #37388

[DanielRosenwasser]

CC @weswigham

Looks like the following will work

function deepEquals<T extends {} | null | undefined>(a: T, b: T): boolean {
    if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
        return false;
    }
    if (Array.isArray(a) || Array.isArray(b)) {
        return false;
    }
    if (Object.keys(a).length !== Object.keys(b).length) {
        return false;
    }
    return true;
} 

and so will

function deepEquals<T extends object | null | undefined>(a: T, b: T): boolean {
    if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
        return false;
    }
    if (Array.isArray(a) || Array.isArray(b)) {
        return false;
    }
    if (Object.keys(a).length !== Object.keys(b).length) {
        return false;
    }
    return true;
} 

but not

function deepEquals<T extends unknown>(a: T, b: T): boolean {
    if (typeof a !== 'object' || typeof b !== 'object' || !a || !b) {
        return false;
    }
    if (Array.isArray(a) || Array.isArray(b)) {
        return false;
    }
    if (Object.keys(a).length !== Object.keys(b).length) {
        return false;
    }
    return true;
} 

Note that the first two only likely work due to @ahejlsberg's change in #43183. I don't know if we're willing to do something special for unknown or all non-unions.

[mjbvz]

Also seeing this in the @playwright/test package. See this issue for repo steps and details about the error

[DanielRosenwasser]

Playing around with a fix here FWIW

#48576

[arnold-O]

The Generic type without constraint is vague, hence with the extends keyword you clearly state what you want that Generic type to be, which is the reason for Typescript.