Avoid listing missing properties on types with only call/construct signatures

[DanielRosenwasser]

Found with @RyanCavanaugh

interface Dog {
    barkable: true
}

declare function getRover(): Dog;

export let x: Dog = getRover;

Expected

Type '() => Dog' is not assignable to 'Dog'.(2741)
  input.ts(7, 21): Did you mean to call this expression?

Actual

Property 'barkable' is missing in type '() => Dog' but required in type 'Dog'.(2741)
  input.ts(2, 5): 'barkable' is declared here.
  input.ts(7, 21): Did you mean to call this expression?

[weswigham]

Hm, OK, but suppose

interface Dog {
    caller: {
        caller: {
            collar: boolean;
        };
    }
}

declare function getRover(): Dog;

export let x: Dog = getRover;

for which we issue

Type '() => Dog' is not assignable to type 'Dog'.
  The types of 'caller.caller' are incompatible between these types.
    Property 'collar' is missing in type 'Function' but required in type '{ collar: boolean; }'.(2322)
input.ts(4, 13): 'collar' is declared here.
input.ts(11, 21): Did you mean to call this expression?

what's the rule here? In the above example, I can't make a clear judgement call on which suggestion is more relevant.

[DanielRosenwasser]

If you are in the off case where you have a name that isn't a string, a length that isn't a number, or any property named caller, I'm sure you'll figure it out on your own.

[RyanCavanaugh]

When the return type of a function is an identity match for the target type, it seems extremely unlikely that "You forgot to call it?" is not the best possible error message. It requires a lot of construction to make something where a function and its return type are both plausible matches for the target.

I would be curious to find out how often a function is ever an intentional source for a target with zero signatures that isn't a top-ish type. Even assigning a function to something nominally uncontroversial like { name: string; age?; number } smells like a bug, and people have complained to that effect.

[weswigham]

I would be curious to find out how often a function is ever an intentional source for a target with zero signatures that isn't a top-ish type

I've seen assignments to {length: number} in the wild.