union with any shows as union in signature quickinfo but any in parameter quickinfo

[sandersn]

Repro based on the one by @mackuba

// @filename: jsdocLowercaseObjectQuickInfo.js **
 * @param {object | null} o
 */
function create(o) {}

create/*1*/(undefined);

Compile with noImplicitAny: false and checkJs: true

Expected:
Quickinfo at /*1*/ is function create(o: any): void

Actual:
function create(o: object | null): void

Note:

• Signature help is correct.
• Parameter quickinfo is correct.

[fatcerberus]

Expected and Actual are swapped, I think?

[sandersn]

No, it's the right way round. object becomes any when noImplicitAny: false, and signature quickinfo should reflect that.

[Andarist]

So this runs into an existing weird situation with reusing existing type declaration. It's not even unique to JSDoc types.

type /*1*/O = {
    /*2*/foo: any | string
}

At marker 1 we can see:

type O = {
    foo: any | string;
}

but at marker 2 we can see:

(property) foo: any

Note that declaration emit preserves any | string here even in 5.4.

The reason why the type for @param gets printed as any is that it's the computed symbol's type that gets printed. When we hover over the function's symbol we end up serializing that symbol using serializeTypeForDeclaration (called by symbolToParameterDeclaration) and that prefers reusing the existing type node.

It's enough to wrap the type in this original repro into an object to get consistent non-reduced results:

/**
 * @param {{prop: object | null}} o
 */
function create2(o) {}

create2/*1*/(undefined);

With the above, { prop: object | null; } gets printed consistently. But that consistent result is misleading since the user won't easily notice that it's an any in disguise.

[fatcerberus]

@sandersn In that case, it’s not true that create(undefined) “should error”. That’s why I asked. 😉

[sandersn]

The comment was left over from the original repro, because the original author wanted object | null to mean object, even with noImplicitAny: false.