A case of unsoundness in TypeScript

TypeScript provides a construct called a call signature to annotate a callable object with properties in JavaScript. For example, think of a function identity, i.e., a callable object, with a property whoAmI:

function identity(arg) {
  return arg;
}
identity.whoAmI = "I am Identity Man";

Note that the above callable construct requires two statements to construct itself. Now, let's use TypeScript's call signature feature to annotate it:

interface IIdentity {
  (arg: number) : number
  whoAmI: string
}

const i : IIdentity = (arg) => arg;
// GOOD: compilation error until the following line is added.
i.whoAmI = "I am Identity!";

So far, so good. However, the following code also type-checks without any compilation errors:

interface IIdentity {
  (arg: number) : number
  whoAmI: string
}

const i : IIdentity = (arg) => arg;
// BAD: the following line compiles even if the callable's construction isn't finished yet.
console.log(i.whoAmI.toLowerCase());
i.whoAmI = "I am Identity!";

The above code of course throws a runtime error: i.whoAmI is undefined.

I don't see a reason why TypeScript cannot ensure that any reference to the non-existent components of a half-constructed callable is illegal until the callable is fully constructed...except for performance reasons. Performance is also why TypeScript does not infer paramter types of a function automatically even though it lets you infer their types, individually, on-demand, through IDE tooling.

Link to the conversation thread that led to this post.