From cc84811dfb7026626a481a5f3d166ac33f247bf4 Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Tue, 21 May 2019 09:51:23 +0300 Subject: [PATCH 01/12] [new-rule] Added new no-invalid-void rule Fixes #4732 --- src/configs/all.ts | 1 + src/rules/noInvalidVoidRule.ts | 67 +++++++++++++++++++++++++ test/rules/no-invalid-void/test.ts.lint | 34 +++++++++++++ test/rules/no-invalid-void/tslint.json | 5 ++ 4 files changed, 107 insertions(+) create mode 100644 src/rules/noInvalidVoidRule.ts create mode 100644 test/rules/no-invalid-void/test.ts.lint create mode 100644 test/rules/no-invalid-void/tslint.json diff --git a/src/configs/all.ts b/src/configs/all.ts index fb98cc7f242..1743724ee90 100644 --- a/src/configs/all.ts +++ b/src/configs/all.ts @@ -170,6 +170,7 @@ export const rules = { "no-default-export": true, "no-default-import": true, "no-duplicate-imports": true, + "no-invalid-void": true, "no-irregular-whitespace": true, "no-mergeable-namespace": true, "no-parameter-reassignment": true, diff --git a/src/rules/noInvalidVoidRule.ts b/src/rules/noInvalidVoidRule.ts new file mode 100644 index 00000000000..7218cc8e371 --- /dev/null +++ b/src/rules/noInvalidVoidRule.ts @@ -0,0 +1,67 @@ +/** + * @license + * Copyright 2017 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: "no-invalid-void", + description: + "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.", + hasFix: false, + optionsDescription: "Not configurable.", + options: null, + optionExamples: [true], + type: "maintainability", + typescriptOnly: true, + }; + /* tslint:enable:object-literal-sort-keys */ + + public static FAILURE_STRING = "void as non-return type is forbidden"; + + public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] { + return this.applyWithFunction(sourceFile, walk); + } +} + +const failedKinds = [ + ts.SyntaxKind.PropertySignature, + ts.SyntaxKind.PropertyDeclaration, + + ts.SyntaxKind.VariableDeclaration, + ts.SyntaxKind.TypeAliasDeclaration, + + ts.SyntaxKind.IntersectionType, + ts.SyntaxKind.UnionType, +]; + +function walk(ctx: Lint.WalkContext): void { + ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node) { + if ( + node.kind === ts.SyntaxKind.VoidKeyword && + node.parent !== undefined && + failedKinds.indexOf(node.parent.kind) !== -1 + ) { + ctx.addFailureAtNode(node, Rule.FAILURE_STRING); + } + + ts.forEachChild(node, cb); + }); +} diff --git a/test/rules/no-invalid-void/test.ts.lint b/test/rules/no-invalid-void/test.ts.lint new file mode 100644 index 00000000000..0fecf1939bb --- /dev/null +++ b/test/rules/no-invalid-void/test.ts.lint @@ -0,0 +1,34 @@ +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] diff --git a/test/rules/no-invalid-void/tslint.json b/test/rules/no-invalid-void/tslint.json new file mode 100644 index 00000000000..251683e361d --- /dev/null +++ b/test/rules/no-invalid-void/tslint.json @@ -0,0 +1,5 @@ +{ + "rules": { + "no-invalid-void": true + } +} From aa977594ffd501a3d00caac0f391307b9d059943 Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Tue, 21 May 2019 10:00:42 +0300 Subject: [PATCH 02/12] [no-invalid-void] Fixed lint error --- src/language/rule/abstractRule.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/src/language/rule/abstractRule.ts b/src/language/rule/abstractRule.ts index 53dc9156f72..89d97b6dce5 100644 --- a/src/language/rule/abstractRule.ts +++ b/src/language/rule/abstractRule.ts @@ -67,6 +67,7 @@ export abstract class AbstractRule implements IRule { ): RuleFailure[]; protected applyWithFunction( sourceFile: ts.SourceFile, + // tslint:disable-next-line:no-invalid-void walkFn: (ctx: WalkContext, programOrChecker?: U) => void, options?: T, programOrChecker?: U, From 355e33952ec361c34c24dc546bec6d1b1943f514 Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Tue, 28 May 2019 12:10:46 +0300 Subject: [PATCH 03/12] [no-invalid-void] Changed copyright year --- src/rules/noInvalidVoidRule.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/rules/noInvalidVoidRule.ts b/src/rules/noInvalidVoidRule.ts index 7218cc8e371..38aa30af168 100644 --- a/src/rules/noInvalidVoidRule.ts +++ b/src/rules/noInvalidVoidRule.ts @@ -1,6 +1,6 @@ /** * @license - * Copyright 2017 Palantir Technologies, Inc. + * 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. From 60ed94ae762f5d6bac4022a0777ef012a3427754 Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Tue, 28 May 2019 12:11:23 +0300 Subject: [PATCH 04/12] [no-invalid-void] Removed unnecessary checking parent of the node --- src/rules/noInvalidVoidRule.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/rules/noInvalidVoidRule.ts b/src/rules/noInvalidVoidRule.ts index 38aa30af168..e3b56614633 100644 --- a/src/rules/noInvalidVoidRule.ts +++ b/src/rules/noInvalidVoidRule.ts @@ -56,7 +56,6 @@ function walk(ctx: Lint.WalkContext): void { ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node) { if ( node.kind === ts.SyntaxKind.VoidKeyword && - node.parent !== undefined && failedKinds.indexOf(node.parent.kind) !== -1 ) { ctx.addFailureAtNode(node, Rule.FAILURE_STRING); From c80e995fd842d687e529ba2aded3e3e1abbbec9f Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Tue, 28 May 2019 12:14:25 +0300 Subject: [PATCH 05/12] [no-invalid-void] Fixed a long string --- src/rules/noInvalidVoidRule.ts | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/rules/noInvalidVoidRule.ts b/src/rules/noInvalidVoidRule.ts index e3b56614633..6d914e65d35 100644 --- a/src/rules/noInvalidVoidRule.ts +++ b/src/rules/noInvalidVoidRule.ts @@ -23,8 +23,9 @@ export class Rule extends Lint.Rules.AbstractRule { /* tslint:disable:object-literal-sort-keys */ public static metadata: Lint.IRuleMetadata = { ruleName: "no-invalid-void", - description: - "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.", + 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.`, hasFix: false, optionsDescription: "Not configurable.", options: null, From 5ccb06f1ab1fb512743eaec6f33a250fc7ed47d1 Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Tue, 28 May 2019 12:17:20 +0300 Subject: [PATCH 06/12] [invalid-void] Renamed no-invalid-void rule to invalid-void --- src/configs/all.ts | 2 +- src/language/rule/abstractRule.ts | 2 +- src/rules/{noInvalidVoidRule.ts => invalidVoidRule.ts} | 2 +- test/rules/{no-invalid-void => invalid-void}/test.ts.lint | 0 test/rules/invalid-void/tslint.json | 5 +++++ test/rules/no-invalid-void/tslint.json | 5 ----- 6 files changed, 8 insertions(+), 8 deletions(-) rename src/rules/{noInvalidVoidRule.ts => invalidVoidRule.ts} (98%) rename test/rules/{no-invalid-void => invalid-void}/test.ts.lint (100%) create mode 100644 test/rules/invalid-void/tslint.json delete mode 100644 test/rules/no-invalid-void/tslint.json diff --git a/src/configs/all.ts b/src/configs/all.ts index 1743724ee90..12c82c9a813 100644 --- a/src/configs/all.ts +++ b/src/configs/all.ts @@ -161,6 +161,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 }, @@ -170,7 +171,6 @@ export const rules = { "no-default-export": true, "no-default-import": true, "no-duplicate-imports": true, - "no-invalid-void": true, "no-irregular-whitespace": true, "no-mergeable-namespace": true, "no-parameter-reassignment": true, diff --git a/src/language/rule/abstractRule.ts b/src/language/rule/abstractRule.ts index 89d97b6dce5..9d865be88ec 100644 --- a/src/language/rule/abstractRule.ts +++ b/src/language/rule/abstractRule.ts @@ -67,7 +67,7 @@ export abstract class AbstractRule implements IRule { ): RuleFailure[]; protected applyWithFunction( sourceFile: ts.SourceFile, - // tslint:disable-next-line:no-invalid-void + // tslint:disable-next-line:invalid-void walkFn: (ctx: WalkContext, programOrChecker?: U) => void, options?: T, programOrChecker?: U, diff --git a/src/rules/noInvalidVoidRule.ts b/src/rules/invalidVoidRule.ts similarity index 98% rename from src/rules/noInvalidVoidRule.ts rename to src/rules/invalidVoidRule.ts index 6d914e65d35..4abfedefb75 100644 --- a/src/rules/noInvalidVoidRule.ts +++ b/src/rules/invalidVoidRule.ts @@ -22,7 +22,7 @@ import * as Lint from "../index"; export class Rule extends Lint.Rules.AbstractRule { /* tslint:disable:object-literal-sort-keys */ public static metadata: Lint.IRuleMetadata = { - ruleName: "no-invalid-void", + 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.`, diff --git a/test/rules/no-invalid-void/test.ts.lint b/test/rules/invalid-void/test.ts.lint similarity index 100% rename from test/rules/no-invalid-void/test.ts.lint rename to test/rules/invalid-void/test.ts.lint diff --git a/test/rules/invalid-void/tslint.json b/test/rules/invalid-void/tslint.json new file mode 100644 index 00000000000..79da7276673 --- /dev/null +++ b/test/rules/invalid-void/tslint.json @@ -0,0 +1,5 @@ +{ + "rules": { + "invalid-void": true + } +} diff --git a/test/rules/no-invalid-void/tslint.json b/test/rules/no-invalid-void/tslint.json deleted file mode 100644 index 251683e361d..00000000000 --- a/test/rules/no-invalid-void/tslint.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "rules": { - "no-invalid-void": true - } -} From 204c47ce5824c40b037a6e67bd85260c5518749c Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Tue, 28 May 2019 12:28:51 +0300 Subject: [PATCH 07/12] [invalid-void] Added rationale --- src/rules/invalidVoidRule.ts | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/rules/invalidVoidRule.ts b/src/rules/invalidVoidRule.ts index 4abfedefb75..a6ef1fc029a 100644 --- a/src/rules/invalidVoidRule.ts +++ b/src/rules/invalidVoidRule.ts @@ -24,8 +24,13 @@ export class Rule extends Lint.Rules.AbstractRule { 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.`, + 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, From b754115f98f8a202d6fad67e54a1a99599e2382f Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Sun, 16 Jun 2019 12:45:29 +0300 Subject: [PATCH 08/12] [invalid-void] Changed failure string --- src/rules/invalidVoidRule.ts | 2 +- test/rules/invalid-void/test.ts.lint | 16 +++++++++------- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/src/rules/invalidVoidRule.ts b/src/rules/invalidVoidRule.ts index a6ef1fc029a..cc7d42e60e5 100644 --- a/src/rules/invalidVoidRule.ts +++ b/src/rules/invalidVoidRule.ts @@ -40,7 +40,7 @@ export class Rule extends Lint.Rules.AbstractRule { }; /* tslint:enable:object-literal-sort-keys */ - public static FAILURE_STRING = "void as non-return type is forbidden"; + 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); diff --git a/test/rules/invalid-void/test.ts.lint b/test/rules/invalid-void/test.ts.lint index 0fecf1939bb..54492043eb2 100644 --- a/test/rules/invalid-void/test.ts.lint +++ b/test/rules/invalid-void/test.ts.lint @@ -5,19 +5,19 @@ type NormalType = () => void; interface Interface { lambda: () => void; voidProp: void; - ~~~~ [void as non-return type is forbidden] + ~~~~ [0] } class ClassName { private readonly propName: void; - ~~~~ [void as non-return type is forbidden] + ~~~~ [0] } let letVoid: void; - ~~~~ [void as non-return type is forbidden] + ~~~~ [0] type VoidType = void; - ~~~~ [void as non-return type is forbidden] + ~~~~ [0] class OtherClassName { private propName: VoidType; @@ -25,10 +25,12 @@ class OtherClassName { type UnionType = string | number; type UnionType2 = string | number | void; - ~~~~ [void as non-return type is forbidden] + ~~~~ [0] type UnionType3 = string | (number & any | (string | void)); - ~~~~ [void as non-return type is forbidden] + ~~~~ [0] type IntersectionType = string & number & void; - ~~~~ [void as non-return type is forbidden] + ~~~~ [0] + +[0]: void is not a valid type other than return types From 6b87399443918a6fdb2e2332cd402c1b332334cc Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Sun, 16 Jun 2019 12:46:43 +0300 Subject: [PATCH 09/12] [invalid-void] Changed failedKinds type from Array to Set --- src/rules/invalidVoidRule.ts | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/rules/invalidVoidRule.ts b/src/rules/invalidVoidRule.ts index cc7d42e60e5..991bef3c921 100644 --- a/src/rules/invalidVoidRule.ts +++ b/src/rules/invalidVoidRule.ts @@ -47,7 +47,7 @@ export class Rule extends Lint.Rules.AbstractRule { } } -const failedKinds = [ +const failedKinds = new Set([ ts.SyntaxKind.PropertySignature, ts.SyntaxKind.PropertyDeclaration, @@ -56,14 +56,11 @@ const failedKinds = [ ts.SyntaxKind.IntersectionType, ts.SyntaxKind.UnionType, -]; +]); function walk(ctx: Lint.WalkContext): void { ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node) { - if ( - node.kind === ts.SyntaxKind.VoidKeyword && - failedKinds.indexOf(node.parent.kind) !== -1 - ) { + if (node.kind === ts.SyntaxKind.VoidKeyword && failedKinds.has(node.parent.kind)) { ctx.addFailureAtNode(node, Rule.FAILURE_STRING); } From c8ff62ed9c31c945f387d68d4f44ef5a265472f0 Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Sun, 16 Jun 2019 13:46:25 +0300 Subject: [PATCH 10/12] [invalid-void] Added new kinds to fail --- src/language/rule/abstractRule.ts | 7 +- src/language/walker/walkContext.ts | 2 +- src/language/walker/walker.ts | 2 +- src/rules/deprecationRule.ts | 2 +- src/rules/importSpacingRule.ts | 2 +- src/rules/invalidVoidRule.ts | 17 +++++ src/rules/matchDefaultExportNameRule.ts | 2 +- src/rules/newlineBeforeReturnRule.ts | 4 +- src/rules/newlinePerChainedCallRule.ts | 4 +- src/rules/noBooleanLiteralCompareRule.ts | 2 +- src/rules/noForInArrayRule.ts | 2 +- src/rules/noInferredEmptyObjectTypeRule.ts | 2 +- src/rules/noInternalModuleRule.ts | 4 +- src/rules/noMergeableNamespaceRule.ts | 2 +- src/rules/noNullUndefinedUnionRule.ts | 2 +- src/rules/noSwitchCaseFallThroughRule.ts | 2 +- src/rules/noUnnecessaryQualifierRule.ts | 2 +- src/rules/noUnsafeAnyRule.ts | 2 +- src/rules/noUseBeforeDeclareRule.ts | 2 +- src/rules/restrictPlusOperandsRule.ts | 2 +- src/rules/returnUndefinedRule.ts | 2 +- src/rules/strictTypePredicatesRule.ts | 2 +- src/rules/unnecessaryBindRule.ts | 2 +- src/rules/useDefaultTypeParameterRule.ts | 2 +- test/rules/invalid-void/test.ts.lint | 78 ++++++++++++++++++++++ 25 files changed, 121 insertions(+), 31 deletions(-) diff --git a/src/language/rule/abstractRule.ts b/src/language/rule/abstractRule.ts index 9d865be88ec..00c5565c4bb 100644 --- a/src/language/rule/abstractRule.ts +++ b/src/language/rule/abstractRule.ts @@ -67,12 +67,13 @@ export abstract class AbstractRule implements IRule { ): RuleFailure[]; protected applyWithFunction( sourceFile: ts.SourceFile, - // tslint:disable-next-line:invalid-void - walkFn: (ctx: WalkContext, programOrChecker?: U) => void, + walkFn: (ctx: WalkContext | 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 + | WalkContext); walkFn(ctx, programOrChecker); return ctx.failures; } diff --git a/src/language/walker/walkContext.ts b/src/language/walker/walkContext.ts index 522af77174d..6d7c4239b00 100644 --- a/src/language/walker/walkContext.ts +++ b/src/language/walker/walkContext.ts @@ -19,7 +19,7 @@ import * as ts from "typescript"; import { Fix, RuleFailure } from "../rule/rule"; -export class WalkContext { +export class WalkContext { public readonly failures: RuleFailure[] = []; constructor( diff --git a/src/language/walker/walker.ts b/src/language/walker/walker.ts index de92391e82e..d2e74280e28 100644 --- a/src/language/walker/walker.ts +++ b/src/language/walker/walker.ts @@ -27,7 +27,7 @@ export interface IWalker { getFailures(): RuleFailure[]; } -export abstract class AbstractWalker extends WalkContext implements IWalker { +export abstract class AbstractWalker extends WalkContext implements IWalker { public abstract walk(sourceFile: ts.SourceFile): void; public getSourceFile() { diff --git a/src/rules/deprecationRule.ts b/src/rules/deprecationRule.ts index e5342617e43..8e07d915716 100644 --- a/src/rules/deprecationRule.ts +++ b/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()); } } diff --git a/src/rules/importSpacingRule.ts b/src/rules/importSpacingRule.ts index 9d6c9385a87..447863d34d8 100644 --- a/src/rules/importSpacingRule.ts +++ b/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, {})); } } diff --git a/src/rules/invalidVoidRule.ts b/src/rules/invalidVoidRule.ts index 991bef3c921..2baec30a50f 100644 --- a/src/rules/invalidVoidRule.ts +++ b/src/rules/invalidVoidRule.ts @@ -56,6 +56,23 @@ const failedKinds = new Set([ 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 { diff --git a/src/rules/matchDefaultExportNameRule.ts b/src/rules/matchDefaultExportNameRule.ts index 44186c5a5be..2d4a8e8b4ca 100644 --- a/src/rules/matchDefaultExportNameRule.ts +++ b/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()); } } diff --git a/src/rules/newlineBeforeReturnRule.ts b/src/rules/newlineBeforeReturnRule.ts index c961d348db7..f82ce695cfd 100644 --- a/src/rules/newlineBeforeReturnRule.ts +++ b/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, {})); } } diff --git a/src/rules/newlinePerChainedCallRule.ts b/src/rules/newlinePerChainedCallRule.ts index 2fe3367692a..11927bb7339 100644 --- a/src/rules/newlinePerChainedCallRule.ts +++ b/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, {})); } } diff --git a/src/rules/noBooleanLiteralCompareRule.ts b/src/rules/noBooleanLiteralCompareRule.ts index 0fd3584d109..22fecb39500 100644 --- a/src/rules/noBooleanLiteralCompareRule.ts +++ b/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()); } } diff --git a/src/rules/noForInArrayRule.ts b/src/rules/noForInArrayRule.ts index 67cdfb03907..6699032a3b2 100644 --- a/src/rules/noForInArrayRule.ts +++ b/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()); } } diff --git a/src/rules/noInferredEmptyObjectTypeRule.ts b/src/rules/noInferredEmptyObjectTypeRule.ts index 3c6dbb4166d..6f8b2e06fec 100644 --- a/src/rules/noInferredEmptyObjectTypeRule.ts +++ b/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) { diff --git a/src/rules/noInternalModuleRule.ts b/src/rules/noInternalModuleRule.ts index 4f8ad5cd850..117c6ffbbda 100644 --- a/src/rules/noInternalModuleRule.ts +++ b/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, {})); } } diff --git a/src/rules/noMergeableNamespaceRule.ts b/src/rules/noMergeableNamespaceRule.ts index 782531cf7b1..c0a8664e3e5 100644 --- a/src/rules/noMergeableNamespaceRule.ts +++ b/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, {})); } } diff --git a/src/rules/noNullUndefinedUnionRule.ts b/src/rules/noNullUndefinedUnionRule.ts index 312e796cb7b..39d0f8cd7cb 100644 --- a/src/rules/noNullUndefinedUnionRule.ts +++ b/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()); } } diff --git a/src/rules/noSwitchCaseFallThroughRule.ts b/src/rules/noSwitchCaseFallThroughRule.ts index 4d2342aac06..647095cfe5a 100644 --- a/src/rules/noSwitchCaseFallThroughRule.ts +++ b/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, {}), ); } } diff --git a/src/rules/noUnnecessaryQualifierRule.ts b/src/rules/noUnnecessaryQualifierRule.ts index 623255dc0ee..effba443bd2 100644 --- a/src/rules/noUnnecessaryQualifierRule.ts +++ b/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()); } } diff --git a/src/rules/noUnsafeAnyRule.ts b/src/rules/noUnsafeAnyRule.ts index 9831168a883..68b54b73073 100644 --- a/src/rules/noUnsafeAnyRule.ts +++ b/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) { diff --git a/src/rules/noUseBeforeDeclareRule.ts b/src/rules/noUseBeforeDeclareRule.ts index bc8eb868ae0..f9da90191f0 100644 --- a/src/rules/noUseBeforeDeclareRule.ts +++ b/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()); } } diff --git a/src/rules/restrictPlusOperandsRule.ts b/src/rules/restrictPlusOperandsRule.ts index 5b34e6a5cce..31e3d5fdff4 100644 --- a/src/rules/restrictPlusOperandsRule.ts +++ b/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()); } } diff --git a/src/rules/returnUndefinedRule.ts b/src/rules/returnUndefinedRule.ts index 5e8ff40c6fa..c44648098ae 100644 --- a/src/rules/returnUndefinedRule.ts +++ b/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()); } } diff --git a/src/rules/strictTypePredicatesRule.ts b/src/rules/strictTypePredicatesRule.ts index 988d5a16fde..db00bfd6000 100644 --- a/src/rules/strictTypePredicatesRule.ts +++ b/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()); } } diff --git a/src/rules/unnecessaryBindRule.ts b/src/rules/unnecessaryBindRule.ts index 4ead10cec8b..e89d6d1d696 100644 --- a/src/rules/unnecessaryBindRule.ts +++ b/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()); } } diff --git a/src/rules/useDefaultTypeParameterRule.ts b/src/rules/useDefaultTypeParameterRule.ts index 82da66b9144..113e5526ad8 100644 --- a/src/rules/useDefaultTypeParameterRule.ts +++ b/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()); } } diff --git a/test/rules/invalid-void/test.ts.lint b/test/rules/invalid-void/test.ts.lint index 54492043eb2..11df17583f1 100644 --- a/test/rules/invalid-void/test.ts.lint +++ b/test/rules/invalid-void/test.ts.lint @@ -2,6 +2,61 @@ function func(): void {} type NormalType = () => void; +let normalArrow = (): void => { } + +let ughThisThing = void 0; + +function takeThing(thing: undefined) { } +takeThing(void 0); + +function takeVoid(thing: void) { } + ~~~~ [0] + + +const arrowGeneric = (arg: T) => { } + ~~~~ [0] +const arrowGeneric1 = (arg: T) => { } + ~~~~ [0] +const arrowGeneric2 = (arg: T) => { } + ~~~~ [0] + ~~~~ [0] + +function functionGeneric(arg: T) {} + ~~~~ [0] +function functionGeneric1(arg: T) {} + ~~~~ [0] +function functionGeneric2(arg: T) {} + ~~~~ [0] + ~~~~ [0] + +declare function functionDeclaration(arg: T): void; + ~~~~ [0] +declare function functionDeclaration1(arg: T): void; + ~~~~ [0] +declare function functionDeclaration2(arg: T): void; + ~~~~ [0] + ~~~~ [0] + + +functionGeneric(undefined); + ~~~~ [0] + +declare function voidArray(args: void[]): void[]; + ~~~~ [0] + ~~~~ [0] + +let value = undefined as void; + ~~~~ [0] + +let value = undefined; + ~~~~ [0] + +function takesThings(...things: void[]): void { } + ~~~~ [0] + +type KeyofVoid = keyof void; + ~~~~[0] + interface Interface { lambda: () => void; voidProp: void; @@ -13,6 +68,10 @@ class ClassName { ~~~~ [0] } +let invalidMap: Map = new Map(); + ~~~~ [0] + ~~~~ [0] + let letVoid: void; ~~~~ [0] @@ -33,4 +92,23 @@ type UnionType3 = string | (number & any | (string | void)); type IntersectionType = string & number & void; ~~~~ [0] +#if typescript >= 2.8.0 +type MappedType = { + [K in keyof T]: void; + ~~~~ [0] +} +type ConditionalType = { + [K in keyof T]: T[K] extends string ? void : string; + ~~~~ [0] +} +#endif + +#if typescript >= 3.4.0 +type ManyVoid = readonly void[]; + ~~~~ [0] + +function foo(arr: readonly void[]) { } + ~~~~ [0] +#endif + [0]: void is not a valid type other than return types From 03545dd1b036528b162a0f36f47a38ac8252f38b Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Sun, 16 Jun 2019 13:58:35 +0300 Subject: [PATCH 11/12] [invalid-void] Fixed build for TypeScript < 2.3 https://github.com/Microsoft/TypeScript/wiki/What's-new-in-TypeScript#generic-parameter-defaults --- test/rules/invalid-void/test.ts.lint | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/test/rules/invalid-void/test.ts.lint b/test/rules/invalid-void/test.ts.lint index 11df17583f1..27c065770b1 100644 --- a/test/rules/invalid-void/test.ts.lint +++ b/test/rules/invalid-void/test.ts.lint @@ -15,27 +15,34 @@ function takeVoid(thing: void) { } const arrowGeneric = (arg: T) => { } ~~~~ [0] +#if typescript >= 2.3.0 const arrowGeneric1 = (arg: T) => { } ~~~~ [0] const arrowGeneric2 = (arg: T) => { } ~~~~ [0] ~~~~ [0] +#endif +#if typescript >= 2.3.0 function functionGeneric(arg: T) {} ~~~~ [0] + function functionGeneric1(arg: T) {} ~~~~ [0] function functionGeneric2(arg: T) {} ~~~~ [0] ~~~~ [0] +#endif declare function functionDeclaration(arg: T): void; ~~~~ [0] +#if typescript >= 2.3.0 declare function functionDeclaration1(arg: T): void; ~~~~ [0] declare function functionDeclaration2(arg: T): void; ~~~~ [0] ~~~~ [0] +#endif functionGeneric(undefined); From 0bff08430763ebd5af3fa94099a418b228536fff Mon Sep 17 00:00:00 2001 From: Evgeniy Timokhov Date: Sat, 6 Jul 2019 11:48:26 +0300 Subject: [PATCH 12/12] [invalid-void] Replaced default generic type of WalkContext and AbstractWalker to undefined from {} --- src/language/rule/abstractRule.ts | 6 ++---- src/language/walker/walkContext.ts | 2 +- src/language/walker/walker.ts | 2 +- src/rules/deprecationRule.ts | 2 +- src/rules/importSpacingRule.ts | 2 +- src/rules/matchDefaultExportNameRule.ts | 2 +- src/rules/newlineBeforeReturnRule.ts | 4 +++- src/rules/newlinePerChainedCallRule.ts | 4 +++- src/rules/noBooleanLiteralCompareRule.ts | 2 +- src/rules/noForInArrayRule.ts | 2 +- src/rules/noInferredEmptyObjectTypeRule.ts | 2 +- src/rules/noInternalModuleRule.ts | 4 +++- src/rules/noMergeableNamespaceRule.ts | 2 +- src/rules/noNullUndefinedUnionRule.ts | 2 +- src/rules/noSwitchCaseFallThroughRule.ts | 2 +- src/rules/noUnnecessaryQualifierRule.ts | 2 +- src/rules/noUnsafeAnyRule.ts | 2 +- src/rules/noUseBeforeDeclareRule.ts | 2 +- src/rules/restrictPlusOperandsRule.ts | 2 +- src/rules/returnUndefinedRule.ts | 2 +- src/rules/strictTypePredicatesRule.ts | 2 +- src/rules/unnecessaryBindRule.ts | 2 +- src/rules/useDefaultTypeParameterRule.ts | 2 +- 23 files changed, 30 insertions(+), 26 deletions(-) diff --git a/src/language/rule/abstractRule.ts b/src/language/rule/abstractRule.ts index 00c5565c4bb..8e1d5bf5e75 100644 --- a/src/language/rule/abstractRule.ts +++ b/src/language/rule/abstractRule.ts @@ -67,13 +67,11 @@ export abstract class AbstractRule implements IRule { ): RuleFailure[]; protected applyWithFunction( sourceFile: ts.SourceFile, - walkFn: (ctx: WalkContext | WalkContext, programOrChecker?: U) => void, + walkFn: (ctx: WalkContext, programOrChecker?: U) => void, options?: T, programOrChecker?: U, ): RuleFailure[] { - const ctx = new WalkContext(sourceFile, this.ruleName, options) as ( - | WalkContext - | WalkContext); + const ctx = new WalkContext(sourceFile, this.ruleName, options); walkFn(ctx, programOrChecker); return ctx.failures; } diff --git a/src/language/walker/walkContext.ts b/src/language/walker/walkContext.ts index 6d7c4239b00..3bbdea62709 100644 --- a/src/language/walker/walkContext.ts +++ b/src/language/walker/walkContext.ts @@ -19,7 +19,7 @@ import * as ts from "typescript"; import { Fix, RuleFailure } from "../rule/rule"; -export class WalkContext { +export class WalkContext { public readonly failures: RuleFailure[] = []; constructor( diff --git a/src/language/walker/walker.ts b/src/language/walker/walker.ts index d2e74280e28..41a1a75ade0 100644 --- a/src/language/walker/walker.ts +++ b/src/language/walker/walker.ts @@ -27,7 +27,7 @@ export interface IWalker { getFailures(): RuleFailure[]; } -export abstract class AbstractWalker extends WalkContext implements IWalker { +export abstract class AbstractWalker extends WalkContext implements IWalker { public abstract walk(sourceFile: ts.SourceFile): void; public getSourceFile() { diff --git a/src/rules/deprecationRule.ts b/src/rules/deprecationRule.ts index 8e07d915716..e5342617e43 100644 --- a/src/rules/deprecationRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/importSpacingRule.ts b/src/rules/importSpacingRule.ts index 447863d34d8..9d6c9385a87 100644 --- a/src/rules/importSpacingRule.ts +++ b/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, {})); + return this.applyWithWalker(new Walker(sourceFile, this.ruleName, undefined)); } } diff --git a/src/rules/matchDefaultExportNameRule.ts b/src/rules/matchDefaultExportNameRule.ts index 2d4a8e8b4ca..44186c5a5be 100644 --- a/src/rules/matchDefaultExportNameRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/newlineBeforeReturnRule.ts b/src/rules/newlineBeforeReturnRule.ts index f82ce695cfd..c961d348db7 100644 --- a/src/rules/newlineBeforeReturnRule.ts +++ b/src/rules/newlineBeforeReturnRule.ts @@ -39,7 +39,9 @@ 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, {})); + return this.applyWithWalker( + new NewlineBeforeReturnWalker(sourceFile, this.ruleName, undefined), + ); } } diff --git a/src/rules/newlinePerChainedCallRule.ts b/src/rules/newlinePerChainedCallRule.ts index 11927bb7339..2fe3367692a 100644 --- a/src/rules/newlinePerChainedCallRule.ts +++ b/src/rules/newlinePerChainedCallRule.ts @@ -42,7 +42,9 @@ 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, {})); + return this.applyWithWalker( + new NewlinePerChainedCallWalker(sourceFile, this.ruleName, undefined), + ); } } diff --git a/src/rules/noBooleanLiteralCompareRule.ts b/src/rules/noBooleanLiteralCompareRule.ts index 22fecb39500..0fd3584d109 100644 --- a/src/rules/noBooleanLiteralCompareRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/noForInArrayRule.ts b/src/rules/noForInArrayRule.ts index 6699032a3b2..67cdfb03907 100644 --- a/src/rules/noForInArrayRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/noInferredEmptyObjectTypeRule.ts b/src/rules/noInferredEmptyObjectTypeRule.ts index 6f8b2e06fec..3c6dbb4166d 100644 --- a/src/rules/noInferredEmptyObjectTypeRule.ts +++ b/src/rules/noInferredEmptyObjectTypeRule.ts @@ -59,7 +59,7 @@ class NoInferredEmptyObjectTypeRule extends Lint.AbstractWalker { ruleName: string, private readonly checker: ts.TypeChecker, ) { - super(sourceFile, ruleName, {}); + super(sourceFile, ruleName, undefined); } public walk(sourceFile: ts.SourceFile) { diff --git a/src/rules/noInternalModuleRule.ts b/src/rules/noInternalModuleRule.ts index 117c6ffbbda..4f8ad5cd850 100644 --- a/src/rules/noInternalModuleRule.ts +++ b/src/rules/noInternalModuleRule.ts @@ -40,7 +40,9 @@ 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, {})); + return this.applyWithWalker( + new NoInternalModuleWalker(sourceFile, this.ruleName, undefined), + ); } } diff --git a/src/rules/noMergeableNamespaceRule.ts b/src/rules/noMergeableNamespaceRule.ts index c0a8664e3e5..782531cf7b1 100644 --- a/src/rules/noMergeableNamespaceRule.ts +++ b/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, {})); + return this.applyWithWalker(new Walker(sourceFile, this.ruleName, undefined)); } } diff --git a/src/rules/noNullUndefinedUnionRule.ts b/src/rules/noNullUndefinedUnionRule.ts index 39d0f8cd7cb..312e796cb7b 100644 --- a/src/rules/noNullUndefinedUnionRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/noSwitchCaseFallThroughRule.ts b/src/rules/noSwitchCaseFallThroughRule.ts index 647095cfe5a..4d2342aac06 100644 --- a/src/rules/noSwitchCaseFallThroughRule.ts +++ b/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, {}), + new NoSwitchCaseFallThroughWalker(sourceFile, this.ruleName, undefined), ); } } diff --git a/src/rules/noUnnecessaryQualifierRule.ts b/src/rules/noUnnecessaryQualifierRule.ts index effba443bd2..623255dc0ee 100644 --- a/src/rules/noUnnecessaryQualifierRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/noUnsafeAnyRule.ts b/src/rules/noUnsafeAnyRule.ts index 68b54b73073..9831168a883 100644 --- a/src/rules/noUnsafeAnyRule.ts +++ b/src/rules/noUnsafeAnyRule.ts @@ -71,7 +71,7 @@ class NoUnsafeAnyWalker extends Lint.AbstractWalker { ruleName: string, private readonly checker: ts.TypeChecker, ) { - super(sourceFile, ruleName, {}); + super(sourceFile, ruleName, undefined); } public walk(sourceFile: ts.SourceFile) { diff --git a/src/rules/noUseBeforeDeclareRule.ts b/src/rules/noUseBeforeDeclareRule.ts index f9da90191f0..bc8eb868ae0 100644 --- a/src/rules/noUseBeforeDeclareRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/restrictPlusOperandsRule.ts b/src/rules/restrictPlusOperandsRule.ts index 31e3d5fdff4..5b34e6a5cce 100644 --- a/src/rules/restrictPlusOperandsRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/returnUndefinedRule.ts b/src/rules/returnUndefinedRule.ts index c44648098ae..5e8ff40c6fa 100644 --- a/src/rules/returnUndefinedRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/strictTypePredicatesRule.ts b/src/rules/strictTypePredicatesRule.ts index db00bfd6000..988d5a16fde 100644 --- a/src/rules/strictTypePredicatesRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/unnecessaryBindRule.ts b/src/rules/unnecessaryBindRule.ts index e89d6d1d696..4ead10cec8b 100644 --- a/src/rules/unnecessaryBindRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } } diff --git a/src/rules/useDefaultTypeParameterRule.ts b/src/rules/useDefaultTypeParameterRule.ts index 113e5526ad8..82da66b9144 100644 --- a/src/rules/useDefaultTypeParameterRule.ts +++ b/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, {}, program.getTypeChecker()); + return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker()); } }