instanceof narrowing should preserve generic types from super to child type

## Search Terms * instanceof generic * narrow instanceof ## Suggestion The following code has a rather unexpected behavior today: ```ts class Parent<T> { x: T; } class Child<S> extends Parent<S> { y: S; } function example(obj: Parent<number>) { if (obj instanceof Child) { const child = obj; } } ``` The narrowed type that `child` gets is `Child<any>`. I'm requesting that the type instead gets narrowed to `Child<number>`, which is what I originally assumed would happen. My proposal is, in general, to infer the type arguments to the narrowed-to class type whenever they can be determined from the original type. ## Precise Behavior Consider the following code today: ```ts const x: P = ...; if (x instanceof C) { x; } ``` Today, if `C` is a generic class, `x` gets the narrowed type `C<any, any, any, ...>`; otherwise it just gets the type `C`. My proposal is to consider the following piece of code, and use it to inform Imagine that `C` has a no-argument constructor. Then the following piece of code is valid today: ```ts function onlyP(c: P) { ... } onlyC(new C()); ``` in order to make it valid, the compiler infers type arguments for `C` that make it into a subtype of `P`. My proposal is to use the same strategy to infer the type arguments for `C` in an `instanceof` narrowing. Consider the following examples today, and their corresponding `instanceof` narrowings: ```ts function ex1(x: Parent<string>) { } ex1(new Child()); // inferred arguments: <string> function ex2(x: Parent<number | string>) { } ex2(new Child()); // inferred arguments: <number | string> function ex3(x: Parent<number> | string) { } ex3(new Child()); // inferred arguments: <number> function ex4(x: Parent<number> | Parent<string>) { } ex4(new Child()); // inferred arguments: Child<number | string> // Note: the above errors, because it Child<number|string> actually fails to be a subtype of // Parent<number> | Parent<string>. // We can either choose to infer Child<any> in this ca…