Sub-typing issue when referencing a parent entity

[ClementNerma]

TypeScript Version: 3.4.0-dev.201xxxxx

// Get the 'value' from 'obj' and return its approximation
function approximate(obj: A): string {
  return obj.value.toFixed(2);
}

interface A {
  value: number;
}

// In TypeScript, 'B' is (wrongly) considered as a sub-type of 'A'
//  because 'number | string' is a sub-type of 'number'
interface B {
  value: number | string;
}

// Declare an 'A' entity
let a: A = { value: 2 };

// Declare a 'B' one with 'a''s content
let b: B = a;

// Use sub-typing overlapping to change 'a''s 'value'
b.value = 'Hello world!';

// Do the approximation
// This code is perfectly valid and compiles without any error
//  but will fail at runtime because of a type error ('.toFixed' is not a function)
// Even with strict compilation rules
// (noImplicitAny, strictNullChecks, strictFunctionTypes, strictPropertyInitialization, noImplicitThis, noImplicitReturns)
approximate(a);

Expected behavior: Do not compile because b shouldn't be able to be a reference to a. Indeed, B shouldn't be considered as a sub-type of A because number | string does not strictly overlaps number

Actual behavior: Code compiles, and fails at runtime.

Playground Link: https://bit.ly/2U2Cpmz

[DanielRosenwasser]

In TypeScript, 'B' is (wrongly) considered as a sub-type of 'A'

It's the opposite, but I know what you mean. This is a duplicate of #8474.

[DanielRosenwasser]

Actually, it's not quite a duplicate - but it's just that we've made an assumption that mutable properties should be related in a covariant, rather than invariant, manner with respect to their containing types. I don't know if we could realistically fix this.

[ClementNerma]

In TypeScript, 'B' is (wrongly) considered as a sub-type of 'A'

Yes sorry, that's what I meant ^^

Actually, it's not quite a duplicate - but it's just that we've made an assumption that mutable properties should be related in a covariant, rather than invariant, manner with respect to their containing types. I don't know if we could realistically fix this.

That's a rare scenario for sure, so this problem shouldn't come in many scripts. I don't know how this is implemented in the compiler, so I let you judge this by yourself :)

[RyanCavanaugh]

Our type system is covariant by default and writing through a supertype alias is the major hole created by that. It's definitely a trade-off.

[typescript-bot]

This issue has been marked 'Working as Intended' and has seen no recent activity. It has been automatically closed for house-keeping purposes.