Suggestion: Type guard generic types

Would it be good to have type guarding on generic types? Or was this decided against?

Example 1

class Parent {
    prop1: string;
}

class Child extends Parent {
    childProp: string;
}

var t: Parent = new Child();

if (t instanceof Child) {
    t.childProp; // no error
}

function myFunction<T extends Parent>(item: T) {
    if (item instanceof Child) {
        item.childProp; // error
    }
}

I realize this example could be rewritten without generics. It’s just an example 😃

Example 2

Here’s a scenario I came across when creating a wrapper class:

interface NedbItem {
    _id: string;
}

function isNedbItem(item: any): item is NedbItem {
    return item != null && typeof item._id === "string";
}

class DatabaseWrapper<T> {
    getItems() {
        const itemsFromDatabase: T[] = .....;

        itemsFromDatabase.forEach(i => this.stripNedbID(i));

        return itemsFromDatabase;
    }

    private stripNedbID(item: T) {
        if (isNedbItem(item))
        {
            delete item._id; // error, _id does not exist on T
        }
    }
}

Maybe a generic type with no constraint should be treated like an any type in this case? (Once type guards are fixed for any types – See #4432)

This suggestion is probably very low on the priority scale.

I couldn’t find this issue discussed elsewhere so sorry if it was.

[masaeedu]

It seems like it already sort-of works if I explicitly write a generic function that returns the type guard:

class Cat { meow() { console.log("meow") } }
class Dog { woof() { console.log("woof") } }

class N<T extends Cat | Dog> {
    data: T = null
    print() {
        const data = this.data

        // This is fine
        if (is(data, Dog)) {
            return data.woof()
        }

        // Unfortunately, this is not. Looks
        // like narrowing isn't working.
        // return data.meow()

        // However, you can work around the
        // problem with this:
        if (is(data, Cat)) {
            return data.meow()
        }
    }
}

function is<T, TClass>(x: T, c: new () => TClass): x is T & TClass {
    return x instanceof c
}

Unfortunately, it looks like narrowing of the union doesn’t work. If I add the explicit annotation const data: Cat | Dog the error goes away, so it looks like an unfortunate interaction between union narrowing and generics. In the meantime, we can just explicitly write if-clauses for each case instead of relying on narrowing.

[ziahamza]

There are still valid cases where this can be helpful, especially when generic type extends from a union type. E.g

class Cat {    }
class Dog {  }
class Node<T extends Cat | Dog> {
     data: T = null
     print() {
          if (this.data instanceof Dog) {
                // this.data now has the type Dog inside the block
          }
     }
} 

But the example doesnt seem to work today as typescript does not specialise the generic type even if it is a subset of the type it extends from