add linting (and some initial fixes)

1 files changed, 232 insertions, 0 deletions

diff --git a/node_modules/tslint/lib/rules/semicolonRule.js b/node_modules/tslint/lib/rules/semicolonRule.js
new file mode 100644
index 000000000..747a2acd2
--- /dev/null
+++ b/node_modules/tslint/lib/rules/semicolonRule.js
@@ -0,0 +1,232 @@
+"use strict";
+/**
+ * @license
+ * Copyright 2013 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var utils = require("tsutils");
+var ts = require("typescript");
+var Lint = require("../index");
+var OPTION_ALWAYS = "always";
+var OPTION_NEVER = "never";
+var OPTION_IGNORE_BOUND_CLASS_METHODS = "ignore-bound-class-methods";
+var OPTION_IGNORE_INTERFACES = "ignore-interfaces";
+var Rule = (function (_super) {
+    tslib_1.__extends(Rule, _super);
+    function Rule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Rule.prototype.apply = function (sourceFile) {
+        var options = {
+            always: this.ruleArguments.indexOf(OPTION_NEVER) === -1,
+            boundClassMethods: this.ruleArguments.indexOf(OPTION_IGNORE_BOUND_CLASS_METHODS) === -1,
+            interfaces: this.ruleArguments.indexOf(OPTION_IGNORE_INTERFACES) === -1,
+        };
+        return this.applyWithWalker(new SemicolonWalker(sourceFile, this.ruleName, options));
+    };
+    return Rule;
+}(Lint.Rules.AbstractRule));
+/* tslint:disable:object-literal-sort-keys */
+Rule.metadata = {
+    ruleName: "semicolon",
+    description: "Enforces consistent semicolon usage at the end of every statement.",
+    hasFix: true,
+    optionsDescription: (_a = ["\n            One of the following arguments must be provided:\n\n            * `\"", "\"` enforces semicolons at the end of every statement.\n            * `\"", "\"` disallows semicolons at the end of every statement except for when they are necessary.\n\n            The following arguments may be optionally provided:\n\n            * `\"", "\"` skips checking semicolons at the end of interface members.\n            * `\"", "\"` skips checking semicolons at the end of bound class methods."], _a.raw = ["\n            One of the following arguments must be provided:\n\n            * \\`\"", "\"\\` enforces semicolons at the end of every statement.\n            * \\`\"", "\"\\` disallows semicolons at the end of every statement except for when they are necessary.\n\n            The following arguments may be optionally provided:\n\n            * \\`\"", "\"\\` skips checking semicolons at the end of interface members.\n            * \\`\"", "\"\\` skips checking semicolons at the end of bound class methods."], Lint.Utils.dedent(_a, OPTION_ALWAYS, OPTION_NEVER, OPTION_IGNORE_INTERFACES, OPTION_IGNORE_BOUND_CLASS_METHODS)),
+    options: {
+        type: "array",
+        items: [
+            {
+                type: "string",
+                enum: [OPTION_ALWAYS, OPTION_NEVER],
+            },
+            {
+                type: "string",
+                enum: [OPTION_IGNORE_INTERFACES],
+            },
+        ],
+        additionalItems: false,
+    },
+    optionExamples: [
+        [true, OPTION_ALWAYS],
+        [true, OPTION_NEVER],
+        [true, OPTION_ALWAYS, OPTION_IGNORE_INTERFACES],
+        [true, OPTION_ALWAYS, OPTION_IGNORE_BOUND_CLASS_METHODS],
+    ],
+    type: "style",
+    typescriptOnly: false,
+};
+/* tslint:enable:object-literal-sort-keys */
+Rule.FAILURE_STRING_MISSING = "Missing semicolon";
+Rule.FAILURE_STRING_COMMA = "Properties should be separated by semicolons";
+Rule.FAILURE_STRING_UNNECESSARY = "Unnecessary semicolon";
+exports.Rule = Rule;
+var SemicolonWalker = (function (_super) {
+    tslib_1.__extends(SemicolonWalker, _super);
+    function SemicolonWalker() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.scanner = undefined;
+        return _this;
+    }
+    SemicolonWalker.prototype.walk = function (sourceFile) {
+        var _this = this;
+        var cb = function (node) {
+            switch (node.kind) {
+                case ts.SyntaxKind.VariableStatement:
+                case ts.SyntaxKind.ExpressionStatement:
+                case ts.SyntaxKind.ReturnStatement:
+                case ts.SyntaxKind.BreakStatement:
+                case ts.SyntaxKind.ContinueStatement:
+                case ts.SyntaxKind.ThrowStatement:
+                case ts.SyntaxKind.ImportEqualsDeclaration:
+                case ts.SyntaxKind.DoStatement:
+                case ts.SyntaxKind.ExportAssignment:
+                    _this.checkSemicolonAt(node);
+                    break;
+                case ts.SyntaxKind.TypeAliasDeclaration:
+                case ts.SyntaxKind.ImportDeclaration:
+                case ts.SyntaxKind.ExportDeclaration:
+                case ts.SyntaxKind.DebuggerStatement:
+                    _this.checkSemicolonOrLineBreak(node);
+                    break;
+                case ts.SyntaxKind.ModuleDeclaration:
+                    // shorthand module declaration
+                    if (node.body === undefined) {
+                        _this.checkSemicolonOrLineBreak(node);
+                    }
+                    break;
+                case ts.SyntaxKind.PropertyDeclaration:
+                    _this.visitPropertyDeclaration(node);
+                    break;
+                case ts.SyntaxKind.MethodDeclaration:
+                case ts.SyntaxKind.FunctionDeclaration:
+                    if (node.body === undefined) {
+                        _this.checkSemicolonOrLineBreak(node);
+                    }
+                    break;
+                case ts.SyntaxKind.InterfaceDeclaration:
+                    if (_this.options.interfaces) {
+                        _this.checkInterface(node);
+                    }
+                    break;
+                case ts.SyntaxKind.SemicolonClassElement:
+                    return _this.reportUnnecessary(node.end - 1);
+                case ts.SyntaxKind.EmptyStatement:
+                    return _this.checkEmptyStatement(node);
+                default:
+            }
+            return ts.forEachChild(node, cb);
+        };
+        return ts.forEachChild(sourceFile, cb);
+    };
+    SemicolonWalker.prototype.visitPropertyDeclaration = function (node) {
+        // check if this is a multi-line arrow function
+        if (node.initializer !== undefined &&
+            node.initializer.kind === ts.SyntaxKind.ArrowFunction &&
+            !utils.isSameLine(this.sourceFile, node.getStart(this.sourceFile), node.end)) {
+            if (this.options.boundClassMethods) {
+                if (this.sourceFile.text[node.end - 1] === ";" &&
+                    this.isFollowedByLineBreak(node.end)) {
+                    this.reportUnnecessary(node.end - 1);
+                }
+            }
+        }
+        else {
+            this.checkSemicolonOrLineBreak(node);
+        }
+    };
+    SemicolonWalker.prototype.isFollowedByLineBreak = function (pos) {
+        var scanner = this.scanner !== undefined ? this.scanner :
+            (this.scanner = ts.createScanner(this.sourceFile.languageVersion, true, this.sourceFile.languageVariant, this.sourceFile.text));
+        scanner.setTextPos(pos);
+        return scanner.scan() === ts.SyntaxKind.EndOfFileToken || scanner.hasPrecedingLineBreak();
+    };
+    SemicolonWalker.prototype.checkSemicolonOrLineBreak = function (node) {
+        var hasSemicolon = this.sourceFile.text[node.end - 1] === ";";
+        if (this.options.always && !hasSemicolon) {
+            this.reportMissing(node.end);
+        }
+        else if (!this.options.always && hasSemicolon && this.isFollowedByLineBreak(node.end)) {
+            // semicolon can be removed if followed by line break;
+            this.reportUnnecessary(node.end - 1);
+        }
+    };
+    SemicolonWalker.prototype.checkEmptyStatement = function (node) {
+        // An empty statement is only ever useful when it is the only statement inside a loop
+        if (!utils.isIterationStatement(node.parent)) {
+            var parentKind = node.parent.kind;
+            // don't remove empty statement if it is a direct child of if, with or a LabeledStatement
+            // otherwise this would unintentionally change control flow
+            var noFix = parentKind === ts.SyntaxKind.IfStatement ||
+                parentKind === ts.SyntaxKind.LabeledStatement ||
+                parentKind === ts.SyntaxKind.WithStatement;
+            this.reportUnnecessary(node.end - 1, noFix);
+        }
+    };
+    SemicolonWalker.prototype.checkInterface = function (node) {
+        for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+            var member = _a[_i];
+            var lastChar = this.sourceFile.text[member.end - 1];
+            var hasSemicolon = lastChar === ";";
+            if (this.options.always && !hasSemicolon) {
+                if (lastChar === ",") {
+                    this.addFailureAt(member.end - 1, 1, Rule.FAILURE_STRING_COMMA, new Lint.Replacement(member.end - 1, 1, ";"));
+                }
+                else {
+                    this.reportMissing(member.end);
+                }
+            }
+            else if (!this.options.always && hasSemicolon &&
+                (member === node.members[node.members.length - 1] || this.isFollowedByLineBreak(member.end))) {
+                this.reportUnnecessary(member.end - 1);
+            }
+        }
+    };
+    SemicolonWalker.prototype.reportMissing = function (pos) {
+        this.addFailureAt(pos, 0, Rule.FAILURE_STRING_MISSING, Lint.Replacement.appendText(pos, ";"));
+    };
+    SemicolonWalker.prototype.reportUnnecessary = function (pos, noFix) {
+        this.addFailureAt(pos, 1, Rule.FAILURE_STRING_UNNECESSARY, noFix === true ? undefined : Lint.Replacement.deleteText(pos, 1));
+    };
+    SemicolonWalker.prototype.checkSemicolonAt = function (node) {
+        var hasSemicolon = this.sourceFile.text[node.end - 1] === ";";
+        if (this.options.always && !hasSemicolon) {
+            this.reportMissing(node.end);
+        }
+        else if (!this.options.always && hasSemicolon) {
+            switch (utils.getNextToken(node, this.sourceFile).kind) {
+                case ts.SyntaxKind.OpenParenToken:
+                case ts.SyntaxKind.OpenBracketToken:
+                case ts.SyntaxKind.PlusToken:
+                case ts.SyntaxKind.MinusToken:
+                case ts.SyntaxKind.RegularExpressionLiteral:
+                    break;
+                default:
+                    if (!this.isFollowedByStatement(node)) {
+                        this.reportUnnecessary(node.end - 1);
+                    }
+            }
+        }
+    };
+    SemicolonWalker.prototype.isFollowedByStatement = function (node) {
+        var nextStatement = utils.getNextStatement(node);
+        if (nextStatement === undefined) {
+            return false;
+        }
+        return utils.isSameLine(this.sourceFile, node.end, nextStatement.getStart(this.sourceFile));
+    };
+    return SemicolonWalker;
+}(Lint.AbstractWalker));
+var _a;