Default type parameter of WalkContext and AbstractWalker to void (#2600)

* Default type parameter of WalkContext and AbstractWalker to void * Also fixed WalkContext<void> violations
palantir · Mar 24, 2019 · 4b8bbf6 · 4b8bbf6
1 parent a3c2bff
commit 4b8bbf6
Show file tree

Hide file tree

Showing 83 changed files with 91 additions and 91 deletions.
diff --git a/docs/develop/custom-rules/walker-design.md b/docs/develop/custom-rules/walker-design.md
@@ -30,23 +30,23 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-// Here, the options object type is `void` because we don't pass any options in this example.
+// Here, the options object type is `void` (which is the default, so can be omitted) because we don't pass any options in this example.
 function walk(ctx: Lint.WalkContext<void>) {
     // Recursively walk the AST starting with root node, `ctx.sourceFile`.
     // Call the function `cb` (defined below) for each child.
     return ts.forEachChild(ctx.sourceFile, cb);
-    
+
     function cb(node: ts.Node): void {
         // Stop recursing further into the AST by returning early. Here, we ignore type nodes.
         if (node.kind >= ts.SyntaxKind.FirstTypeNode && node.kind <= ts.SyntaxKind.LastTypeNode) {
             return;
         }
-        
+
         // Add failures using the `WalkContext<T>` object. Here, we add a failure if we find the null keyword.
         if (node.kind === ts.SyntaxKind.NullKeyword) {
             return ctx.addFailureAtNode(node, Rule.FAILURE_STRING);
         }
-        
+
         // Continue recursion into the AST by calling function `cb` for every child of the current node.
         return ts.forEachChild(node, cb);
     }
@@ -90,7 +90,7 @@ class NoMagicNumbersWalker extends Lint.AbstractWalker<Set<string>> {
                 return ts.forEachChild(node, cb);
             }
         };
-        
+
         // Start recursion for all children of `sourceFile`.
         return ts.forEachChild(sourceFile, cb);
     }
@@ -108,7 +108,7 @@ class NoMagicNumbersWalker extends Lint.AbstractWalker<Set<string>> {
 ## Migrating from RuleWalker to AbstractWalker
 
 The main difference between `RuleWalker` and `AbstractWalker` is that you need to implement the AST recursion yourself. But why would you want to do that?
-__Performance!__ `RuleWalker` wants to be "one walker to rule them all" (pun intended). It's easy to use but that convenience 
+__Performance!__ `RuleWalker` wants to be "one walker to rule them all" (pun intended). It's easy to use but that convenience
 makes it slow by default. When implementing the walking yourself, you only need to do as much work as needed.
 
 Besides that you *should* convert the `ruleArguments` to a useful format before passing it to `AbstractWalker` as seen above.
@@ -125,8 +125,8 @@ This table describes the equivalent methods between the two classes:
 `this.appendText()` | `Lint.Replacement.appendText()`
 `this.hasOption()` and `this.getOptions()` | use `this.options` directly
 `this.getLineAndCharacterOfPosition()` | `ts.getLineAndCharacterOfPosition(this.sourceFile, ...)`
-`this.getLimit()` | `this.sourceFile.end` 
-`this.getSourceFile()` | is available to be compatible, but prefer `this.sourceFile` 
+`this.getLimit()` | `this.sourceFile.end`
+`this.getSourceFile()` | is available to be compatible, but prefer `this.sourceFile`
 `this.getFailures()` | is available to be compatible, but prefer `this.failures`
 `this.skip()` | just don't use it, it's a noop
 `this.getRuleName()` | `this.ruleName`
diff --git a/src/language/rule/abstractRule.ts b/src/language/rule/abstractRule.ts
@@ -52,7 +52,7 @@ export abstract class AbstractRule implements IRule {
 
     protected applyWithFunction(
         sourceFile: ts.SourceFile,
-        walkFn: (ctx: WalkContext<void>) => void,
+        walkFn: (ctx: WalkContext) => void,
     ): RuleFailure[];
     protected applyWithFunction<T>(
         sourceFile: ts.SourceFile,

diff --git a/src/language/walker/scopeAwareRuleWalker.ts b/src/language/walker/scopeAwareRuleWalker.ts
@@ -27,7 +27,7 @@ import { RuleWalker } from "./ruleWalker";
  *
  * For example, imagine a `no-break` rule that warns on `break` in `for` but not in `switch`:
  *
- * function walk(ctx: Lint.WalkContext<void>): void {
+ * function walk(ctx: Lint.WalkContext): void {
  *     let isInFor = false;
  *     ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
  *         switch (node.kind) {

diff --git 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<T> {
+export class WalkContext<T = void> {
     public readonly failures: RuleFailure[] = [];
 
     constructor(

diff --git 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<T> extends WalkContext<T> implements IWalker {
+export abstract class AbstractWalker<T = void> extends WalkContext<T> implements IWalker {
     public abstract walk(sourceFile: ts.SourceFile): void;
 
     public getSourceFile() {

diff --git a/src/rules/adjacentOverloadSignaturesRule.ts b/src/rules/adjacentOverloadSignaturesRule.ts
@@ -44,7 +44,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     const { sourceFile } = ctx;
     visitStatements(sourceFile.statements);
     return ts.forEachChild(sourceFile, function cb(node: ts.Node): void {

diff --git a/src/rules/banCommaOperatorRule.ts b/src/rules/banCommaOperatorRule.ts
@@ -64,7 +64,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (
             isBinaryExpression(node) &&

diff --git a/src/rules/banTsIgnoreRule.ts b/src/rules/banTsIgnoreRule.ts
@@ -44,7 +44,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     const ignoreDiagnosticCommentRegEx = /^\s*\/\/\/?\s*@ts-ignore/;
     forEachComment(ctx.sourceFile, (fullText, comment) => {
         const commentText = fullText.slice(comment.pos, comment.end);

diff --git a/src/rules/binaryExpressionOperandOrderRule.ts b/src/rules/binaryExpressionOperandOrderRule.ts
@@ -50,7 +50,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     ts.forEachChild(ctx.sourceFile, function cb(node) {
         if (
             isBinaryExpression(node) &&

diff --git a/src/rules/callableTypesRule.ts b/src/rules/callableTypesRule.ts
@@ -51,7 +51,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (
             ((isInterfaceDeclaration(node) && noSupertype(node)) || isTypeLiteralNode(node)) &&

diff --git a/src/rules/classNameRule.ts b/src/rules/classNameRule.ts
@@ -50,7 +50,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (
             (isClassLikeDeclaration(node) && node.name !== undefined) ||

diff --git a/src/rules/curlyRule.ts b/src/rules/curlyRule.ts
@@ -86,7 +86,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walkAsNeeded(ctx: Lint.WalkContext<void>): void {
+function walkAsNeeded(ctx: Lint.WalkContext): void {
     ts.forEachChild(ctx.sourceFile, function cb(node) {
         if (isBlock(node) && isBlockUnnecessary(node)) {
             ctx.addFailureAt(node.statements.pos - 1, 1, Rule.FAILURE_STRING_AS_NEEDED);

diff --git a/src/rules/deprecationRule.ts b/src/rules/deprecationRule.ts
@@ -62,7 +62,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>, tc: ts.TypeChecker) {
+function walk(ctx: Lint.WalkContext, tc: ts.TypeChecker) {
     return ts.forEachChild(ctx.sourceFile, function cb(node): void {
         if (isIdentifier(node)) {
             if (!isDeclaration(node)) {

diff --git a/src/rules/encodingRule.ts b/src/rules/encodingRule.ts
@@ -43,7 +43,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     const encoding = detectEncoding(ctx.sourceFile.fileName);
     if (encoding !== "utf8") {
         ctx.addFailure(0, 1, Rule.FAILURE_STRING(encoding));

diff --git a/src/rules/forinRule.ts b/src/rules/forinRule.ts
@@ -58,7 +58,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node): void {
         if (isForInStatement(node) && isBlock(node.statement) && !isFiltered(node.statement)) {
             ctx.addFailureAtNode(node, Rule.FAILURE_STRING);

diff --git a/src/rules/functionConstructorRule.ts b/src/rules/functionConstructorRule.ts
@@ -49,7 +49,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(context: Lint.WalkContext<void>): void {
+function walk(context: Lint.WalkContext): void {
     ts.forEachChild(context.sourceFile, function cb(node): void {
         if (isFunctionCallOrNewExpression(node)) {
             addFailureAtNode(node);

diff --git a/src/rules/importSpacingRule.ts b/src/rules/importSpacingRule.ts
@@ -49,7 +49,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-class Walker extends Lint.AbstractWalker<void> {
+class Walker extends Lint.AbstractWalker {
     public walk({ statements }: ts.SourceFile): void {
         for (const statement of statements) {
             if (!isImportDeclaration(statement)) {

diff --git a/src/rules/interfaceOverTypeLiteralRule.ts b/src/rules/interfaceOverTypeLiteralRule.ts
@@ -43,7 +43,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (isTypeAliasDeclaration(node) && isTypeLiteralNode(node.type)) {
             const typeKeyword = getChildOfKind(node, ts.SyntaxKind.TypeKeyword, ctx.sourceFile)!;

diff --git a/src/rules/labelPositionRule.ts b/src/rules/labelPositionRule.ts
@@ -46,7 +46,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (isLabeledStatement(node) && !isLabelable(node.statement)) {
             ctx.addFailureAtNode(node.label, Rule.FAILURE_STRING);

diff --git a/src/rules/matchDefaultExportNameRule.ts b/src/rules/matchDefaultExportNameRule.ts
@@ -45,7 +45,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>, tc: ts.TypeChecker) {
+function walk(ctx: Lint.WalkContext, tc: ts.TypeChecker) {
     for (const statement of ctx.sourceFile.statements) {
         if (
             !isImportDeclaration(statement) ||

diff --git a/src/rules/newParensRule.ts b/src/rules/newParensRule.ts
@@ -40,7 +40,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (
             node.kind === ts.SyntaxKind.NewExpression &&

diff --git a/src/rules/newlineBeforeReturnRule.ts b/src/rules/newlineBeforeReturnRule.ts
@@ -45,7 +45,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-class NewlineBeforeReturnWalker extends Lint.AbstractWalker<void> {
+class NewlineBeforeReturnWalker extends Lint.AbstractWalker {
     public walk(sourceFile: ts.SourceFile) {
         const cb = (node: ts.Node): void => {
             if (node.kind === ts.SyntaxKind.ReturnStatement) {

diff --git a/src/rules/newlinePerChainedCallRule.ts b/src/rules/newlinePerChainedCallRule.ts
@@ -48,7 +48,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-class NewlinePerChainedCallWalker extends Lint.AbstractWalker<void> {
+class NewlinePerChainedCallWalker extends Lint.AbstractWalker {
     public walk(sourceFile: ts.SourceFile) {
         const checkForSameLine = (node: ts.Node): void => {
             if (

diff --git a/src/rules/noAngleBracketTypeAssertionRule.ts b/src/rules/noAngleBracketTypeAssertionRule.ts
@@ -46,7 +46,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (isTypeAssertion(node)) {
             let { expression } = node;

diff --git a/src/rules/noAnyRule.ts b/src/rules/noAnyRule.ts
@@ -55,7 +55,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (node.kind === ts.SyntaxKind.AnyKeyword) {
             const start = node.end - 3;

diff --git a/src/rules/noArgRule.ts b/src/rules/noArgRule.ts
@@ -44,7 +44,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (
             isPropertyAccessExpression(node) &&

diff --git a/src/rules/noBitwiseRule.ts b/src/rules/noBitwiseRule.ts
@@ -48,7 +48,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (node.kind === ts.SyntaxKind.BinaryExpression) {
             switch ((node as ts.BinaryExpression).operatorToken.kind) {

diff --git a/src/rules/noBooleanLiteralCompareRule.ts b/src/rules/noBooleanLiteralCompareRule.ts
@@ -50,7 +50,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>, checker: ts.TypeChecker): void {
+function walk(ctx: Lint.WalkContext, checker: ts.TypeChecker): void {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (utils.isBinaryExpression(node)) {
             const cmp = getBooleanComparison(node, checker);

diff --git a/src/rules/noConditionalAssignmentRule.ts b/src/rules/noConditionalAssignmentRule.ts
@@ -46,7 +46,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     let checking = 0;
     return ts.forEachChild(ctx.sourceFile, cb);
 

diff --git a/src/rules/noConstructRule.ts b/src/rules/noConstructRule.ts
@@ -47,7 +47,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (isNewExpression(node) && node.expression.kind === ts.SyntaxKind.Identifier) {
             switch ((node.expression as ts.Identifier).text) {

diff --git a/src/rules/noDebuggerRule.ts b/src/rules/noDebuggerRule.ts
@@ -40,7 +40,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (node.kind === ts.SyntaxKind.DebuggerStatement) {
             return ctx.addFailureAtNode(node, Rule.FAILURE_STRING);

diff --git a/src/rules/noDefaultExportRule.ts b/src/rules/noDefaultExportRule.ts
@@ -44,7 +44,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     if (ctx.sourceFile.isDeclarationFile || !ts.isExternalModule(ctx.sourceFile)) {
         return;
     }

diff --git a/src/rules/noDuplicateSuperRule.ts b/src/rules/noDuplicateSuperRule.ts
@@ -43,7 +43,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (isConstructorDeclaration(node) && node.body !== undefined) {
             getSuperForNode(node.body);

diff --git a/src/rules/noDuplicateSwitchCaseRule.ts b/src/rules/noDuplicateSwitchCaseRule.ts
@@ -38,7 +38,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (node.kind === ts.SyntaxKind.CaseBlock) {
             visitCaseBlock(node as ts.CaseBlock);

diff --git a/src/rules/noDynamicDeleteRule.ts b/src/rules/noDynamicDeleteRule.ts
@@ -46,7 +46,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(context: Lint.WalkContext<void>) {
+function walk(context: Lint.WalkContext) {
     function checkDeleteAccessExpression(node: ts.Expression | undefined): void {
         if (node === undefined || !tsutils.isElementAccessExpression(node)) {
             return;

diff --git a/src/rules/noEmptyInterfaceRule.ts b/src/rules/noEmptyInterfaceRule.ts
@@ -45,7 +45,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (
             isInterfaceDeclaration(node) &&

diff --git a/src/rules/noEvalRule.ts b/src/rules/noEvalRule.ts
@@ -44,7 +44,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>) {
+function walk(ctx: Lint.WalkContext) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (
             isCallExpression(node) &&

diff --git a/src/rules/noForInArrayRule.ts b/src/rules/noForInArrayRule.ts
@@ -55,7 +55,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>, checker: ts.TypeChecker) {
+function walk(ctx: Lint.WalkContext, checker: ts.TypeChecker) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (node.kind === ts.SyntaxKind.ForInStatement) {
             const type = checker.getTypeAtLocation((node as ts.ForInStatement).expression);

diff --git a/src/rules/noInferredEmptyObjectTypeRule.ts b/src/rules/noInferredEmptyObjectTypeRule.ts
@@ -52,7 +52,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 }
 
-class NoInferredEmptyObjectTypeRule extends Lint.AbstractWalker<void> {
+class NoInferredEmptyObjectTypeRule extends Lint.AbstractWalker {
     constructor(
         sourceFile: ts.SourceFile,
         ruleName: string,