`NoInfer` changes behavior for type matching on spread

[upsuper]

🔎 Search Terms

NoInfer spread

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about NoInfer

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=6.0.3#code/GYVwdgxgLglg9mABAQwE6oIwApkC5EDaYIAtgEYCmqANIgHQMBycAkmMFQDwEC6AfDwCUiAN4BfAFBpMWAhiEBuCRNCRYCFOgBMOfEVKUa9BryGjJ0nXMXLV0eElXY8iLAA98xclVoM6cfGY2DlRufmEAXj5EADc4GAATYXEVcGw3RCjzQSVUtQdEVR0Xd08DH2N-PTMsuMTkySL3TOjxHIkgA

💻 Code

function arr1(a: [number, ...NoInfer<[]>]) {}
arr1([1]);

function arr2(a: [number, ...[]]) {}
arr2([1]);

function fun1(a: (x: number, ...o: NoInfer<[]>) => void) {}
fun1(x => {});

function fun2(a: (x: number, ...o: []) => void) {}
fun2(x => {});

🙁 Actual behavior

The two function calls to functions with NoInfer triggers type error, while the other two to equivalent function without NoInfer don't.

🙂 Expected behavior

This code should work without type error.

Additional information about the issue

No response

[RyanCavanaugh]

Using NoInfer<> around a type expression with no type parameters doesn't make any sense. Don't do this.

[upsuper]

That is just a simplification. Wrapping NoInfer<> around a type parameter has exactly the same problem. The code where I hit this issue is closer to

function func1<A extends unknown[]>(
  args: A,
  fn: (x: number, ...args: NoInfer<A>) => void,
) {}

func1([] as const, x => {});

which also triggers this error:

Argument of type '(x: number) => void' is not assignable to parameter of type '(x: number, ...args: NoInfer<[]>) => void'.
  Types of parameters 'x' and 'x' are incompatible.
    Type '[x: number, ...args: NoInfer<[]>]' is not assignable to type '[x: number]'.
      Source has 2 element(s) but target allows only 1.

In the code above, removing NoInfer doesn't change what A is inferred to, but eliminates the type error on the invoke.

[RyanCavanaugh]

Why do you have NoInfer there either? e.g. what's a sample call that it fixes?

[upsuper]

The reason is to allow the function to have fewer params than A.

As an example, if we have

function func1<A extends unknown[]>(
  args: A,
  fn: (...args: NoInfer<A>) => void,
) {}

function foo(u: number, v: number) {
  func1([u, v] as const, () => {});
}

without the NoInfer, it would report

Argument of type '[number, number]' is not assignable to parameter of type '[]'.
  Source has 2 element(s) but target allows only 0.

on the first argument which is undesirable.

Theoretically, all of

• () => void,
• (x: number) => void, and
• (x: number, y: number) => void

should be assignable to (x: number, y: number) => void as well as (...args: [x: number, y: number]) => void, but with NoInfer, only the first and the last are accepted.