New rule: unsafe assignment / declaration / return / call

[danielnixon]

Prevent this:

type A = { val: string; };
type B = { val: string | number; };

const a: A = { val: "string" };
const b: B = a;

b.val = 3;

console.log(a.val.toUpperCase()); // throws

And this:

interface MutableValue<T> {
    value: T;
}

interface ImmutableValue<T> {
    readonly value: T;
}

let i: ImmutableValue<string> = { value: "hi" };
i.value = "Excellent, I can't change it"; // compile-time error

let m: MutableValue<string> = i;
m.value = "Oh dear, I can change it";

see microsoft/TypeScript#14150 and microsoft/TypeScript#13347

[danielnixon]

So, when comparing the types on either sides of the declaration (or assignment, or return, or call):

• Both sides readonly (safe because neither can be mutated)
• Right hand side is an object literal (safe because no reference can be retained to the right hand side) - TODO but what if the object literal sets a property to a value that we do retain a reference to
• Both sides mutable AND neither side is a type union AND both sides are exactly the same type (safe because mutating one can't break the type of the other)
• TODO: work out how to handle unions
• TODO: work out how to handle subtype relationship (argument is a subtype of param)

[danielnixon]

Initial version of rule landed: 87b978c