fix(43030): undefined[] converted to any[] in JS

[a-tarasyuk]

Fixes #43030

[DanielRosenwasser]

Now I really don't understand the subtleties here.

[a-tarasyuk]

@DanielRosenwasser I think this issue is a little bit tricky. The problem here is that for Nullable types (only in JavaScript files and in both strict and not strict modes), the checker returns any. It doesn't matter if it's defined explicitly or implicitly.

/** @type {() => undefined} */
function f1() {
    return undefined;
}
const a = f1()
>a : any
>f1() : undefined
>f1 : () => undefined

/** @type {() => null} */
function f1() {
    return null;
}
const a = f1()
>a : any
>f1() : undefined
>f1 : () => undefined

For instance for a similar case for arrays (line #32342) the checker checks to implicitNeverType in strict mode and for undefinedWideningType in non-strict mode., maybe we need to use a similar logic here.

Or use strictNullChecks option and return any in non-strict mode (!strictNullChecks && (widened.flags & TypeFlags.Nullable))

// @strictNullChecks: false
/** @type {() => undefined} */
function f1() {
    return undefined;
}
const a = f1()
>a : any
>f1() : undefined
>f1 : () => undefined

// @strictNullChecks: true
/** @type {() => undefined} */
function f1() {
    return undefined;
}
const a = f1()
>a : undefined
>f1() : undefined
>f1 : () => undefined

Does that make sense?

[sandersn]

Test changes look good. I have some questions about the implementation though. Also, I think we should hold this change for 4.4 in order to make it available to users to test for a long time.

• I looked at the similar code that you pointed out in isEmptyArrayLiteralType, and it only applies to strictNullChecks. Why don't you need the same choice between === implicitNeverType vs === undefinedWideningType in this fix?
• why neverType vs implicitNeverType, which is what isEmptyArrayLiteralType uses?

I thought it might be time to revisit the choice of having []: any[] in strict null checks in js instead of []: never[] like in TS, but decided that the additional annotations would still not be appropriate for even strict JS. I suspect that switching isEmptyArrayLiteralType to use the check introduced in this PR would get us that. Is that right?

[sandersn]

So..making both use the same check doesn't make []: never[] under strictnullchecks. Interesting, there must be an ad-hoc conversion I've forgotten about. This is a good change for strictnullchecks, since authors probably care about var x = null having the correct type in that case. We should do some more thinking and maybe usage analysis for the empty array case in the future.

[sandersn]

Update: looking closer at the baselines, the conversion must happen for initialisers, because in var x = [], []: never[] but x: any[].