Type parameter constrained to union cannot be exhaustively narrowed to 'never'

TypeScript Version: 2.1.1 (http://www.typescriptlang.org/play/index.html)

Code

type Type = "a" | "b"

function isA(a: any): a is "a" {
    return a === "a"
}

function isB(a: any): a is "b" {
    return a === "b"
}

function assertNever(arg: never) {
    throw new Error("This should never be called")
}

function handleAction<T extends Type>(type: T) {
    if (isA(type)) {
        return type
    } else if (isB(type)) {
        return type
    } else {
        assertNever(type)
    }
}

Expected behavior: No compilation error

Actual behavior: Argument of type ‘T’ is not assignable to type ‘never’

[OliverJAsh]

I have a problem which I think is related to this.

{
    type FooOrBar = "foo" | "bar"

    let x: FooOrBar
    (() => { // Error: Not all code paths return a value.
        if (x === 'foo') {
            x
            return 1
        } else if (x === 'bar') {
            x
            return 2;
        }
    })
}

TS should be smart enough to know I have exhausted the union here.

Is this related?

[arxanas]

I believe this is the same issue:

type Foo = "bar" | "baz";

function okay(foo: Foo): number {
    switch (foo) {
        case "bar":
            return 1;
        case "baz":
            return 2;
    }
}

// Function lacks ending return statement and return type does not include 'undefined'.
function illegal<T extends Foo>(foo: T): number {
    switch (foo) {
        case "bar":
            return 1;
        case "baz":
            return 2;
    }
}

This is useful in practice. My actual use-case involves a type projection like function foo<T extends Id>(id: T, assocatedData: AssociatedData[T]>), like this:

const data = {
  "foo": {},
  "bar": {},
};

type AssociatedData = {
    "foo": {
        name: string,
    },
    "bar": {
        id: number,
    },
};

type Id = keyof typeof data;

function fancy<T extends Id>(id: T, data: AssociatedData[T]): number {
    // Not detected as exhaustive.
    switch (id) {
        case "foo":
            return 1;
        case "bar":
            return 2;
    }
}

(NB: the type projection does not refine types exactly how I would like here, but that’s a separate issue.)