Contextual typing failure with discriminated type and partially overlapping type.

[yannack]

TypeScript Version: 2.3 +

Code

type MyType = 'meep'|'bidi';
type ThatType = 'moop'|'meep';

interface Foo {  
  isfoo: 'true';
  foo: MyType;
}
interface Bar {
  isfoo: 'false';
  foo: string;
}

let arr: Array<Foo|Bar>;

arr = [{foo: 'meep', isfoo: 'true'}, 
       {foo: 'moop', isfoo: 'false'}];

Expected behavior: This should compile. The discriminant isfoo should be enough to figure out that the first element of the array can only be a Foo and the second is a Bar.

Actual behavior:
ERROR(15,1): : Type '({ foo: string; isfoo: "true"; } | { foo: string; isfoo: "false"; })[]' is not assignable to type '(Foo | Bar)[]'.
Type '{ foo: string; isfoo: "true"; } | { foo: string; isfoo: "false"; }' is not assignable to type 'Foo | Bar'.
Type '{ foo: string; isfoo: "true"; }' is not assignable to type 'Foo | Bar'.
Type '{ foo: string; isfoo: "true"; }' is not assignable to type 'Foo'.
Types of property 'foo' are incompatible.
Type 'string' is not assignable to type 'MyType'.

However, if Foo's foo is declared as a string, then it compiles fine. If Bar's foo is declared as a ThatType, then it also compiles fine.

[yannack]

Hi, It's part of the description of the bug. If interface Bar is declared with its property 'foo' of type 'ThatType', then the compiler has no issues. So this works fine: type MyType = 'meep'|'bidi'; type ThatType = 'moop'|'meep'; interface Foo { isfoo: 'true'; foo: MyType; } interface Bar { isfoo: 'false'; foo: ThatType; } let arr: Array<Foo|Bar>; arr = [{foo: 'meep', isfoo: 'true'}, {foo: 'moop', isfoo: 'false'}]; But if ThatType = string; then the compile error comes back.

…

On 14 June 2017 at 03:15, devdoomari ***@***.***> wrote: just a small question, but how is 'ThatType' being used for? — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#16513 (comment)>, or mute the thread <https://github.com/notifications/unsubscribe-auth/AAa5RRAAJ8_8Km5IwA0GsLLdCyrktYQ7ks5sD4iTgaJpZM4N5WGr> .

[DanielRosenwasser]

The first symptom we're seeing is that {foo: 'meep', isfoo: 'true'} is not assignable to Foo.

What we think is happening is that when looking at the type of the foo property, we get the contextual type to decide whether to widen. We see that the contextual type is string | MyType which subtype-reduces to string. So the type of the foo property is widened to string, but at that point it's no longer compatible with Foo.

[chmln]

Similarly ran into this issue when typing responses from a database.

I'm aware that the current solution is to employ discriminated type unions with varying string values.
But it doesn't feel right to pollute my schemas and data with unnecessary fields.

interface T {
    _id: string
    revision: number
}

interface Error {
    _id: undefined
    error: string  
}

const getDoc = (s: string): T | Error => {
    if (Math.random() < 0.5) {
        const r: T = {
            _id: "123",
            revision: 1
        }
        return r
    }

    else {
        const e: Error = {
            error: "Not found"
        }
       // Error: property 'name' is missing in type { error: string }
        return e
    }    
}

const doc = (id: string) => {
    const d = getDoc(id)
    if (d._id === undefined) {
        console.log(d.error)
         // 'error' doesnt exist on type 'T'
    }

    else {
        console.log(d.revision)
        // Error: 'revision' doesnt exist on type 'Error'
    }
}

[sandersn]

Duplicate of #16457