upgrade dependencies

1 files changed, 69 insertions, 50 deletions

diff --git a/node_modules/tslint/lib/rules/noConditionalAssignmentRule.js b/node_modules/tslint/lib/rules/noConditionalAssignmentRule.js
index f437d1a63..30e77aa84 100644
--- a/node_modules/tslint/lib/rules/noConditionalAssignmentRule.js
+++ b/node_modules/tslint/lib/rules/noConditionalAssignmentRule.js
@@ -17,6 +17,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
+var tsutils_1 = require("tsutils");
 var ts = require("typescript");
 var Lint = require("../index");
 var Rule = /** @class */ (function (_super) {
@@ -25,14 +26,13 @@ var Rule = /** @class */ (function (_super) {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     Rule.prototype.apply = function (sourceFile) {
-        var walker = new NoConditionalAssignmentWalker(sourceFile, this.getOptions());
-        return this.applyWithWalker(walker);
+        return this.applyWithFunction(sourceFile, walk);
     };
     /* tslint:disable:object-literal-sort-keys */
     Rule.metadata = {
         ruleName: "no-conditional-assignment",
         description: "Disallows any type of assignment in conditionals.",
-        descriptionDetails: "This applies to `do-while`, `for`, `if`, and `while` statements.",
+        descriptionDetails: "This applies to `do-while`, `for`, `if`, and `while` statements and conditional (ternary) expressions.",
         rationale: (_a = ["\n            Assignments in conditionals are often typos:\n            for example `if (var1 = var2)` instead of `if (var1 == var2)`.\n            They also can be an indicator of overly clever code which decreases maintainability."], _a.raw = ["\n            Assignments in conditionals are often typos:\n            for example \\`if (var1 = var2)\\` instead of \\`if (var1 == var2)\\`.\n            They also can be an indicator of overly clever code which decreases maintainability."], Lint.Utils.dedent(_a)),
         optionsDescription: "Not configurable.",
         options: null,
@@ -45,55 +45,74 @@ var Rule = /** @class */ (function (_super) {
     return Rule;
 }(Lint.Rules.AbstractRule));
 exports.Rule = Rule;
-var NoConditionalAssignmentWalker = /** @class */ (function (_super) {
-    tslib_1.__extends(NoConditionalAssignmentWalker, _super);
-    function NoConditionalAssignmentWalker() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.isInConditional = false;
-        return _this;
-    }
-    NoConditionalAssignmentWalker.prototype.visitIfStatement = function (node) {
-        this.validateConditionalExpression(node.expression);
-        _super.prototype.visitIfStatement.call(this, node);
-    };
-    NoConditionalAssignmentWalker.prototype.visitWhileStatement = function (node) {
-        this.validateConditionalExpression(node.expression);
-        _super.prototype.visitWhileStatement.call(this, node);
-    };
-    NoConditionalAssignmentWalker.prototype.visitDoStatement = function (node) {
-        this.validateConditionalExpression(node.expression);
-        _super.prototype.visitDoStatement.call(this, node);
-    };
-    NoConditionalAssignmentWalker.prototype.visitForStatement = function (node) {
-        if (node.condition != null) {
-            this.validateConditionalExpression(node.condition);
+function walk(ctx) {
+    var checking = 0;
+    return ts.forEachChild(ctx.sourceFile, cb);
+    function cb(node) {
+        var kind = node.kind;
+        if (!tsutils_1.isNodeKind(kind)) {
+            return; // return early for tokens
         }
-        _super.prototype.visitForStatement.call(this, node);
-    };
-    NoConditionalAssignmentWalker.prototype.visitBinaryExpression = function (expression) {
-        if (this.isInConditional) {
-            this.checkForAssignment(expression);
-        }
-        _super.prototype.visitBinaryExpression.call(this, expression);
-    };
-    NoConditionalAssignmentWalker.prototype.validateConditionalExpression = function (expression) {
-        this.isInConditional = true;
-        if (expression.kind === ts.SyntaxKind.BinaryExpression) {
-            // check for simple assignment in a conditional, like `if (a = 1) {`
-            this.checkForAssignment(expression);
+        switch (kind) {
+            case ts.SyntaxKind.ConditionalExpression:
+                check(node.condition);
+                cb(node.whenTrue);
+                cb(node.whenFalse);
+                return;
+            case ts.SyntaxKind.IfStatement:
+                check(node.expression);
+                cb(node.thenStatement);
+                maybeCallback(cb, node.elseStatement);
+                return;
+            case ts.SyntaxKind.DoStatement:
+            case ts.SyntaxKind.WhileStatement:
+                check(node.expression);
+                cb(node.statement);
+                return;
+            case ts.SyntaxKind.ForStatement:
+                maybeCallback(cb, node.initializer);
+                maybeCallback(check, node.condition);
+                maybeCallback(cb, node.incrementor);
+                cb(node.statement);
+                return;
         }
-        // walk the children of the conditional expression for nested assignments, like `if ((a = 1) && (b == 1)) {`
-        this.walkChildren(expression);
-        this.isInConditional = false;
-    };
-    NoConditionalAssignmentWalker.prototype.checkForAssignment = function (expression) {
-        if (isAssignmentToken(expression.operatorToken)) {
-            this.addFailureAtNode(expression, Rule.FAILURE_STRING);
+        if (checking !== 0) {
+            switch (kind) {
+                case ts.SyntaxKind.BinaryExpression:
+                    if (tsutils_1.isAssignmentKind(node.operatorToken.kind)) {
+                        ctx.addFailureAtNode(node, Rule.FAILURE_STRING);
+                    }
+                    cb(node.left);
+                    cb(node.right);
+                    return;
+                case ts.SyntaxKind.ParenthesizedExpression:
+                case ts.SyntaxKind.NonNullExpression:
+                case ts.SyntaxKind.AsExpression:
+                case ts.SyntaxKind.TypeAssertionExpression:
+                    return cb(node.expression);
+                case ts.SyntaxKind.PrefixUnaryExpression:
+                    return cb(node.operand);
+                default:
+                    return noCheck(node);
+            }
         }
-    };
-    return NoConditionalAssignmentWalker;
-}(Lint.RuleWalker));
-function isAssignmentToken(token) {
-    return token.kind >= ts.SyntaxKind.FirstAssignment && token.kind <= ts.SyntaxKind.LastAssignment;
+        return ts.forEachChild(node, cb);
+    }
+    function check(node) {
+        ++checking;
+        cb(node);
+        --checking;
+    }
+    function noCheck(node) {
+        var old = checking;
+        checking = 0;
+        ts.forEachChild(node, cb);
+        checking = old;
+    }
+}
+function maybeCallback(cb, node) {
+    if (node !== undefined) {
+        cb(node);
+    }
 }
 var _a;