New no-invalid-void rule

[timocov]

Rule Suggestion

We've such rule internally and I believe it might be useful for someone else and we can provide such rule in TSLint.

Is your rule for a general problem or is it specific to your development style? For a general problem.

What does your suggested rule do?

Restrict invalid usage of void type. For example, as property type or in type enumerations. I believe the void type should be used as return type only and be alone (without any kind of intersection types - see examples below).

List several examples where your rule could be used

function func(): void {}

type NormalType = () => void;

interface Interface {
    lambda: () => void;
    voidProp: void;
              ~~~~ [void as non-return type is forbidden]
}

class ClassName {
    private readonly propName: void;
                               ~~~~ [void as non-return type is forbidden]
}

let letVoid: void;
             ~~~~ [void as non-return type is forbidden]

type VoidType = void;
                ~~~~ [void as non-return type is forbidden]

class OtherClassName {
    private propName: VoidType;
}

type UnionType = string | number;
type UnionType2 = string | number | void;
                                    ~~~~ [void as non-return type is forbidden]

type UnionType3 = string | (number & any | (string | void));
                                                     ~~~~ [void as non-return type is forbidden]

type IntersectionType = string & number & void;
                                          ~~~~ [void as non-return type is forbidden]