Index signature is assignable to weak type whose properties don't match the signature type

From https://stackoverflow.com/q/52368008 . Based on https://github.com/Microsoft/TypeScript/pull/16047#issue-122101801, it appears that @sandersn may have thought about the rule, but it still makes no sense to me and no rationale is stated.

TypeScript Version: master (394ee31a56c40033f31a3a8461ec267463033194)

Search Terms: weak type index signature

Code

interface Foo {
    a?: string;
}
interface Bar {
    [n: string]: number;
}
declare let b: Bar;
// No error; expected "Type 'Bar' has no properties in common with type 'Foo'."
let a: Foo = b;

Expected behavior: Error: “Type ‘Bar’ has no properties in common with type ‘Foo’.”

Actual behavior: No error.

Playground Link: link

Related Issues: Possibly #9900

[mattmccutchen]

I didn’t know a “Bug” could be “In Discussion”. 😄

For that matter, if we interpret an index signature as “there might exist a property of any name”, why do we ever allow a type with an index signature to be assignable to a type with an incompatible optional property, regardless of whether the target type is weak? Are there real-world cases in which the error would be undesirable? Example:

interface Foo {
    a: number;
    b?: string;
}
interface Bar {
    a: number
    [n: string]: number;
}
let b: Bar = {a: 42, b: 43};
let f: Foo = b;  // OK; expect error?

[sandersn]

Ah, I didn’t see the types. 😃 I have the weak type implementation so much in my head that I just looked at properties.

So it sounds like the correct check for index signatures is to make sure that the signature type is assignable to the union of the weak type’s property types.