--- /dev/null
+"use strict";
+/**
+ * @license
+ * Copyright 2017 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 tsutils_1 = require("tsutils");
+var ts = require("typescript");
+var Lint = require("../index");
+var Rule = /** @class */ (function (_super) {
+ tslib_1.__extends(Rule, _super);
+ function Rule() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Rule.prototype.apply = function (sourceFile) {
+ return this.applyWithFunction(sourceFile, walk);
+ };
+ /* tslint:disable:object-literal-sort-keys */
+ Rule.metadata = {
+ ruleName: "no-duplicate-super",
+ description: "Warns if 'super()' appears twice in a constructor.",
+ rationale: "The second call to 'super()' will fail at runtime.",
+ optionsDescription: "Not configurable.",
+ options: null,
+ optionExamples: [true],
+ type: "functionality",
+ typescriptOnly: false,
+ };
+ /* tslint:enable:object-literal-sort-keys */
+ Rule.FAILURE_STRING_DUPLICATE = "Multiple calls to 'super()' found. It must be called only once.";
+ Rule.FAILURE_STRING_LOOP = "'super()' called in a loop. It must be called only once.";
+ return Rule;
+}(Lint.Rules.AbstractRule));
+exports.Rule = Rule;
+function walk(ctx) {
+ return ts.forEachChild(ctx.sourceFile, function cb(node) {
+ if (tsutils_1.isConstructorDeclaration(node) && node.body !== undefined) {
+ getSuperForNode(node.body);
+ }
+ return ts.forEachChild(node, cb);
+ });
+ function getSuperForNode(node) {
+ if (tsutils_1.isIterationStatement(node)) {
+ var bodySuper = combineSequentialChildren(node);
+ if (typeof bodySuper === "number") {
+ return 0 /* NoSuper */;
+ }
+ if (!bodySuper.break) {
+ ctx.addFailureAtNode(bodySuper.node, Rule.FAILURE_STRING_LOOP);
+ }
+ return tslib_1.__assign({}, bodySuper, { break: false });
+ }
+ switch (node.kind) {
+ case ts.SyntaxKind.ReturnStatement:
+ case ts.SyntaxKind.ThrowStatement:
+ return 1 /* Return */;
+ case ts.SyntaxKind.BreakStatement:
+ return 2 /* Break */;
+ case ts.SyntaxKind.ClassDeclaration:
+ case ts.SyntaxKind.ClassExpression:
+ // 'super()' is bound differently inside, so ignore.
+ return 0 /* NoSuper */;
+ case ts.SyntaxKind.SuperKeyword:
+ return node.parent.kind === ts.SyntaxKind.CallExpression &&
+ node.parent.expression === node
+ ? { node: node.parent, break: false }
+ : 0 /* NoSuper */;
+ case ts.SyntaxKind.ConditionalExpression: {
+ var _a = node, condition = _a.condition, whenTrue = _a.whenTrue, whenFalse = _a.whenFalse;
+ var inCondition = getSuperForNode(condition);
+ var inBranches = worse(getSuperForNode(whenTrue), getSuperForNode(whenFalse));
+ if (typeof inCondition !== "number" && typeof inBranches !== "number") {
+ addDuplicateFailure(inCondition.node, inBranches.node);
+ }
+ return worse(inCondition, inBranches);
+ }
+ case ts.SyntaxKind.IfStatement: {
+ var _b = node, thenStatement = _b.thenStatement, elseStatement = _b.elseStatement;
+ return worse(getSuperForNode(thenStatement), elseStatement !== undefined ? getSuperForNode(elseStatement) : 0 /* NoSuper */);
+ }
+ case ts.SyntaxKind.SwitchStatement:
+ return getSuperForSwitch(node);
+ default:
+ return combineSequentialChildren(node);
+ }
+ }
+ function getSuperForSwitch(node) {
+ // 'super()' from any clause. Used to track whether 'super()' happens in the switch at all.
+ var foundSingle;
+ // 'super()' from the previous clause if it did not 'break;'.
+ var fallthroughSingle;
+ for (var _i = 0, _a = node.caseBlock.clauses; _i < _a.length; _i++) {
+ var clause = _a[_i];
+ var clauseSuper = combineSequentialChildren(clause);
+ switch (clauseSuper) {
+ case 0 /* NoSuper */:
+ break;
+ case 2 /* Break */:
+ fallthroughSingle = undefined;
+ break;
+ case 1 /* Return */:
+ return 0 /* NoSuper */;
+ default:
+ if (fallthroughSingle !== undefined) {
+ addDuplicateFailure(fallthroughSingle, clauseSuper.node);
+ }
+ if (!clauseSuper.break) {
+ fallthroughSingle = clauseSuper.node;
+ }
+ foundSingle = clauseSuper.node;
+ }
+ }
+ return foundSingle !== undefined ? { node: foundSingle, break: false } : 0 /* NoSuper */;
+ }
+ /**
+ * Combines children that come one after another.
+ * (As opposed to if/else, switch, or loops, which need their own handling.)
+ */
+ function combineSequentialChildren(node) {
+ var seenSingle;
+ var res = ts.forEachChild(node, function (child) {
+ var childSuper = getSuperForNode(child);
+ switch (childSuper) {
+ case 0 /* NoSuper */:
+ return undefined;
+ case 2 /* Break */:
+ if (seenSingle !== undefined) {
+ return tslib_1.__assign({}, seenSingle, { break: true });
+ }
+ return childSuper;
+ case 1 /* Return */:
+ return childSuper;
+ default:
+ if (seenSingle !== undefined && !seenSingle.break) {
+ addDuplicateFailure(seenSingle.node, childSuper.node);
+ }
+ seenSingle = childSuper;
+ return undefined;
+ }
+ });
+ return res !== undefined ? res : seenSingle !== undefined ? seenSingle : 0 /* NoSuper */;
+ }
+ function addDuplicateFailure(a, b) {
+ ctx.addFailure(a.getStart(), b.end, Rule.FAILURE_STRING_DUPLICATE);
+ }
+}
+// If/else run separately, so return the branch more likely to result in eventual errors.
+function worse(a, b) {
+ return typeof a === "number"
+ ? typeof b === "number"
+ ? a < b
+ ? b
+ : a
+ : b
+ : typeof b === "number"
+ ? a
+ : a.break
+ ? b
+ : a;
+}
projects / dotfiles / .git / blobdiff