Unexpected widening of template literal string type when the function's type is referenced by the constraint of a additional uninvolved type parameter

🔎 Search Terms

"Generic constraints", "Infer strict return type"

🕗 Version & Regression Information

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

⏯ Playground Link

No response

💻 Code

First example:

type Primitives = number | string | boolean | bigint | symbol | undefined | null | void;

declare function call<
  R extends Primitives,
  O extends { a: (...args: any[]) => R },
  Args extends { a: Parameters<O['a']> }
>(o: O, args: Args): ReturnType<O['a']>;

const check = call(
  {
    a(a: string) {
      return `${a}a`;
    }
  },
  { a: ['a'] }
)

Second example:

type Primitives = number | string | boolean | bigint | symbol | undefined | null | void;

declare function call<
  R extends Primitives,
  O extends { a: (...args: any[]) => R },
>(o: O, args: { a: Parameters<O['a']> }): ReturnType<O['a']>;

const check = call(
  {
    a(a: string) {
      return `${a}a`;
    }
  },
  { a: ['a'] }
)

🙁 Actual behavior

I'm trying to write a function that retrieves the function's strict return type (which is a property of an object) and takes a second argument as an object with the same properties, but with arguments for these functions.

There is a problem with how TypeScript infer the return types.

In the first example check will have string type. But in the second example check will have ${string}a type as expected.

I have noticed that problem occur when I try to write generic for args argument of call function.

This looks like a bug, since generic for args argument has no effect on other types.

🙂 Expected behavior

In both examples the return type must be ${string}a.

Additional information about the issue

No response

Inizia riproducendo le due dichiarazioni di chiamata generiche e verificando il tipo inferito di check in ciascun esempio. Esamina i percorsi di inferenza dei vincoli generici e del tipo restituito di TypeScript, quindi aggiungi un test di regressione che dimostri che il primo esempio conserva il tipo literal di template ${string}a, proprio come il secondo.