convert no-unnecessary-bind rule to use a walk function

src/noUnnecessaryBindRule.ts

@@ -1,5 +1,6 @@
 import * as ts from 'typescript';
 import * as Lint from 'tslint';
+import * as tsutils from 'tsutils';
 
 import { AstUtils } from './utils/AstUtils';
 import { ExtendedMetadata } from './utils/ExtendedMetadata';
@@ -56,46 +57,48 @@ export class Rule extends Lint.Rules.AbstractRule {
 
     public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
         if (Rule.isWarningShown === false) {
-            console.warn(
-                'Warning: no-unnecessary-bind rule is deprecated. Replace your usage with the TSLint unnecessary-bind rule.'
-            );
+            console.warn('Warning: no-unnecessary-bind rule is deprecated. Replace your usage with the TSLint unnecessary-bind rule.');
             Rule.isWarningShown = true;
         }
 
-        return this.applyWithWalker(new NoUnnecessaryBindRuleWalker(sourceFile, this.getOptions()));
+        return this.applyWithFunction(sourceFile, walk);
     }
 }
 
-class NoUnnecessaryBindRuleWalker extends Lint.RuleWalker {
-    protected visitCallExpression(node: ts.CallExpression): void {
-        const analyzers: CallAnalyzer[] = [
-            new TypeScriptFunctionAnalyzer(),
-            new UnderscoreStaticAnalyzer(),
-            new UnderscoreInstanceAnalyzer()
-        ];
-
-        analyzers.forEach(
-            (analyzer: CallAnalyzer): void => {
-                if (analyzer.canHandle(node)) {
-                    const contextArgument = analyzer.getContextArgument(node);
-                    const functionArgument = analyzer.getFunctionArgument(node);
-                    if (contextArgument === undefined || functionArgument === undefined) {
-                        return;
-                    }
-                    if (contextArgument.getText() === 'this') {
-                        if (isArrowFunction(functionArgument)) {
-                            this.addFailureAt(node.getStart(), node.getWidth(), Rule.FAILURE_ARROW_WITH_BIND);
-                        } else if (isFunctionLiteral(functionArgument)) {
-                            this.addFailureAt(node.getStart(), node.getWidth(), Rule.FAILURE_FUNCTION_WITH_BIND);
+function walk(ctx: Lint.WalkContext<void>) {
+    function cb(node: ts.Node): void {
+        if (tsutils.isCallExpression(node)) {
+            const analyzers: CallAnalyzer[] = [
+                new TypeScriptFunctionAnalyzer(),
+                new UnderscoreStaticAnalyzer(),
+                new UnderscoreInstanceAnalyzer()
+            ];
+
+            analyzers.forEach(
+                (analyzer: CallAnalyzer): void => {
+                    if (analyzer.canHandle(node)) {
+                        const contextArgument = analyzer.getContextArgument(node);
+                        const functionArgument = analyzer.getFunctionArgument(node);
+                        if (contextArgument === undefined || functionArgument === undefined) {
+                            return;
+                        }
+                        if (contextArgument.getText() === 'this') {
+                            if (isArrowFunction(functionArgument)) {
+                                ctx.addFailureAt(node.getStart(), node.getWidth(), Rule.FAILURE_ARROW_WITH_BIND);
+                            } else if (isFunctionLiteral(functionArgument)) {
+                                ctx.addFailureAt(node.getStart(), node.getWidth(), Rule.FAILURE_FUNCTION_WITH_BIND);
+                            }
                         }
                     }
                 }
-            }
-        );
-        super.visitCallExpression(node);
+            );
+        }
+
+        return ts.forEachChild(node, cb);
     }
-}
 
+    return ts.forEachChild(ctx.sourceFile, cb);
+}
 interface CallAnalyzer {
     canHandle(node: ts.CallExpression): boolean;
     getContextArgument(node: ts.CallExpression): ts.Expression | undefined;