never rest type not assignable to complex rest type

[jack-williams]

TypeScript Version: 3.5.1

Search Terms:

Code

function foo<T extends any[]>() {
 const fn1: (x: string, ...rest: T) => unknown = (x, ..._) => x;
 const fn2: (...args: never) => unknown = fn1 // error
}

Expected behavior:

Assignment of fn1 to fn2 should pass.

Actual behavior:

Assignment of fn1 to fn2 should fails.

Playground Link: link

Related Issues:
#33457

[jack-williams]

The goal here would be to make all signatures structurally assignable to (...args: never) => unknown.

[RyanCavanaugh]

Anders Hejlsberg (@ahejlsberg) this seems reasonable to me. Thoughts?

[fatcerberus]

I did some experiments in the playground. This seems to break only when the rest parameter is generic. Use a concrete type and all is well:

• Playground link

Interestingly, [ string, ...T ] (where T is generic but extends any[]) isn't even legal and produces the error A rest element type must be an array type. This seems like a pretty big clue: the assignment of fn1 to fn2 may only be failing because it's unable to construct a tuple type for the parameter list of (x: string, ...rest: T) => unknown.

[jack-williams]

This is where it fails in checking:

const sourceCount = getParameterCount(source);
const sourceRestType = getNonArrayRestType(source);
const targetRestType = getNonArrayRestType(target);
if (sourceRestType && targetRestType && sourceCount !== targetCount) {
 // We're not able to relate misaligned complex rest parameters
 return Ternary.False;
}

[fatcerberus]

Jack Williams (@jack-williams) That doesn't seem to explain why it succeeds for the non-generic case. What is the exact definition of "complex" here?

[jack-williams]

What is the exact definition of "complex" here?

A rest type where you don't know the bounds, or whether it is unbounded---I would guess. I think never needs to be treated like any in that it is effectively known to be unbounded.

[jack-williams]

FWIW. I think the fix is basically:

function getNonArrayRestType(signature: Signature) {
 const restType = getEffectiveRestType(signature);
 return restType && !isArrayType(restType) && !isTypeAny(restType) && !isTypeNever(restType) ? restType : undefined;
}

+ isTypeNever.

[AnyhowStep]

Repro taken from TS' source code,

TypeScript/src/compiler/core.ts

Lines 1460 to 1464 in c447ebc

	/**
	* Safer version of `Function` which should not be called.
	* Every function should be assignable to this, but this should not be assignable to every function.
	*/
	export type AnyFunction = (...args: never[]) => void;

/**
 * Safer version of `Function` which should not be called.
 * Every function should be assignable to this, but this should not be assignable to every function.
 */
export type AnyFunction = (...args: never[]) => void;

function foo<T extends any[]>() {
 const fn1: (...rest: T) => void = (..._) => {};
 const fn2: AnyFunction = fn1 // error
}

Playground

Every function should be assignable to this

But not every function is assignable to it