Really fix type parameter of applyWithFunction

src/language/rule/abstractRule.ts

@@ -20,6 +20,8 @@ import * as ts from "typescript";
 import { IWalker, WalkContext } from "../walker";
 import { IOptions, IRule, IRuleMetadata, RuleFailure, RuleSeverity } from "./rule";
 
+export type NoInfer<T> = T & {[K in keyof T]: T[K]};
+
 export abstract class AbstractRule implements IRule {
     public static metadata: IRuleMetadata;
     protected readonly ruleArguments: any[];
@@ -48,16 +50,8 @@ export abstract class AbstractRule implements IRule {
     }
 
     protected applyWithFunction(sourceFile: ts.SourceFile, walkFn: (ctx: WalkContext<void>) => void): RuleFailure[];
-    protected applyWithFunction<T, U extends T>(
-        sourceFile: ts.SourceFile,
-        walkFn: (ctx: WalkContext<T>) => void,
-        options: U,
-    ): RuleFailure[];
-    protected applyWithFunction<T, U extends T>(
-        sourceFile: ts.SourceFile,
-        walkFn: (ctx: WalkContext<T | void>) => void,
-        options?: U,
-    ): RuleFailure[] {
+    protected applyWithFunction<T>(sourceFile: ts.SourceFile, walkFn: (ctx: WalkContext<T>) => void, options: NoInfer<T>): RuleFailure[];
+    protected applyWithFunction<T>(sourceFile: ts.SourceFile, walkFn: (ctx: WalkContext<T | void>) => void, options?: T): RuleFailure[] {
         const ctx = new WalkContext(sourceFile, this.ruleName, options);
         walkFn(ctx);
         return ctx.failures;

src/rules/arrayTypeRule.ts

@@ -52,7 +52,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     public static FAILURE_STRING_GENERIC_SIMPLE = "Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.";
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, this.ruleArguments[0]);
+        return this.applyWithFunction(sourceFile, walk, this.ruleArguments[0] as Option);
     }
 }
 

src/rules/deprecationRule.ts

@@ -44,7 +44,7 @@ export class Rule extends Lint.Rules.TypedRule {
     }
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, (ctx: Lint.WalkContext<void>) => walk(ctx, program.getTypeChecker()));
+        return this.applyWithFunction(sourceFile, (ctx) => walk(ctx, program.getTypeChecker()));
     }
 }
 

src/rules/maxLineLengthRule.ts

@@ -49,7 +49,7 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, walk, this.ruleArguments[0]);
+        return this.applyWithFunction(sourceFile, walk, this.ruleArguments[0] as number);
     }
 }
 

src/rules/noFloatingPromisesRule.ts

@@ -49,7 +49,7 @@ export class Rule extends Lint.Rules.TypedRule {
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
         return this.applyWithFunction(
             sourceFile,
-            (ctx: Lint.WalkContext<string[]>) => walk(ctx, program.getTypeChecker()),
+            (ctx) => walk(ctx, program.getTypeChecker()),
             ["Promise", ...this.ruleArguments as string[]],
         );
     }

src/rules/noUnboundMethodRule.ts

@@ -45,7 +45,7 @@ export class Rule extends Lint.Rules.TypedRule {
     public static FAILURE_STRING = "Avoid referencing unbound methods which may cause unintentional scoping of 'this'.";
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, (ctx: Lint.WalkContext<Options>) => walk(ctx, program.getTypeChecker()), {
+        return this.applyWithFunction(sourceFile, (ctx) => walk(ctx, program.getTypeChecker()), {
             ignoreStatic: this.ruleArguments.indexOf(OPTION_IGNORE_STATIC) !== -1,
         });
     }

src/rules/noVoidExpressionRule.ts

@@ -49,7 +49,7 @@ export class Rule extends Lint.Rules.TypedRule {
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
         const ignoreArrowFunctionShorthand = this.ruleArguments.indexOf(OPTION_IGNORE_ARROW_FUNCTION_SHORTHAND) !== -1;
-        return this.applyWithFunction<Options, Options>(
+        return this.applyWithFunction(
             sourceFile, (ctx) => walk(ctx, program.getTypeChecker()), { ignoreArrowFunctionShorthand });
     }
 }

src/rules/objectLiteralSortKeysRule.ts

@@ -77,7 +77,7 @@ export class Rule extends Lint.Rules.OptionallyTypedRule {
     }
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction<Options, Options>(
+        return this.applyWithFunction(
             sourceFile,
             (ctx) => walk(ctx, program.getTypeChecker()),
             parseOptions(this.ruleArguments),

src/rules/promiseFunctionAsyncRule.ts

@@ -42,7 +42,7 @@ export class Rule extends Lint.Rules.TypedRule {
     public static FAILURE_STRING = "functions that return promises must be async";
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
-        return this.applyWithFunction(sourceFile, (ctx: Lint.WalkContext<void>) => walk(ctx, program.getTypeChecker()));
+        return this.applyWithFunction(sourceFile, (ctx) => walk(ctx, program.getTypeChecker()));
     }
 }
 

src/rules/strictBooleanExpressionsRule.ts

@@ -88,7 +88,7 @@ export class Rule extends Lint.Rules.TypedRule {
 
     public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
         const options = parseOptions(this.ruleArguments, Lint.isStrictNullChecksEnabled(program.getCompilerOptions()));
-        return this.applyWithFunction(sourceFile, (ctx: Lint.WalkContext<Options>) => walk(ctx, program.getTypeChecker()), options);
+        return this.applyWithFunction(sourceFile, (ctx) => walk(ctx, program.getTypeChecker()), options);
     }
 }