Function parameters are not inferable when defined via JSDoc using @type tag (with strict) about typescript

[Andarist]

The generated function has SignatureFlags.IsUntypedSignatureInJSFile assigned to it. So its min argument count gets computed as 0. Based on that calls without any arguments are allowed as the provided number of arguments (0 here) satisfies the min argument count.

Currently, this flag is not assigned to signatures coming from JS files when the function has either @param tag or when the function itself is typed using @type. For that reason, you end with the same problem when the function is contextually-typed using @satisfies:

/** @satisfies {(arg: string) => void} */
const func = function func(param) { };
func() // oops

Related(ish) case to the @satisfies can be found here

[fatcerberus]

@kungfooman That's because the parameter itself is, in fact, optional:

function func(/** @type {string} */ param) {}
/**
 * @typedef {typeof func} Func
 * @typedef {Func extends (...args: infer P) => any ? P : never} FuncParam
 */

func();  // not an error

Playground link

I don't know why it's treated as optional, but the inference result is correct.

[kungfooman]

Funny behaviour, and why does it work somewhat better in only one file: Playground

function func(/** @type {string} */ param) {}
/**
 * @typedef {typeof func} Func
 * @typedef {Func extends (...args: infer P) => any ? P : never} FuncParam
 */

Result: type FuncParam = [param?: string] (it shouldn't be optional)

[kungfooman]

I don't know why it's treated as optional, but the inference result is correct.

If we turn on strictNullChecks it's suddenly never again 😅

IMO it should only ever be considered optional if we use the Google Closure syntax:

function func(/** @type {string=} */ param) {}

(= after string)

[scottmcginness]

Thank you for the playground links! Reproduces the problem nicely.

In the non-optional cases above, the tooltip hover still thinks that func is a function with a non-optional (param: string) parameter. Which seems correct. Later still having param be optional seems weird to me too, but maybe that's how optionality works 🤷

In addition, both the infer and func() remain inconsistent with how @param works (which is how I expect, in fact):

/** @param {string} param */
function func(param) {}
func() // error

and FuncParam as above is [param: string]. Playground link