Bug with type argument inference if it has default value `= undefined` and actual value is object with non-arrow function

[termi]

There is a difference in how TypeScript infers the type automatically based on type of the argument we pass in:

• how the value is declared (inline or by reference)
• whether the value is an inline object with non-arrow function

The error is reproduced if generic parameter has default value undefined (this is mandatory in my case.)

🔎 Search Terms

• "generics in constructor"
• "type argument inference undefined"

🕗 Version & Regression Information

• This is the behavior in every version I tried from 3.9.7 to 5.9.3

⏯ Playground Link

• This issue with function
• This issue with class

💻 Code

This issue with function:

function make<T, S=T, D=undefined>(value: T, options: NewOptions<T, S, D>) {
  return {
    v: value,
    data: options?.data,
    sourceValue: options?.sourceValue ?? value,
    finaleValue: options?.finaleValue,
  };
}

export type NewOptions<T, S, D> = {
  finaleValue?: T,
  sourceValue?: S,
  data: D,
};

const instance_withError = make(0, {
   // Error here: `Type '{ test(): number; }' is not assignable to type 'undefined'.(2322)`?
    data: {
        test() {
            return 123;
        },
    },
});

const data = {
    test() {
        return 123;
    },
};
// no error here
const instance1 = make(0, {
    // data is not inline object, BUT object with non-arrow function
    data,
    sourceValue: 'test',
    finaleValue: 1,
});

// no error here
const instance2 = make(0, {
    // data is inline object, BUT object with arrow function
    data: {
         test: () => {
            return 123;
        },
    },
    sourceValue: 1,
    finaleValue: 2,
});
const sV1 = instance2.sourceValue;
//    ^?
const v1 = instance2.v;
//    ^?


const sV2 = instance1.sourceValue;
//    ^?
const v2 = instance1.v;
//    ^?


// Should be `{ test(): number; }`
const data_invalid = instance_withError.data;
//    ^?
// Should be `{ test(): number; }`
const data1 = instance1.data;
//    ^?
// Should be `{ test: () => number; }`
const data2 = instance2.data;
//    ^?

🙁 Actual behavior

1. An error occurs:
   Type '{ test(): number; }' is not assignable to type 'undefined'.(2322)
2. data type is undefined

🙂 Expected behavior

1. No error occurs
2. data type is { test(): number; }

[nmain]

There's a lot of extra fluff in that repro, isn't it just this?

Playground

declare function make<D=undefined>(options: D): any;

// cant infer
make({
    test() {
        return 123;
    },
});

// can explictly call
make<{ test(): number }>({
    test() {
        return 123;
    },
})

// can infer with arrow function
make({
    test: () => {
        return 123;
    },
});

[MartinJohns]

Likely a duplicate of #47599.

[termi]

There's a lot of extra fluff in that repro, isn't it just this?

The reason why my example has 3 generic parameters

declare function make<T, S=T, D=undefined>(value: T, options: NewOptions<T, S, D>);

is to show that D=undefined default value is necessary here and cannot be removed.

Is you case

declare function make<D=undefined>(options: D): any;

we can just remove =undefined and all will work fine.

[termi]

Likely a duplicate of #47599.

It's related, but not duplicate.
In my case, adding =undefined in generic parameter causes a problem.

[Andarist]

This is already fixed by #62243 . You can try out nightly build.

[RyanCavanaugh]

Confirmed in nightly playground