[new-rule] Added new invalid-void rule

src/configs/all.ts

@@ -163,6 +163,7 @@ export const rules = {
     "cyclomatic-complexity": true,
     eofline: true,
     indent: { options: ["spaces"] },
+    "invalid-void": true,
     "linebreak-style": { options: "LF" },
     "max-classes-per-file": { options: 1 },
     "max-file-line-count": { options: 1000 },

src/language/rule/abstractRule.ts

@@ -67,11 +67,13 @@ export abstract class AbstractRule implements IRule {
     ): RuleFailure[];
     protected applyWithFunction<T, U>(
         sourceFile: ts.SourceFile,
-        walkFn: (ctx: WalkContext<T | void>, programOrChecker?: U) => void,
+        walkFn: (ctx: WalkContext<T> | WalkContext, programOrChecker?: U) => void,
         options?: T,
         programOrChecker?: U,
     ): RuleFailure[] {
-        const ctx = new WalkContext(sourceFile, this.ruleName, options);
+        const ctx = new WalkContext(sourceFile, this.ruleName, options) as (
+            | WalkContext<T>
+            | WalkContext);
         walkFn(ctx, programOrChecker);
         return ctx.failures;
     }

src/language/walker/walkContext.ts

@@ -19,7 +19,7 @@ import * as ts from "typescript";
 
 import { Fix, RuleFailure } from "../rule/rule";
 
-export class WalkContext<T = void> {
+export class WalkContext<T = {}> {
     public readonly failures: RuleFailure[] = [];
 
     constructor(

src/language/walker/walker.ts

@@ -27,7 +27,7 @@ export interface IWalker {
     getFailures(): RuleFailure[];
 }
 
-export abstract class AbstractWalker<T = void> extends WalkContext<T> implements IWalker {
+export abstract class AbstractWalker<T = {}> extends WalkContext<T> implements IWalker {
     public abstract walk(sourceFile: ts.SourceFile): void;
 
     public getSourceFile() {

src/rules/deprecationRule.ts

@@ -58,7 +58,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/importSpacingRule.ts

@@ -45,7 +45,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     public static NO_LINE_BREAKS = "Line breaks are not allowed in import declaration";
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-        return this.applyWithWalker(new Walker(sourceFile, this.ruleName, undefined));
+        return this.applyWithWalker(new Walker(sourceFile, this.ruleName, {}));
     }
 }
 

src/rules/invalidVoidRule.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as ts from "typescript";
+
+import * as Lint from "../index";
+
+export class Rule extends Lint.Rules.AbstractRule {
+    /* tslint:disable:object-literal-sort-keys */
+    public static metadata: Lint.IRuleMetadata = {
+        ruleName: "invalid-void",
+        description: Lint.Utils.dedent`
+            Disallows usage of \`void\` type outside of return type.
+            If \`void\` is used as return type, it shouldn't be a part of intersection/union type.`,
+        rationale: Lint.Utils.dedent`
+            The \`void\` type means "nothing" or that a function does not return any value,
+            in contra with implicit \`undefined\` type which means that a function returns a value \`undefined\`.
+            So "nothing" cannot be mixed with any other types.
+            If you need this - use \`undefined\` type instead.`,
+        hasFix: false,
+        optionsDescription: "Not configurable.",
+        options: null,
+        optionExamples: [true],
+        type: "maintainability",
+        typescriptOnly: true,
+    };
+    /* tslint:enable:object-literal-sort-keys */
+
+    public static FAILURE_STRING = "void is not a valid type other than return types";
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithFunction(sourceFile, walk);
+    }
+}
+
+const failedKinds = new Set([
+    ts.SyntaxKind.PropertySignature,
+    ts.SyntaxKind.PropertyDeclaration,
+
+    ts.SyntaxKind.VariableDeclaration,
+    ts.SyntaxKind.TypeAliasDeclaration,
+
+    ts.SyntaxKind.IntersectionType,
+    ts.SyntaxKind.UnionType,
+
+    ts.SyntaxKind.Parameter,
+    ts.SyntaxKind.TypeParameter,
+
+    ts.SyntaxKind.AsExpression,
+    ts.SyntaxKind.TypeAssertionExpression,
+
+    ts.SyntaxKind.TypeOperator,
+    ts.SyntaxKind.ArrayType,
+
+    ts.SyntaxKind.MappedType,
+    ts.SyntaxKind.ConditionalType,
+
+    ts.SyntaxKind.TypeReference,
+
+    ts.SyntaxKind.NewExpression,
+    ts.SyntaxKind.CallExpression,
+]);
+
+function walk(ctx: Lint.WalkContext): void {
+    ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node) {
+        if (node.kind === ts.SyntaxKind.VoidKeyword && failedKinds.has(node.parent.kind)) {
+            ctx.addFailureAtNode(node, Rule.FAILURE_STRING);
+        }
+
+        ts.forEachChild(node, cb);
+    });
+}

src/rules/matchDefaultExportNameRule.ts

@@ -41,7 +41,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/newlineBeforeReturnRule.ts

@@ -39,9 +39,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     public static FAILURE_STRING = "Missing blank line before return";
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-        return this.applyWithWalker(
-            new NewlineBeforeReturnWalker(sourceFile, this.ruleName, undefined),
-        );
+        return this.applyWithWalker(new NewlineBeforeReturnWalker(sourceFile, this.ruleName, {}));
     }
 }
 

src/rules/newlinePerChainedCallRule.ts

@@ -42,9 +42,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     public static FAILURE_STRING = "When chaining calls, put method calls on new lines.";
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-        return this.applyWithWalker(
-            new NewlinePerChainedCallWalker(sourceFile, this.ruleName, undefined),
-        );
+        return this.applyWithWalker(new NewlinePerChainedCallWalker(sourceFile, this.ruleName, {}));
     }
 }
 

src/rules/noBooleanLiteralCompareRule.ts

@@ -46,7 +46,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/noForInArrayRule.ts

@@ -51,7 +51,7 @@ export class Rule extends Lint.Rules.TypedRule {
         "for-in loops over arrays are forbidden. Use for-of or array.forEach instead.";
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/noInferredEmptyObjectTypeRule.ts

@@ -59,7 +59,7 @@ class NoInferredEmptyObjectTypeRule extends Lint.AbstractWalker {
         ruleName: string,
         private readonly checker: ts.TypeChecker,
     ) {
-        super(sourceFile, ruleName, undefined);
+        super(sourceFile, ruleName, {});
     }
 
     public walk(sourceFile: ts.SourceFile) {

src/rules/noInternalModuleRule.ts

@@ -40,9 +40,7 @@ export class Rule extends Lint.Rules.AbstractRule {
         "The internal 'module' syntax is deprecated, use the 'namespace' keyword instead.";
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-        return this.applyWithWalker(
-            new NoInternalModuleWalker(sourceFile, this.ruleName, undefined),
-        );
+        return this.applyWithWalker(new NoInternalModuleWalker(sourceFile, this.ruleName, {}));
     }
 }
 

src/rules/noMergeableNamespaceRule.ts

@@ -37,7 +37,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-        return this.applyWithWalker(new Walker(sourceFile, this.ruleName, undefined));
+        return this.applyWithWalker(new Walker(sourceFile, this.ruleName, {}));
     }
 }
 

src/rules/noNullUndefinedUnionRule.ts

@@ -46,7 +46,7 @@ export class Rule extends Lint.Rules.TypedRule {
     public static FAILURE_STRING = "Union type cannot include both 'null' and 'undefined'.";
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/noSwitchCaseFallThroughRule.ts

@@ -65,7 +65,7 @@ export class Rule extends Lint.Rules.AbstractRule {
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
         return this.applyWithWalker(
-            new NoSwitchCaseFallThroughWalker(sourceFile, this.ruleName, undefined),
+            new NoSwitchCaseFallThroughWalker(sourceFile, this.ruleName, {}),
         );
     }
 }

src/rules/noUnnecessaryQualifierRule.ts

@@ -40,7 +40,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/noUnsafeAnyRule.ts

@@ -71,7 +71,7 @@ class NoUnsafeAnyWalker extends Lint.AbstractWalker {
         ruleName: string,
         private readonly checker: ts.TypeChecker,
     ) {
-        super(sourceFile, ruleName, undefined);
+        super(sourceFile, ruleName, {});
     }
 
     public walk(sourceFile: ts.SourceFile) {

src/rules/noUseBeforeDeclareRule.ts

@@ -54,7 +54,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/restrictPlusOperandsRule.ts

@@ -40,7 +40,7 @@ export class Rule extends Lint.Rules.TypedRule {
     public static SUGGEST_TEMPLATE_LITERALS = ". Consider using template literals.";
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/returnUndefinedRule.ts

@@ -48,7 +48,7 @@ export class Rule extends Lint.Rules.TypedRule {
         "`void` function should use `return;`, not `return undefined;`.";
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/strictTypePredicatesRule.ts

@@ -68,7 +68,7 @@ export class Rule extends Lint.Rules.TypedRule {
             showWarningOnce("strict-type-predicates does not work without --strictNullChecks");
             return [];
         }
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/unnecessaryBindRule.ts

@@ -47,7 +47,7 @@ export class Rule extends Lint.Rules.OptionallyTypedRule {
     }
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }
 

src/rules/useDefaultTypeParameterRule.ts

@@ -45,7 +45,7 @@ export class Rule extends Lint.Rules.TypedRule {
         "This is the default value for this type parameter, so it can be omitted.";
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+        return this.applyWithFunction(sourceFile, walk, {}, program.getTypeChecker());
     }
 }