.github/ISSUE_TEMPLATE/rule-suggestion.md

@@ -6,6 +6,8 @@ about: Suggest a new rule for TSLint
 
 ### Rule Suggestion
 
+_Note: TSLint has stopped accepting new core rules because it is being deprecated in favor of ESLint. Your request is likely to be rejected with the suggestion to maintain a custom rule outside this repository. See [the roadmap](https://github.com/palantir/tslint/issues/4534) for more details._
+
 **Is your rule for a general problem or is it specific to your development style?**
 
 **What does your suggested rule do?**

CHANGELOG.md

@@ -1,5 +1,28 @@
 # Change Log
 
+## v5.20.0
+
+- [bugfix] fix [`strict-boolean-expressions`](https://palantir.github.io/tslint/rules/strict-boolean-expressions/) false positive with `"ignore-rhs"` option (#4833)
+- [bugfix] fix [`no-unnecessary-type-assertion`](https://palantir.github.io/tslint/rules/no-unnecessary-type-assertion/) no error when `"strict": true` in compiler flags (#4841)
+- [bugfix] "ignore" option for [`file-name-casing`](https://palantir.github.io/tslint/rules/file-name-casing/) rule works correctly (#4848)
+- [bugfix] fix [`array-type`](https://palantir.github.io/tslint/rules/array-type/) false positive for simple parenthesized types with "array-simple" option (#4844)
+- [new-rule-option] [`object-literal-shorthand`](https://palantir.github.io/tslint/rules/object-literal-shorthand/) supports `{"property"?: "never", "method"?: "never"}` as config options (#4842)
+- [new-rule-option]: `allow-generics` option for [`invalid-void`](https://palantir.github.io/tslint/rules/invalid-void) rule (#4839)
+- [new-rule-option] `check-super-calls` option for [`unnecessary-constructor`](https://palantir.github.io/tslint/rules/unnecessary-constructor/) rule (#4813)
+- [chore] Upgrade `diff` dependency to v4.0.1 (#4845, #4852)
+
+Thanks to our contributors!
+
+- Bas Bosman
+- Tanmoy Bhowmik
+- David Zulaica
+- Maxime Kjaer
+- @guidsdo
+- Pavel Birukov
+- Josh Goldberg
+- Akshaya Srivatsa
+
+
 ## v5.19.0
 
 - [bugfix] relax [`promise-function-async`](https://palantir.github.io/tslint/rules/promise-function-async/) for short parenthesized arrow functions (#4765)
@@ -12,9 +35,9 @@
 - [new-rule-option] `variable-declaration-ignore-function` option for [`typedef`](https://palantir.github.io/tslint/rules/typedef/) rule (#4769)
 - [new-rule-option] `ignore-blank-lines` option for [`object-literal-sort-keys`](https://palantir.github.io/tslint/rules/object-literal-sort-keys/) rule (#4808)
 - [new-rule] [`no-for-in`](https://palantir.github.io/tslint/rules/no-for-in/) (#4747)
-- [new-rule] [`no-invalid-void`](https://palantir.github.io/tslint/rules/no-invalid-void/) (#4736)
+- [new-rule] [`invalid-void`](https://palantir.github.io/tslint/rules/invalid-void/) (#4736)
 - [new-rule] [`strict-string-expressions`](https://palantir.github.io/tslint/rules/strict-string-expressions/) reports errors on type coercions found in string expressions (#4807)
-- [new-rule] ['no-promise-as-boolean'](https://palantir.github.io/tslint/rules/no-promise-as-boolean/) (#4790)
+- [new-rule] [`no-promise-as-boolean`](https://palantir.github.io/tslint/rules/no-promise-as-boolean/) (#4790)
 - [docs] link to OSS fellowship medium post in README (#4821)
 
 Thanks to our contributors!

package.json

@@ -1,6 +1,6 @@
 {
     "name": "tslint",
-    "version": "5.19.0",
+    "version": "5.20.0",
     "description": "An extensible static analysis linter for the TypeScript language",
     "bin": {
         "tslint": "./bin/tslint"
@@ -33,7 +33,7 @@
         "builtin-modules": "^1.1.1",
         "chalk": "^2.3.0",
         "commander": "^2.12.1",
-        "diff": "^3.2.0",
+        "diff": "^4.0.1",
         "glob": "^7.1.1",
         "js-yaml": "^3.13.1",
         "minimatch": "^3.0.4",

src/linter.ts

@@ -42,7 +42,7 @@ import { arrayify, dedent, flatMap, mapDefined } from "./utils";
  * Linter that can lint multiple files in consecutive runs.
  */
 export class Linter {
-    public static VERSION = "5.19.0";
+    public static VERSION = "5.20.0";
 
     public static findConfiguration = findConfiguration;
     public static findConfigurationPath = findConfigurationPath;

src/rules/arrayTypeRule.ts

@@ -164,6 +164,8 @@ function isSimpleType(nodeType: ts.TypeNode): boolean {
         case ts.SyntaxKind.ThisType:
         case ts.SyntaxKind.UnknownKeyword:
             return true;
+        case ts.SyntaxKind.ParenthesizedType:
+            return isSimpleType((nodeType as ts.ParenthesizedTypeNode).type);
         case ts.SyntaxKind.TypeReference:
             // TypeReferences must be non-generic or be another Array with a simple type
             const { typeName, typeArguments } = nodeType as ts.TypeReferenceNode;

src/rules/fileNameCasingRule.ts

@@ -25,7 +25,7 @@ import { isCamelCased, isKebabCased, isPascalCased, isSnakeCased } from "../util
 enum Casing {
     CamelCase = "camel-case",
     PascalCase = "pascal-case",
-    Ignored = "ignored",
+    Ignored = "ignore",
     KebabCase = "kebab-case",
     SnakeCase = "snake-case",
 }
@@ -40,7 +40,13 @@ type ValidationResult = Casing | undefined;
 
 type Validator<T extends Config> = (sourceFile: ts.SourceFile, casing: T) => ValidationResult;
 
-const rules = [Casing.CamelCase, Casing.PascalCase, Casing.KebabCase, Casing.SnakeCase];
+const rules = [
+    Casing.CamelCase,
+    Casing.Ignored,
+    Casing.PascalCase,
+    Casing.KebabCase,
+    Casing.SnakeCase,
+];
 
 const validCasingOptions = new Set(rules);
 

src/rules/invalidVoidRule.ts

@@ -15,35 +15,84 @@
  * limitations under the License.
  */
 
+import * as tsutils from "tsutils";
 import * as ts from "typescript";
 
 import * as Lint from "../index";
 
+const OPTION_ALLOW_GENERICS = "allow-generics";
+
+interface Options {
+    allowGenerics: boolean | Set<string>;
+}
+
+type RawOptions =
+    | undefined
+    | {
+          [OPTION_ALLOW_GENERICS]?: boolean | Set<string>;
+      };
+
+type GenericReference = ts.NewExpression | ts.TypeReferenceNode;
+
 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.
+            Disallows usage of \`void\` type outside of generic or return types.
             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],
+        optionsDescription: Lint.Utils.dedent`
+            If \`${OPTION_ALLOW_GENERICS}\` is specified as \`false\`, then generic types will no longer be allowed to to be \`void\`.
+            Alternately, provide an array of strings for \`${OPTION_ALLOW_GENERICS}\` to exclusively allow generic types by those names.`,
+        options: {
+            type: "object",
+            properties: {
+                [OPTION_ALLOW_GENERICS]: {
+                    oneOf: [
+                        { type: "boolean" },
+                        { type: "array", items: { type: "string" }, minLength: 1 },
+                    ],
+                },
+            },
+            additionalProperties: false,
+        },
+        optionExamples: [
+            true,
+            [true, { [OPTION_ALLOW_GENERICS]: false }],
+            [true, { [OPTION_ALLOW_GENERICS]: ["Promise", "PromiseLike"] }],
+        ],
         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 static FAILURE_STRING_ALLOW_GENERICS =
+        "void is only valid as a return type or generic type variable";
+    public static FAILURE_STRING_NO_GENERICS = "void is only valid as a return type";
+    public static FAILURE_WRONG_GENERIC = (genericName: string) =>
+        `${genericName} may not have void as a type variable`;
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk);
+        return this.applyWithFunction(sourceFile, walk, {
+            // tslint:disable-next-line:no-object-literal-type-assertion
+            allowGenerics: this.getAllowGenerics(this.ruleArguments[0] as RawOptions),
+        });
+    }
+
+    private getAllowGenerics(rawArgument: RawOptions) {
+        if (rawArgument == undefined) {
+            return true;
+        }
+
+        const allowGenerics = rawArgument[OPTION_ALLOW_GENERICS];
+
+        return allowGenerics instanceof Array ? new Set(allowGenerics) : Boolean(allowGenerics);
     }
 }
 
@@ -75,10 +124,60 @@ const failedKinds = new Set([
     ts.SyntaxKind.CallExpression,
 ]);
 
-function walk(ctx: Lint.WalkContext): void {
+function walk(ctx: Lint.WalkContext<Options>): void {
+    const defaultFailureString = ctx.options.allowGenerics
+        ? Rule.FAILURE_STRING_ALLOW_GENERICS
+        : Rule.FAILURE_STRING_NO_GENERICS;
+
+    const getGenericReferenceName = (node: GenericReference) => {
+        const rawName = tsutils.isNewExpression(node) ? node.expression : node.typeName;
+
+        return tsutils.isIdentifier(rawName) ? rawName.text : rawName.getText(ctx.sourceFile);
+    };
+
+    const getTypeReferenceFailure = (node: GenericReference) => {
+        if (!(ctx.options.allowGenerics instanceof Set)) {
+            return ctx.options.allowGenerics ? undefined : defaultFailureString;
+        }
+
+        const genericName = getGenericReferenceName(node);
+
+        return ctx.options.allowGenerics.has(genericName)
+            ? undefined
+            : Rule.FAILURE_WRONG_GENERIC(genericName);
+    };
+
+    const checkTypeReference = (parent: GenericReference, node: ts.Node) => {
+        const failure = getTypeReferenceFailure(parent);
+
+        if (failure !== undefined) {
+            ctx.addFailureAtNode(node, failure);
+        }
+    };
+
+    const isParentGenericReference = (
+        parent: ts.Node,
+        node: ts.Node,
+    ): parent is GenericReference => {
+        if (tsutils.isTypeReferenceNode(parent)) {
+            return true;
+        }
+
+        return (
+            tsutils.isNewExpression(parent) &&
+            parent.typeArguments !== undefined &&
+            ts.isTypeNode(node) &&
+            parent.typeArguments.indexOf(node) !== -1
+        );
+    };
+
     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);
+            if (isParentGenericReference(node.parent, node)) {
+                checkTypeReference(node.parent, node);
+            } else {
+                ctx.addFailureAtNode(node, defaultFailureString);
+            }
         }
 
         ts.forEachChild(node, cb);

src/rules/noUnnecessaryTypeAssertionRule.ts

@@ -44,13 +44,18 @@ export class Rule extends Lint.Rules.TypedRule {
         "This assertion is unnecessary since it does not change the type of the expression.";
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
+        const compilerOptions = program.getCompilerOptions();
+        const strictChecksEnabled = !!compilerOptions.strict;
+        const strictNullChecksEnabled = compilerOptions.strictNullChecks === true;
+        const strictNullChecksNotDisabled = compilerOptions.strictNullChecks !== false;
+
         return this.applyWithWalker(
             new Walker(
                 sourceFile,
                 this.ruleName,
                 this.ruleArguments,
                 program.getTypeChecker(),
-                !!program.getCompilerOptions().strictNullChecks,
+                strictNullChecksEnabled || (strictChecksEnabled && strictNullChecksNotDisabled),
             ),
         );
     }