fix(50858): parameters in function signatures inferred from default generic types sometimes not assigned instantiated types

src/compiler/checker.ts

@@ -27532,12 +27532,31 @@ namespace ts {
  function instantiateContextualType(contextualType: Type | undefined, node: Node, contextFlags: ContextFlags | undefined): Type | undefined {
  if (contextualType && maybeTypeOfKind(contextualType, TypeFlags.Instantiable)) {
  const inferenceContext = getInferenceContext(node);
- // If no inferences have been made, nothing is gained from instantiating as type parameters
- // would just be replaced with their defaults similar to the apparent type.
- if (inferenceContext && contextFlags! & ContextFlags.Signature && some(inferenceContext.inferences, hasInferenceCandidates)) {
- // For contextual signatures we incorporate all inferences made so far, e.g. from return
- // types as well as arguments to the left in a function call.
- return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+ if (inferenceContext && contextFlags! & ContextFlags.Signature) {
+ // If no inferences have been made, nothing is gained from instantiating as type parameters
+ // would just be replaced with their defaults similar to the apparent type.
+ if (some(inferenceContext.inferences, hasInferenceCandidates)) {
+ // For contextual signatures we incorporate all inferences made so far, e.g. from return
+ // types as well as arguments to the left in a function call.
+ return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+ }
+
+ const apparentType = mapType(contextualType, getApparentType, /*noReductions*/ true);
+
+ // If the apparent type is any, we cannot lose any information by instantiating,
+ // so we might as well try and possibly get a useful type
+ if (apparentType === anyType) {
+ return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+ }
+ else if((apparentType.flags & TypeFlags.Union)) {
+ const signatureList = getContextualSignatureListFromApparentTypes((apparentType as UnionType).types, node as FunctionExpression | ArrowFunction | MethodDeclaration);
+
+ if (!signatureList) {
+ // At this point, the signature type is guaranteed to eventually collapse into any
+ // because it is a union of incompatible function signatures
+ return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper);
+ }
+ }
  }
  if (inferenceContext?.returnMapper) {
  // For other purposes (e.g. determining whether to produce literal types) we only
@@ -27953,8 +27972,17 @@ namespace ts {
  if (!(type.flags & TypeFlags.Union)) {
  return getContextualCallSignature(type, node);
  }
- let signatureList: Signature[] | undefined;
  const types = (type as UnionType).types;
+ const signatureList = getContextualSignatureListFromApparentTypes(types, node);
+
+ // Result is union of signatures collected (return type is union of return types of this signature set)
+ if (signatureList) {
+ return signatureList.length === 1 ? signatureList[0] : createUnionSignature(signatureList[0], signatureList);
+ }
+ }
+
+ function getContextualSignatureListFromApparentTypes(types: Type[], node: FunctionExpression | ArrowFunction | MethodDeclaration): Signature[] | undefined {
+ let signatureList: Signature[] | undefined;
  for (const current of types) {
  const signature = getContextualCallSignature(current, node);
  if (signature) {
@@ -27972,10 +28000,7 @@ namespace ts {
  }
  }
  }
- // Result is union of signatures collected (return type is union of return types of this signature set)
- if (signatureList) {
- return signatureList.length === 1 ? signatureList[0] : createUnionSignature(signatureList[0], signatureList);
- }
+ return signatureList;
  }
 
  function checkSpreadExpression(node: SpreadElement, checkMode?: CheckMode): Type {

tests/baselines/reference/genericInferenceDefaultTypeParameter.js

@@ -0,0 +1,17 @@
+//// [genericInferenceDefaultTypeParameter.ts]
+type Type = {
+ a: (e: string) => void,
+ b: (e: number) => void,
+}
+
+function f1<T extends keyof Type = 'a'>(props: Type[T]): any {
+ return null
+}
+
+f1((event) => { })
+
+//// [genericInferenceDefaultTypeParameter.js]
+function f1(props) {
+ return null;
+}
+f1(function (event) { });

tests/baselines/reference/genericInferenceDefaultTypeParameter.symbols

@@ -0,0 +1,28 @@
+=== tests/cases/compiler/genericInferenceDefaultTypeParameter.ts ===
+type Type = {
+>Type : Symbol(Type, Decl(genericInferenceDefaultTypeParameter.ts, 0, 0))
+
+ a: (e: string) => void,
+>a : Symbol(a, Decl(genericInferenceDefaultTypeParameter.ts, 0, 13))
+>e : Symbol(e, Decl(genericInferenceDefaultTypeParameter.ts, 1, 8))
+
+ b: (e: number) => void,
+>b : Symbol(b, Decl(genericInferenceDefaultTypeParameter.ts, 1, 27))
+>e : Symbol(e, Decl(genericInferenceDefaultTypeParameter.ts, 2, 8))
+}
+
+function f1<T extends keyof Type = 'a'>(props: Type[T]): any {
+>f1 : Symbol(f1, Decl(genericInferenceDefaultTypeParameter.ts, 3, 1))
+>T : Symbol(T, Decl(genericInferenceDefaultTypeParameter.ts, 5, 12))
+>Type : Symbol(Type, Decl(genericInferenceDefaultTypeParameter.ts, 0, 0))
+>props : Symbol(props, Decl(genericInferenceDefaultTypeParameter.ts, 5, 40))
+>Type : Symbol(Type, Decl(genericInferenceDefaultTypeParameter.ts, 0, 0))
+>T : Symbol(T, Decl(genericInferenceDefaultTypeParameter.ts, 5, 12))
+
+ return null
+}
+
+f1((event) => { })
+>f1 : Symbol(f1, Decl(genericInferenceDefaultTypeParameter.ts, 3, 1))
+>event : Symbol(event, Decl(genericInferenceDefaultTypeParameter.ts, 9, 4))
+

tests/baselines/reference/genericInferenceDefaultTypeParameter.types

@@ -0,0 +1,27 @@
+=== tests/cases/compiler/genericInferenceDefaultTypeParameter.ts ===
+type Type = {
+>Type : { a: (e: string) => void; b: (e: number) => void; }
+
+ a: (e: string) => void,
+>a : (e: string) => void
+>e : string
+
+ b: (e: number) => void,
+>b : (e: number) => void
+>e : number
+}
+
+function f1<T extends keyof Type = 'a'>(props: Type[T]): any {
+>f1 : <T extends keyof Type = "a">(props: Type[T]) => any
+>props : Type[T]
+
+ return null
+>null : null
+}
+
+f1((event) => { })
+>f1((event) => { }) : any
+>f1 : <T extends keyof Type = "a">(props: Type[T]) => any
+>(event) => { } : (event: string) => void
+>event : string
+

tests/baselines/reference/genericInferenceDefaultTypeParameterJsxReact.js

@@ -0,0 +1,27 @@
+//// [genericInferenceDefaultTypeParameterJsxReact.tsx]
+/// <reference path="/.lib/react16.d.ts" />
+import React, { ComponentPropsWithRef, ElementType, ReactNode } from 'react'
+
+type ButtonBaseProps<T extends ElementType> =
+ ComponentPropsWithRef<T> & {
+ children?: ReactNode
+}
+
+function Component<T extends ElementType = 'span'>(props: ButtonBaseProps<T>) {
+ return <></>
+}
+
+const v1 = <Component onClick={e => e.preventDefault()} />
+
+//// [genericInferenceDefaultTypeParameterJsxReact.js]
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+ return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+/// <reference path="react16.d.ts" />
+var react_1 = __importDefault(require("react"));
+function Component(props) {
+ return react_1["default"].createElement(react_1["default"].Fragment, null);
+}
+var v1 = react_1["default"].createElement(Component, { onClick: function (e) { return e.preventDefault(); } });

tests/baselines/reference/genericInferenceDefaultTypeParameterJsxReact.symbols

@@ -0,0 +1,42 @@
+=== tests/cases/compiler/genericInferenceDefaultTypeParameterJsxReact.tsx ===
+/// <reference path="react16.d.ts" />
+import React, { ComponentPropsWithRef, ElementType, ReactNode } from 'react'
+>React : Symbol(React, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 6))
+>ComponentPropsWithRef : Symbol(ComponentPropsWithRef, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 15))
+>ElementType : Symbol(ElementType, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 38))
+>ReactNode : Symbol(ReactNode, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 51))
+
+type ButtonBaseProps<T extends ElementType> =
+>ButtonBaseProps : Symbol(ButtonBaseProps, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 76))
+>T : Symbol(T, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 3, 21))
+>ElementType : Symbol(ElementType, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 38))
+
+ ComponentPropsWithRef<T> & {
+>ComponentPropsWithRef : Symbol(ComponentPropsWithRef, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 15))
+>T : Symbol(T, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 3, 21))
+
+ children?: ReactNode
+>children : Symbol(children, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 4, 31))
+>ReactNode : Symbol(ReactNode, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 51))
+}
+
+function Component<T extends ElementType = 'span'>(props: ButtonBaseProps<T>) {
+>Component : Symbol(Component, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 6, 1))
+>T : Symbol(T, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 8, 19))
+>ElementType : Symbol(ElementType, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 38))
+>props : Symbol(props, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 8, 51))
+>ButtonBaseProps : Symbol(ButtonBaseProps, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 1, 76))
+>T : Symbol(T, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 8, 19))
+
+ return <></>
+}
+
+const v1 = <Component onClick={e => e.preventDefault()} />
+>v1 : Symbol(v1, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 12, 5))
+>Component : Symbol(Component, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 6, 1))
+>onClick : Symbol(onClick, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 12, 21))
+>e : Symbol(e, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 12, 31))
+>e.preventDefault : Symbol(React.SyntheticEvent.preventDefault, Decl(react16.d.ts, 642, 31))
+>e : Symbol(e, Decl(genericInferenceDefaultTypeParameterJsxReact.tsx, 12, 31))
+>preventDefault : Symbol(React.SyntheticEvent.preventDefault, Decl(react16.d.ts, 642, 31))
+

tests/baselines/reference/genericInferenceDefaultTypeParameterJsxReact.types

@@ -0,0 +1,36 @@
+=== tests/cases/compiler/genericInferenceDefaultTypeParameterJsxReact.tsx ===
+/// <reference path="react16.d.ts" />
+import React, { ComponentPropsWithRef, ElementType, ReactNode } from 'react'
+>React : typeof React
+>ComponentPropsWithRef : any
+>ElementType : any
+>ReactNode : any
+
+type ButtonBaseProps<T extends ElementType> =
+>ButtonBaseProps : ButtonBaseProps<T>
+
+ ComponentPropsWithRef<T> & {
+ children?: ReactNode
+>children : React.ReactNode
+}
+
+function Component<T extends ElementType = 'span'>(props: ButtonBaseProps<T>) {
+>Component : <T extends React.ElementType<any> = "span">(props: ButtonBaseProps<T>) => JSX.Element
+>props : ButtonBaseProps<T>
+
+ return <></>
+><></> : JSX.Element
+}
+
+const v1 = <Component onClick={e => e.preventDefault()} />
+>v1 : JSX.Element
+><Component onClick={e => e.preventDefault()} /> : JSX.Element
+>Component : <T extends React.ElementType<any> = "span">(props: ButtonBaseProps<T>) => JSX.Element
+>onClick : (e: React.MouseEvent<HTMLSpanElement>) => void
+>e => e.preventDefault() : (e: React.MouseEvent<HTMLSpanElement>) => void
+>e : React.MouseEvent<HTMLSpanElement>
+>e.preventDefault() : void
+>e.preventDefault : () => void
+>e : React.MouseEvent<HTMLSpanElement>
+>preventDefault : () => void
+

tests/cases/compiler/genericInferenceDefaultTypeParameter.ts

@@ -0,0 +1,12 @@
+// @noImplicitAny: true
+
+type Type = {
+ a: (e: string) => void,
+ b: (e: number) => void,
+}
+
+function f1<T extends keyof Type = 'a'>(props: Type[T]): any {
+ return null
+}
+
+f1((event) => { })

tests/cases/compiler/genericInferenceDefaultTypeParameterJsxReact.tsx

@@ -0,0 +1,17 @@
+// @noImplicitAny: true
+// @esModuleInterop: true
+// @jsx: react
+
+/// <reference path="/.lib/react16.d.ts" />
+import React, { ComponentPropsWithRef, ElementType, ReactNode } from 'react'
+
+type ButtonBaseProps<T extends ElementType> =
+ ComponentPropsWithRef<T> & {
+ children?: ReactNode
+}
+
+function Component<T extends ElementType = 'span'>(props: ButtonBaseProps<T>) {
+ return <></>
+}
+
+const v1 = <Component onClick={e => e.preventDefault()} />