Pedantic: deny mutable type generalization

[awerlogus]

Search Terms

type generalization
type expanding

Suggestion

Currently we have a vulnerability in type safety of mutable variables. You can generalize the type of some variable and change its value by passing there something not compatible with the old type. Examples:

const a: Array<number> = [1, 2]

const b: Array<number | string> = a

b.push('a is not array of numbers anymore')

const a = { data: 0 }

function b (param: { data: string | number }) {
  param.data = 'a is broken now'
}

b(a)

So I suggest adding a new compiler option under 'pedantic' label which will deny such type conversions:

const a: Array<number> = [1, 2]

// Error: type 'Array<number>' is not assignable to 'Array<number | string>'
const b: Array<number | string> = a

const a: Array<number> = [1, 2]

// OK: 'ReadonlyArray' won't let us mutate the state of 'a'
const b: ReadonlyArray<number | string> = a

const a = { foo: 0, bar: 'string' }

function b (param: { readonly foo: number | string, bar: string }) {
  param.bar = String(param.foo)
}

// OK
// property 'foo: number' is assignable to 'readonly foo: number | string'
// property 'bar: string' is assignable to 'bar: string'
b(a) 

function c (param: { readonly foo: number | string, bar: number | string }) {
  param.bar = String(param.foo)
}

// Error: property 'bar: string' is not assignable to 'bar: number | string'
c(a)

[DanielRosenwasser]

I'm pretty sure we have experimented with strictly applying variance checks for methods (and mutable properties), but lib.d.ts would no longer pass a type-check. @RyanCavanaugh might remember better.

[RyanCavanaugh]

The DOM wouldn't typecheck under strict method variance because of how the event listener methods on DOM objects are defined (flow types these as "Function" to get around this). This would really be the least of your problems though; there's a reason C++ has const as a type and member modifier -- without those primitives, every declaration file would really need two versions (if not more) of every type.

[awerlogus]

@RyanCavanaugh

The DOM wouldn't typecheck under strict method variance because of how the event listener methods on DOM objects are defined

Can you give an example of the code that will be broken after this change?