Default type parameter of WalkContext and AbstractWalker to void

src/language/rule/abstractRule.ts

@@ -48,7 +48,7 @@ export abstract class AbstractRule implements IRule {
         return this.ruleSeverity !== "off";
     }
 
-    protected applyWithFunction(sourceFile: ts.SourceFile, walkFn: (ctx: WalkContext<void>) => void): RuleFailure[];
+    protected applyWithFunction(sourceFile: ts.SourceFile, walkFn: (ctx: WalkContext) => void): RuleFailure[];
     protected applyWithFunction<T, U extends T>(
         sourceFile: ts.SourceFile,
         walkFn: (ctx: WalkContext<T>) => void,

src/language/walker/scopeAwareRuleWalker.ts

@@ -26,7 +26,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) {

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(public readonly sourceFile: ts.SourceFile, public readonly ruleName: string, public readonly options: T) {}

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() {

src/rules/adjacentOverloadSignaturesRule.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 { sourceFile } = ctx;
     visitStatements(sourceFile.statements);
     return ts.forEachChild(sourceFile, function cb(node: ts.Node): void {

src/rules/callableTypesRule.ts

@@ -43,7 +43,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))

src/rules/classNameRule.ts

@@ -42,7 +42,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 ||
             isInterfaceDeclaration(node)) {

src/rules/interfaceOverTypeLiteralRule.ts

@@ -40,7 +40,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) && node.type.kind === ts.SyntaxKind.TypeLiteral) {
             ctx.addFailureAtNode(node.name, Rule.FAILURE_STRING);

src/rules/labelPositionRule.ts

@@ -45,7 +45,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);

src/rules/memberAccessRule.ts

@@ -73,7 +73,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>, noPublic: boolean, checkAccessor: boolean, checkConstructor: boolean) {
+function walk(ctx: Lint.WalkContext, noPublic: boolean, checkAccessor: boolean, checkConstructor: boolean) {
     return ts.forEachChild(ctx.sourceFile, function recur(node: ts.Node): void {
         if (isClassLikeDeclaration(node)) {
             for (const child of node.members) {

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 && (node as ts.NewExpression).arguments === undefined) {
             ctx.addFailureAtNode(node, Rule.FAILURE_STRING);

src/rules/newlineBeforeReturnRule.ts

@@ -40,7 +40,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) {

src/rules/noAngleBracketTypeAssertionRule.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 (isTypeAssertion(node)) {
             const start = node.getStart(ctx.sourceFile);

src/rules/noAnyRule.ts

@@ -43,7 +43,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;

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) &&
             node.name.text === "callee" &&

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) {

src/rules/noBooleanLiteralCompareRule.ts

@@ -44,7 +44,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);

src/rules/noConstructRule.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 (isNewExpression(node) && node.expression.kind === ts.SyntaxKind.Identifier) {
             switch ((node.expression as ts.Identifier).text) {

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);

src/rules/noDuplicateSuperRule.ts

@@ -42,7 +42,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) {
            getSuperForNode(node.body);

src/rules/noDuplicateVariableRule.ts

@@ -48,7 +48,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     let scope = new Set<string>();
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (utils.isFunctionScopeBoundary(node)) {

src/rules/noEmptyInterfaceRule.ts

@@ -41,7 +41,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) &&
             node.members.length === 0 &&

src/rules/noEmptyRule.ts

@@ -42,7 +42,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.Block &&
             (node as ts.Block).statements.length === 0 &&

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) &&
             node.expression.kind === ts.SyntaxKind.Identifier && (node.expression as ts.Identifier).text === "eval") {

src/rules/noForInArrayRule.ts

@@ -54,7 +54,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>, program: ts.Program) {
+function walk(ctx: Lint.WalkContext, program: ts.Program) {
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (node.kind === ts.SyntaxKind.ForInStatement) {
             const type = program.getTypeChecker().getTypeAtLocation((node as ts.ForInStatement).expression);

src/rules/noInternalModuleRule.ts

@@ -41,7 +41,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-class NoInternalModuleWalker extends Lint.AbstractWalker<void> {
+class NoInternalModuleWalker extends Lint.AbstractWalker {
     public walk(sourceFile: ts.SourceFile) {
         return this.checkStatements(sourceFile.statements);
     }

src/rules/noInvalidTemplateStringsRule.ts

@@ -41,7 +41,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 (utils.isStringLiteral(node)) {
             check(node);

src/rules/noIrregularWhitespaceRule.ts

@@ -45,7 +45,7 @@ export class Rule extends Lint.Rules.AbstractRule {
 export const IRREGULAR_WHITESPACE_REGEX = /[\u000b\u000c\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]+/mg;
 /* tslint:enable:max-line-length */
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     IRREGULAR_WHITESPACE_REGEX.lastIndex = 0;
     let match: RegExpExecArray | null;
     // tslint:disable-next-line no-conditional-assignment

src/rules/noMisusedNewRule.ts

@@ -41,7 +41,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 (isMethodSignature(node)) {
             if (getPropertyName(node.name) === "constructor") {

src/rules/noNullKeywordRule.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, cb);
     function cb(node: ts.Node): void {
         if (node.kind >= ts.SyntaxKind.FirstTypeNode && node.kind <= ts.SyntaxKind.LastTypeNode) {

src/rules/noObjectLiteralTypeAssertionRule.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 (isTypeAssertionLike(node) && isObjectLiteral(node.expression)) {
             ctx.addFailureAtNode(node, Rule.FAILURE_STRING);

src/rules/noReferenceImportRule.ts

@@ -41,7 +41,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     const { sourceFile } = ctx;
     if (sourceFile.typeReferenceDirectives.length === 0) {
         return;

src/rules/noReferenceRule.ts

@@ -42,7 +42,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     for (const ref of ctx.sourceFile.referencedFiles) {
         ctx.addFailure(ref.pos, ref.end, Rule.FAILURE_STRING);
     }

src/rules/noSparseArraysRule.ts

@@ -41,7 +41,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 (!utils.isArrayLiteralExpression(node)) {
             if (utils.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {

src/rules/noStringLiteralRule.ts

@@ -42,7 +42,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 (isElementAccessExpression(node)) {
             const argument = node.argumentExpression;

src/rules/noStringThrowRule.ts

@@ -42,7 +42,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     const { sourceFile } = ctx;
     return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         if (isThrowStatement(node)) {

src/rules/noSwitchCaseFallThroughRule.ts

@@ -66,7 +66,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-export class NoSwitchCaseFallThroughWalker extends Lint.AbstractWalker<void> {
+export class NoSwitchCaseFallThroughWalker extends Lint.AbstractWalker {
     public walk(sourceFile: ts.SourceFile) {
         const cb = (node: ts.Node): void => {
             if (node.kind === ts.SyntaxKind.SwitchStatement) {

src/rules/noUnnecessaryCallbackWrapperRule.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, cb);
     function cb(node: ts.Node): void {
         if (isArrowFunction(node) && !hasModifier(node.modifiers, ts.SyntaxKind.AsyncKeyword) &&

src/rules/noUnnecessaryTypeAssertionRule.ts

@@ -39,7 +39,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 }
 
-class Walker extends Lint.AbstractWalker<void> {
+class Walker extends Lint.AbstractWalker {
     constructor(sourceFile: ts.SourceFile, ruleName: string, private readonly checker: ts.TypeChecker) {
         super(sourceFile, ruleName, undefined);
     }

src/rules/noUnsafeAnyRule.ts

@@ -43,7 +43,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 {
     if (ctx.sourceFile.isDeclarationFile) {
         // Not possible in a declaration file.
         return;

src/rules/noUnsafeFinallyRule.ts

@@ -52,7 +52,7 @@ export class Rule extends Lint.Rules.AbstractRule {
 
 type JumpStatement = ts.BreakStatement | ts.ContinueStatement | ts.ThrowStatement | ts.ReturnStatement;
 
-function walk(ctx: Lint.WalkContext<void>): void {
+function walk(ctx: Lint.WalkContext): void {
     let inFinally = false;
     ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
         switch (node.kind) {

src/rules/noUnusedVariableRule.ts

@@ -96,7 +96,7 @@ function parseOptions(options: any[]): Options {
     return { checkParameters, ignorePattern };
 }
 
-function walk(ctx: Lint.WalkContext<void>, program: ts.Program, { checkParameters, ignorePattern }: Options): void {
+function walk(ctx: Lint.WalkContext, program: ts.Program, { checkParameters, ignorePattern }: Options): void {
     const { sourceFile } = ctx;
     const unusedCheckedProgram = getUnusedCheckedProgram(program, checkParameters);
     const diagnostics = ts.getPreEmitDiagnostics(unusedCheckedProgram, sourceFile);
@@ -148,7 +148,7 @@ function walk(ctx: Lint.WalkContext<void>, program: ts.Program, { checkParameter
  * - If all of the import specifiers in an import are unused, add a combined failure for them all.
  * - Unused imports are fixable.
  */
-function addImportSpecifierFailures(ctx: Lint.WalkContext<void>, failures: Map<ts.Identifier, string>, sourceFile: ts.SourceFile) {
+function addImportSpecifierFailures(ctx: Lint.WalkContext, failures: Map<ts.Identifier, string>, sourceFile: ts.SourceFile) {
     forEachImport(sourceFile, (importNode) => {
         if (importNode.kind === ts.SyntaxKind.ImportEqualsDeclaration) {
             tryRemoveAll(importNode.name);

src/rules/noUseBeforeDeclareRule.ts

@@ -45,7 +45,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 recur(node: ts.Node): void {
         switch (node.kind) {
             case ts.SyntaxKind.TypeReference: