--- /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 error_1 = require("../error");
+var Lint = require("../index");
+// tslint:disable:no-bitwise
+var Rule = /** @class */ (function (_super) {
+ tslib_1.__extends(Rule, _super);
+ function Rule() {
+ return _super !== null && _super.apply(this, arguments) || this;
+ }
+ Rule.FAILURE_STRING = function (value) {
+ return "Expression is always " + value + ".";
+ };
+ Rule.FAILURE_STRICT_PREFER_STRICT_EQUALS = function (value, isPositive) {
+ return "Use '" + (isPositive ? "===" : "!==") + " " + value + "' instead.";
+ };
+ Rule.prototype.applyWithProgram = function (sourceFile, program) {
+ if (!Lint.isStrictNullChecksEnabled(program.getCompilerOptions())) {
+ error_1.showWarningOnce("strict-type-predicates does not work without --strictNullChecks");
+ return [];
+ }
+ return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
+ };
+ /* tslint:disable:object-literal-sort-keys */
+ Rule.metadata = {
+ ruleName: "strict-type-predicates",
+ description: Lint.Utils.dedent(templateObject_1 || (templateObject_1 = tslib_1.__makeTemplateObject(["\n Warns for type predicates that are always true or always false.\n Works for 'typeof' comparisons to constants (e.g. 'typeof foo === \"string\"'), and equality comparison to 'null'/'undefined'.\n (TypeScript won't let you compare '1 === 2', but it has an exception for '1 === undefined'.)\n Does not yet work for 'instanceof'.\n Does *not* warn for 'if (x.y)' where 'x.y' is always truthy. For that, see strict-boolean-expressions.\n\n This rule requires `strictNullChecks` to work properly."], ["\n Warns for type predicates that are always true or always false.\n Works for 'typeof' comparisons to constants (e.g. 'typeof foo === \"string\"'), and equality comparison to 'null'/'undefined'.\n (TypeScript won't let you compare '1 === 2', but it has an exception for '1 === undefined'.)\n Does not yet work for 'instanceof'.\n Does *not* warn for 'if (x.y)' where 'x.y' is always truthy. For that, see strict-boolean-expressions.\n\n This rule requires \\`strictNullChecks\\` to work properly."]))),
+ optionsDescription: "Not configurable.",
+ options: null,
+ optionExamples: [true],
+ type: "functionality",
+ typescriptOnly: true,
+ requiresTypeInfo: true,
+ };
+ /* tslint:enable:object-literal-sort-keys */
+ Rule.FAILURE_STRING_BAD_TYPEOF = "Bad comparison for 'typeof'.";
+ return Rule;
+}(Lint.Rules.TypedRule));
+exports.Rule = Rule;
+function walk(ctx, checker) {
+ return ts.forEachChild(ctx.sourceFile, function cb(node) {
+ if (tsutils_1.isBinaryExpression(node)) {
+ var equals = Lint.getEqualsKind(node.operatorToken);
+ if (equals !== undefined) {
+ checkEquals(node, equals);
+ }
+ }
+ return ts.forEachChild(node, cb);
+ });
+ function checkEquals(node, _a) {
+ var isStrict = _a.isStrict, isPositive = _a.isPositive;
+ var exprPred = getTypePredicate(node, isStrict);
+ if (exprPred === undefined) {
+ return;
+ }
+ if (exprPred.kind === 2 /* TypeofTypo */) {
+ fail(Rule.FAILURE_STRING_BAD_TYPEOF);
+ return;
+ }
+ var exprType = checker.getTypeAtLocation(exprPred.expression);
+ // TODO: could use checker.getBaseConstraintOfType to help with type parameters, but it's not publicly exposed.
+ if (tsutils_1.isTypeFlagSet(exprType, ts.TypeFlags.Any | ts.TypeFlags.TypeParameter | ts.TypeFlags.Unknown)) {
+ return;
+ }
+ switch (exprPred.kind) {
+ case 0 /* Plain */: {
+ var predicate = exprPred.predicate, isNullOrUndefined = exprPred.isNullOrUndefined;
+ var value = getConstantBoolean(exprType, predicate);
+ // 'null'/'undefined' are the only two values *not* assignable to '{}'.
+ if (value !== undefined && (isNullOrUndefined || !isEmptyType(checker, exprType))) {
+ fail(Rule.FAILURE_STRING(value === isPositive));
+ }
+ break;
+ }
+ case 1 /* NonStructNullUndefined */: {
+ var result = testNonStrictNullUndefined(exprType);
+ if (result !== undefined) {
+ fail(typeof result === "boolean"
+ ? Rule.FAILURE_STRING(result === isPositive)
+ : Rule.FAILURE_STRICT_PREFER_STRICT_EQUALS(result, isPositive));
+ }
+ }
+ }
+ function fail(failure) {
+ ctx.addFailureAtNode(node, failure);
+ }
+ }
+}
+/** Detects a type predicate given `left === right`. */
+function getTypePredicate(node, isStrictEquals) {
+ var left = node.left, right = node.right;
+ var lr = getTypePredicateOneWay(left, right, isStrictEquals);
+ return lr !== undefined ? lr : getTypePredicateOneWay(right, left, isStrictEquals);
+}
+/** Only gets the type predicate if the expression is on the left. */
+function getTypePredicateOneWay(left, right, isStrictEquals) {
+ switch (right.kind) {
+ case ts.SyntaxKind.TypeOfExpression:
+ var expression = right.expression;
+ if (!tsutils_1.isLiteralExpression(left)) {
+ if ((tsutils_1.isIdentifier(left) && left.text === "undefined") ||
+ left.kind === ts.SyntaxKind.NullKeyword ||
+ left.kind === ts.SyntaxKind.TrueKeyword ||
+ left.kind === ts.SyntaxKind.FalseKeyword) {
+ return { kind: 2 /* TypeofTypo */ };
+ }
+ return undefined;
+ }
+ var predicate = getTypePredicateForKind(left.text);
+ return predicate === undefined
+ ? { kind: 2 /* TypeofTypo */ }
+ : {
+ expression: expression,
+ isNullOrUndefined: left.text === "undefined",
+ kind: 0 /* Plain */,
+ predicate: predicate,
+ };
+ case ts.SyntaxKind.NullKeyword:
+ return nullOrUndefined(ts.TypeFlags.Null);
+ case ts.SyntaxKind.Identifier:
+ if (right.originalKeywordKind === ts.SyntaxKind.UndefinedKeyword) {
+ return nullOrUndefined(undefinedFlags);
+ }
+ return undefined;
+ default:
+ return undefined;
+ }
+ function nullOrUndefined(flags) {
+ return isStrictEquals
+ ? {
+ expression: left,
+ isNullOrUndefined: true,
+ kind: 0 /* Plain */,
+ predicate: flagPredicate(flags),
+ }
+ : { kind: 1 /* NonStructNullUndefined */, expression: left };
+ }
+}
+function isEmptyType(checker, type) {
+ return checker.typeToString(type) === "{}";
+}
+var undefinedFlags = ts.TypeFlags.Undefined | ts.TypeFlags.Void;
+function getTypePredicateForKind(kind) {
+ switch (kind) {
+ case "undefined":
+ return flagPredicate(undefinedFlags);
+ case "boolean":
+ return flagPredicate(ts.TypeFlags.BooleanLike);
+ case "number":
+ return flagPredicate(ts.TypeFlags.NumberLike);
+ case "string":
+ return flagPredicate(ts.TypeFlags.StringLike);
+ case "symbol":
+ return flagPredicate(ts.TypeFlags.ESSymbol);
+ case "function":
+ return isFunction;
+ case "object":
+ // It's an object if it's not any of the above.
+ var allFlags_1 = ts.TypeFlags.Undefined |
+ ts.TypeFlags.Void |
+ ts.TypeFlags.BooleanLike |
+ ts.TypeFlags.NumberLike |
+ ts.TypeFlags.StringLike |
+ ts.TypeFlags.ESSymbol;
+ return function (type) { return !tsutils_1.isTypeFlagSet(type, allFlags_1) && !isFunction(type); };
+ default:
+ return undefined;
+ }
+}
+function flagPredicate(testedFlag) {
+ return function (type) { return tsutils_1.isTypeFlagSet(type, testedFlag); };
+}
+function isFunction(t) {
+ if (t.getConstructSignatures().length !== 0 || t.getCallSignatures().length !== 0) {
+ return true;
+ }
+ var symbol = t.getSymbol();
+ return symbol !== undefined && symbol.getName() === "Function";
+}
+/** Returns a boolean value if that should always be the result of a type predicate. */
+function getConstantBoolean(type, predicate) {
+ var anyTrue = false;
+ var anyFalse = false;
+ for (var _i = 0, _a = unionParts(type); _i < _a.length; _i++) {
+ var ty = _a[_i];
+ if (predicate(ty)) {
+ anyTrue = true;
+ }
+ else {
+ anyFalse = true;
+ }
+ if (anyTrue && anyFalse) {
+ return undefined;
+ }
+ }
+ return anyTrue;
+}
+/** Returns bool for always/never true, or a string to recommend strict equality. */
+function testNonStrictNullUndefined(type) {
+ var anyNull = false;
+ var anyUndefined = false;
+ var anyOther = false;
+ for (var _i = 0, _a = unionParts(type); _i < _a.length; _i++) {
+ var ty = _a[_i];
+ if (tsutils_1.isTypeFlagSet(ty, ts.TypeFlags.Null)) {
+ anyNull = true;
+ }
+ else if (tsutils_1.isTypeFlagSet(ty, undefinedFlags)) {
+ anyUndefined = true;
+ }
+ else {
+ anyOther = true;
+ }
+ }
+ return !anyOther
+ ? true
+ : anyNull && anyUndefined
+ ? undefined
+ : anyNull
+ ? "null"
+ : anyUndefined
+ ? "undefined"
+ : false;
+}
+function unionParts(type) {
+ return tsutils_1.isUnionType(type) ? type.types : [type];
+}
+var templateObject_1;
projects / dotfiles / .git / blobdiff