Generic function types cannot merge using union types

[falsandtru]

type f = {
  (): number;
} | {
  (): string;
}

var f: f;
f(); // valid

type g = {
  <T>(): number;
} | {
  <T>(): string;
}

var g: g;
g(); // error

type f = {
  (): any;
  (v: any): any;
} | {
  (v?: any): any;
}

var f: f;
f(); // valid

type g = {
  <T>(): any;
  <T>(v: any): any;
} | {
  <T>(v?: any): any;
}

var g: g;
g(); // error

[weswigham]

This is by design, apparently. We have this comment in the related code:

        // The signatures of a union type are those signatures that are present in each of the constituent types.
        // Generic signatures must match exactly, but non-generic signatures are allowed to have extra optional
        // parameters and may differ in return types. When signatures differ in return types, the resulting return
        // type is the union of the constituent return types.
        function getUnionSignatures(types: Type[], kind: SignatureKind): Signature[] {

However, I'm not sure if we have good spec/test coverage for this, and I think attempting quick info on the function call in this example seems to freeze the language service.

Though this behavior is currently by design, we could possibly? do better here.

[falsandtru]

Please change this issue title if you need.

[RyanCavanaugh]

This is no longer an error