Casting generics ignores --strictNullCheck

[0xShammah]

TypeScript Version: 2.1.5

Code
Minimal example that compiles just fine:

let x: Promise<string | undefined> = Promise.resolve(undefined);
let y: Promise<string> = x;

Small usage example in which I encountered the bug:

interface ITest {
    test(): Promise<string>;
}

class Test implements ITest{
    test(): Promise<string | undefined> {
        return Promise.resolve(undefined);
    }
}

var test = new Test();
test.test().then(console.log);

Expected behavior:
A compile error: the type Promise<string | undefined> does not match the type Promise<string>. I should not be able to cast undefined to string.

Actual behavior:
No errors.

[0xShammah]

This might be related to #10717 and https://github.com/Microsoft/TypeScript/wiki/FAQ#why-are-function-parameters-bivariant

[RyanCavanaugh]

@rbuckton does this get fixed by your recent change?

[rbuckton]

@RyanCavanaugh: if you mean #13487 then no, I do not believe it addresses this issue. In this case we are running afoul of parameter bivariance and how we handle structural typing. Though the checker sees that the type arguments are not assignable, we continue on to a structural check. During the structural check, we end up comparing the assignability of the onfulfilled callback for then, and we see that (value: string | undefined) => any is assignable to (value: string) => any. Unfortunately, we cannot fix this without branding Promise in some fashion or introducing some form of covariance or contravariance.

[whymarrh]

Is this an example of the same or a similar issue (in v2.1.5)? Would #10717/#13257 fix this?

class A {
    constructor(readonly message: string) {}
}

class B extends A {
    lastCharacter() {
        return this.message.substring(this.message.length - 1);
    }
}

const pick: (s: string) => Promise<B> = (s: string) =>
    Promise.resolve(new A(s));