Nested generic calls don't inherit outer inferences when their return types are intersections containing functions

🔎 Search Terms

generic call inference intersection return type

🕗 Version & Regression Information

• This is the behavior in every version I tried

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=5.6.0-dev.20240611#code/JYOwLgpgTgZghgYwgAgMIHsQ2AcwDwAqAfMgN4CwAUMsgppAB5gBcyBA3FTaAG7oDWEVhWo1kACgasCASlZ9gAE06iaEBhAStJ0mcgC8JBcq7IAvirNUqizQBs4UFDACuIBGGCZaTuJEJE4nRYuKwYIfjEcsjGKjb2js5uHl4gyAC2AJ4AkiB8ggBCUAIQIAHiwMLI6praUmx6hjHoSubRIjQ6DfItJpRmyABkyGCZAA4Q6DDIwHGUCL6Q4h209OosZKtuGwDM5gA0prwlrFm5+RBFJSDLpmoaWhIMjSQrYsgMd2IA9N-IAHoAfi+NAYADo6NswWB0AAxYAaRTiABMMhU7zMh1EZhkWJxc1sCAcTmQrncnm8ZzyJXKlU2NUeXVkBiMvTawlMTOisVMDLquhZzSUljmCwgfggt1EwUYG1IW3ArD2mKO1MEpxyaslb2qDzqLzIII+Rt+AOBqjE4Mh4GhcIRECRqPRYhV2NxVHxVCAA

💻 Code

interface Config<T> {
  context: T;
  invoke: {
    (x: T): void;
    exec: (x: T) => void;
  };
}

declare function create<T>(config: Config<T>): void;

declare function myInvokeBroken<T>(i: { exec: (x: T) => void }): {
  (x: T): void;
} & typeof i;

create({
  context: { count: 3 },
  invoke: myInvokeBroken({
    exec: (x) => {
      x
      // ^?
      x.count.toFixed(2);
    },
  }),
});

declare function myInvoke<T>(i: { exec: (x: T) => void }): {
  (x: T): void;
  exec: (x: T) => void;
};

create({
  context: { count: 3 },
  invoke: myInvoke({
    exec: (x) => {
      x
      // ^?
      x.count.toFixed(2);
    },
  }),
});

🙁 Actual behavior

x doesn't get contextually typed based on the outer inferences in the myInvokeBroken example

🙂 Expected behavior

I would expect myInvokeBroken and myInvoke to work here in the same way. Their return types are the same. It's only that myInvokeBroken is using an intersection in its return type while myInvoke isn't

Additional information about the issue

No response

Commencez par le repro lié dans TypeScript Playground et comparez l’inférence pour les deux appels génériques, en vous concentrant sur le type de retour d’intersection dans myInvokeBroken par rapport au type de retour explicite d’objet appelable dans myInvoke. Suivez le chemin du vérificateur de types qui fournit des types contextuels au callback exec imbriqué. C’est terminé lorsque les deux exemples typent contextuellement x comme { count: number } et que x.count.toFixed(2) est accepté, avec un test de régression couvrant la différence.