no-useless-predicate: detect useless type guard calls

[ajafff]

declare function isString(v: any): v is string;
declare function isNumber(v: any): v is number;
declare let value: number;

// this condition will probably always be false, otherwise you have some really messed up code
if (isString(value)) {
    value.charAt(0);
}

// typeguard is useless because `value` is already `number` or a subtype thereof
if (isNumber(value)) {
    value.toFixed(0);
}

This needs type relationship APIs to detect if the typeguard type is not assignable to the original type.

[ajafff]

Also make sure this works with this typeguards:

declare class Base {
    public isA(): this is A;
    public isB(): this is B;
}
declare class A extends Base {
    a: string;
}
declare class B extends Base {
    b: number;
}

declare var a: A;
a.isB(); // will probably always be false
a.isA(); // will always be true

[ajafff]

For posterity, this is how TypeScript handles impossible (empty) intersection types: microsoft/TypeScript#18438

This is relevant because type guards simply create an intersection type

[ajafff]

The always true case is actually pretty easy to detect: the resulting type is no intersection. Or if it was an intersection before, it's an intersection of the same length after narrowing.
And in the else branch the narrowed type is never. For negated conditions it's the other way around, of course.

[ajafff]

There's another thing to consider: typeguards narrow unions. So if it was a union type before and is no union after narrowing, it's not always true (var a below). That also applies if a nested property was a union before an is now no union or a union with less constituents (var b below)

declare var a: {prop: boolean} | {prop2: string};

declare function tg(v: any): v is {prop: boolean};

if (tg(a)) {
    a; // {prop: boolean}
}

declare var b: {prop: boolean | string};

if (tg(b)) {
    b; // {prop: boolean}
}

[ajafff]

The same logic as outlined above should also apply to instanceof narrowing.

class A {
  a = 1;
}
class B extends A {
  b = 1;
}
class C {
  c = 1;
}
class D {
  a = "incompatible";
}

declare var v: A;
if (v instanceof A) {
  // no error as this isn't guaranteed to be an instance of `A` at runtime
}
if (v instanceof B) {
  // no error, B is a subclass
}
if (v instanceof C) {
  // no error, v is `A & C` which have no incompatible properties
}
if (v instanceof D) {
  // error, `D['prop']` is not compatible to `A['prop']` and therefore results in `never`
}