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

Start by reproducing the two generic call declarations and checking the inferred type of check in each example. Investigate TypeScript's generic constraint and return-type inference paths, then add a regression test showing that the first example preserves the ${string}a template literal type just like the second.