+++ /dev/null
-"use strict";
-/**
- * @license
- * Copyright 2018 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 OPTION_ALLOW_NULL_UNION = "allow-null-union";
-var OPTION_ALLOW_UNDEFINED_UNION = "allow-undefined-union";
-var OPTION_ALLOW_STRING = "allow-string";
-var OPTION_ALLOW_ENUM = "allow-enum";
-var OPTION_ALLOW_NUMBER = "allow-number";
-var OPTION_ALLOW_MIX = "allow-mix";
-var OPTION_ALLOW_BOOLEAN_OR_UNDEFINED = "allow-boolean-or-undefined";
-var OPTION_IGNORE_RHS = "ignore-rhs";
-// tslint:disable object-literal-sort-keys no-bitwise
-var Rule = /** @class */ (function (_super) {
- tslib_1.__extends(Rule, _super);
- function Rule() {
- return _super !== null && _super.apply(this, arguments) || this;
- }
- Rule.prototype.applyWithProgram = function (sourceFile, program) {
- var options = parseOptions(this.ruleArguments, Lint.isStrictNullChecksEnabled(program.getCompilerOptions()));
- return this.applyWithFunction(sourceFile, walk, options, program.getTypeChecker());
- };
- Rule.metadata = {
- ruleName: "strict-boolean-expressions",
- description: Lint.Utils.dedent(templateObject_1 || (templateObject_1 = tslib_1.__makeTemplateObject(["\n Restricts the types allowed in boolean expressions. By default only booleans are allowed.\n\n The following nodes are checked:\n\n * Arguments to the `!`, `&&`, and `||` operators\n * The condition in a conditional expression (`cond ? x : y`)\n * Conditions for `if`, `for`, `while`, and `do-while` statements."], ["\n Restricts the types allowed in boolean expressions. By default only booleans are allowed.\n\n The following nodes are checked:\n\n * Arguments to the \\`!\\`, \\`&&\\`, and \\`||\\` operators\n * The condition in a conditional expression (\\`cond ? x : y\\`)\n * Conditions for \\`if\\`, \\`for\\`, \\`while\\`, and \\`do-while\\` statements."]))),
- optionsDescription: Lint.Utils.dedent(templateObject_2 || (templateObject_2 = tslib_1.__makeTemplateObject(["\n These options may be provided:\n\n * `", "` allows union types containing `null`.\n - It does *not* allow `null` itself.\n - Without the '--strictNullChecks' compiler option, this will allow anything other than a string, number, or enum.\n * `", "` allows union types containing `undefined`.\n - It does *not* allow `undefined` itself.\n - Without the '--strictNullChecks' compiler option, this will allow anything other than a string, number, or enum.\n * `", "` allows strings.\n - It does *not* allow unions containing `string`.\n - It does *not* allow string literal types.\n * `", "` allows enums.\n - It does *not* allow unions containing `enum`.\n * `", "` allows numbers.\n - It does *not* allow unions containing `number`.\n - It does *not* allow enums or number literal types.\n * `", "` allows multiple of the above to appear together.\n - For example, `string | number` or `RegExp | null | undefined` would normally not be allowed.\n - A type like `\"foo\" | \"bar\" | undefined` is always allowed, because it has only one way to be false.\n * `", "` allows `boolean | undefined`.\n - Also allows `true | false | undefined`.\n - Does not allow `false | undefined`.\n - This option is a subset of `", "`, so you don't need to enable both options at the same time.\n * `", "` ignores the right-hand operand of `&&` and `||`.\n "], ["\n These options may be provided:\n\n * \\`", "\\` allows union types containing \\`null\\`.\n - It does *not* allow \\`null\\` itself.\n - Without the '--strictNullChecks' compiler option, this will allow anything other than a string, number, or enum.\n * \\`", "\\` allows union types containing \\`undefined\\`.\n - It does *not* allow \\`undefined\\` itself.\n - Without the '--strictNullChecks' compiler option, this will allow anything other than a string, number, or enum.\n * \\`", "\\` allows strings.\n - It does *not* allow unions containing \\`string\\`.\n - It does *not* allow string literal types.\n * \\`", "\\` allows enums.\n - It does *not* allow unions containing \\`enum\\`.\n * \\`", "\\` allows numbers.\n - It does *not* allow unions containing \\`number\\`.\n - It does *not* allow enums or number literal types.\n * \\`", "\\` allows multiple of the above to appear together.\n - For example, \\`string | number\\` or \\`RegExp | null | undefined\\` would normally not be allowed.\n - A type like \\`\"foo\" | \"bar\" | undefined\\` is always allowed, because it has only one way to be false.\n * \\`", "\\` allows \\`boolean | undefined\\`.\n - Also allows \\`true | false | undefined\\`.\n - Does not allow \\`false | undefined\\`.\n - This option is a subset of \\`", "\\`, so you don't need to enable both options at the same time.\n * \\`", "\\` ignores the right-hand operand of \\`&&\\` and \\`||\\`.\n "])), OPTION_ALLOW_NULL_UNION, OPTION_ALLOW_UNDEFINED_UNION, OPTION_ALLOW_STRING, OPTION_ALLOW_ENUM, OPTION_ALLOW_NUMBER, OPTION_ALLOW_MIX, OPTION_ALLOW_BOOLEAN_OR_UNDEFINED, OPTION_ALLOW_UNDEFINED_UNION, OPTION_IGNORE_RHS),
- options: {
- type: "array",
- items: {
- type: "string",
- enum: [
- OPTION_ALLOW_NULL_UNION,
- OPTION_ALLOW_UNDEFINED_UNION,
- OPTION_ALLOW_STRING,
- OPTION_ALLOW_ENUM,
- OPTION_ALLOW_NUMBER,
- OPTION_ALLOW_BOOLEAN_OR_UNDEFINED,
- OPTION_IGNORE_RHS,
- ],
- },
- minLength: 0,
- maxLength: 7,
- },
- optionExamples: [
- true,
- [
- true,
- OPTION_ALLOW_NULL_UNION,
- OPTION_ALLOW_UNDEFINED_UNION,
- OPTION_ALLOW_STRING,
- OPTION_ALLOW_ENUM,
- OPTION_ALLOW_NUMBER,
- ],
- [true, OPTION_ALLOW_BOOLEAN_OR_UNDEFINED],
- ],
- type: "functionality",
- typescriptOnly: true,
- requiresTypeInfo: true,
- };
- return Rule;
-}(Lint.Rules.TypedRule));
-exports.Rule = Rule;
-function parseOptions(ruleArguments, strictNullChecks) {
- return {
- strictNullChecks: strictNullChecks,
- allowNullUnion: has(OPTION_ALLOW_NULL_UNION),
- allowUndefinedUnion: has(OPTION_ALLOW_UNDEFINED_UNION),
- allowString: has(OPTION_ALLOW_STRING),
- allowEnum: has(OPTION_ALLOW_ENUM),
- allowNumber: has(OPTION_ALLOW_NUMBER),
- allowMix: has(OPTION_ALLOW_MIX),
- allowBooleanOrUndefined: has(OPTION_ALLOW_BOOLEAN_OR_UNDEFINED),
- ignoreRhs: has(OPTION_IGNORE_RHS),
- };
- function has(name) {
- return ruleArguments.indexOf(name) !== -1;
- }
-}
-function walk(ctx, checker) {
- var sourceFile = ctx.sourceFile, options = ctx.options;
- ts.forEachChild(sourceFile, function cb(node) {
- switch (node.kind) {
- case ts.SyntaxKind.BinaryExpression: {
- var b = node;
- if (binaryBooleanExpressionKind(b) !== undefined) {
- var left = b.left, right = b.right;
- // If ignore-rhs is off, we don't have to analyze a boolean binary expression
- // on the left side because it will be checked well enough on its own. However,
- // if ignore-rhs is on, we have to analyze the overall result of the left
- // side no matter what, because its right side might not follow the rules.
- if (!isBooleanBinaryExpression(left)) {
- checkExpression(left, b);
- }
- // If ignore-rhs is on, we don't have to analyze the right hand side
- // We also don't have to analyze the right hand side if it is also a
- // boolean binary expression; its own inner check is sufficient.
- if (!(options.ignoreRhs || isBooleanBinaryExpression(right))) {
- checkExpression(right, b);
- }
- }
- break;
- }
- case ts.SyntaxKind.PrefixUnaryExpression: {
- var _a = node, operator = _a.operator, operand = _a.operand;
- if (operator === ts.SyntaxKind.ExclamationToken) {
- checkExpression(operand, node);
- }
- break;
- }
- case ts.SyntaxKind.IfStatement:
- case ts.SyntaxKind.WhileStatement:
- case ts.SyntaxKind.DoStatement: {
- var c = node;
- // If it's a boolean binary expression, we'll check it when recursing.
- if (!isBooleanBinaryExpression(c.expression)) {
- checkExpression(c.expression, c);
- }
- break;
- }
- case ts.SyntaxKind.ConditionalExpression:
- checkExpression(node.condition, node);
- break;
- case ts.SyntaxKind.ForStatement: {
- var condition = node.condition;
- if (condition !== undefined) {
- checkExpression(condition, node);
- }
- }
- }
- return ts.forEachChild(node, cb);
- });
- function checkExpression(node, location) {
- var type = checker.getTypeAtLocation(node);
- var failure = getTypeFailure(type, options);
- if (failure !== undefined) {
- if (failure === 0 /* AlwaysTruthy */ &&
- !options.strictNullChecks &&
- (options.allowNullUnion || options.allowUndefinedUnion)) {
- // OK; It might be null/undefined.
- return;
- }
- ctx.addFailureAtNode(node, showFailure(location, failure, isUnionType(type), options));
- }
- }
-}
-function getTypeFailure(type, options) {
- if (isUnionType(type)) {
- return handleUnion(type, options);
- }
- var kind = getKind(type);
- var failure = failureForKind(kind, /*isInUnion*/ false, options);
- if (failure !== undefined) {
- return failure;
- }
- switch (triState(kind)) {
- case true:
- // Allow 'any'. Allow 'true' itself, but not any other always-truthy type.
- return tsutils_1.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.BooleanLiteral)
- ? undefined
- : 0 /* AlwaysTruthy */;
- case false:
- // Allow 'false' itself, but not any other always-falsy type
- return tsutils_1.isTypeFlagSet(type, ts.TypeFlags.BooleanLiteral)
- ? undefined
- : 1 /* AlwaysFalsy */;
- case undefined:
- return undefined;
- }
-}
-function isBooleanUndefined(type) {
- var isTruthy = false;
- for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
- var ty = _a[_i];
- if (tsutils_1.isTypeFlagSet(ty, ts.TypeFlags.Boolean)) {
- isTruthy = true;
- }
- else if (tsutils_1.isTypeFlagSet(ty, ts.TypeFlags.BooleanLiteral)) {
- isTruthy = isTruthy || ty.intrinsicName === "true";
- // tslint:disable-next-line:no-bitwise
- }
- else if (!tsutils_1.isTypeFlagSet(ty, ts.TypeFlags.Void | ts.TypeFlags.Undefined)) {
- return undefined;
- }
- }
- return isTruthy;
-}
-function handleUnion(type, options) {
- if (options.allowBooleanOrUndefined) {
- switch (isBooleanUndefined(type)) {
- case true:
- return undefined;
- case false:
- return 1 /* AlwaysFalsy */;
- }
- }
- // Tracks whether it's possibly truthy.
- var anyTruthy = false;
- // Counts falsy kinds to see if there's a mix. Also tracks whether it's possibly falsy.
- var seenFalsy = 0;
- for (var _i = 0, _a = type.types; _i < _a.length; _i++) {
- var ty = _a[_i];
- var kind = getKind(ty);
- var failure = failureForKind(kind, /*isInUnion*/ true, options);
- if (failure !== undefined) {
- return failure;
- }
- switch (triState(kind)) {
- case true:
- anyTruthy = true;
- break;
- case false:
- seenFalsy++;
- break;
- default:
- anyTruthy = true;
- seenFalsy++;
- }
- }
- return seenFalsy === 0
- ? 0 /* AlwaysTruthy */
- : !anyTruthy
- ? 1 /* AlwaysFalsy */
- : !options.allowMix && seenFalsy > 1
- ? 7 /* Mixes */
- : undefined;
-}
-/** Fails if a kind of falsiness is not allowed. */
-function failureForKind(kind, isInUnion, options) {
- switch (kind) {
- case 0 /* String */:
- case 1 /* FalseStringLiteral */:
- return options.allowString ? undefined : 2 /* String */;
- case 2 /* Number */:
- case 3 /* FalseNumberLiteral */:
- return options.allowNumber ? undefined : 3 /* Number */;
- case 8 /* Enum */:
- return options.allowEnum ? undefined : 6 /* Enum */;
- case 6 /* Null */:
- return isInUnion && !options.allowNullUnion ? 4 /* Null */ : undefined;
- case 7 /* Undefined */:
- return isInUnion && !options.allowUndefinedUnion ? 5 /* Undefined */ : undefined;
- default:
- return undefined;
- }
-}
-/** Divides a type into always true, always false, or unknown. */
-function triState(kind) {
- switch (kind) {
- case 0 /* String */:
- case 2 /* Number */:
- case 4 /* Boolean */:
- case 8 /* Enum */:
- return undefined;
- case 6 /* Null */:
- case 7 /* Undefined */:
- case 3 /* FalseNumberLiteral */:
- case 1 /* FalseStringLiteral */:
- case 5 /* FalseBooleanLiteral */:
- return false;
- case 9 /* AlwaysTruthy */:
- return true;
- }
-}
-function getKind(type) {
- return is(ts.TypeFlags.String)
- ? 0 /* String */
- : is(ts.TypeFlags.Number)
- ? 2 /* Number */
- : is(ts.TypeFlags.Boolean)
- ? 4 /* Boolean */
- : is(ts.TypeFlags.Null)
- ? 6 /* Null */
- : is(ts.TypeFlags.Undefined | ts.TypeFlags.Void)
- ? 7 /* Undefined */
- : is(ts.TypeFlags.EnumLike)
- ? 8 /* Enum */
- : is(ts.TypeFlags.NumberLiteral)
- ? numberLiteralIsZero(type)
- ? 3 /* FalseNumberLiteral */
- : 9 /* AlwaysTruthy */
- : is(ts.TypeFlags.StringLiteral)
- ? stringLiteralIsEmpty(type)
- ? 1 /* FalseStringLiteral */
- : 9 /* AlwaysTruthy */
- : is(ts.TypeFlags.BooleanLiteral)
- ? type.intrinsicName === "true"
- ? 9 /* AlwaysTruthy */
- : 5 /* FalseBooleanLiteral */
- : 9 /* AlwaysTruthy */;
- function is(flags) {
- return tsutils_1.isTypeFlagSet(type, flags);
- }
-}
-function numberLiteralIsZero(type) {
- // for compatibility with typescript@<2.4.0
- return type.value !== undefined ? type.value === 0 : type.text === "0";
-}
-function stringLiteralIsEmpty(type) {
- // for compatibility with typescript@<2.4.0
- return (type.value !== undefined ? type.value : type.text) === "";
-}
-/** Matches `&&` and `||` operators. */
-function isBooleanBinaryExpression(node) {
- return (node.kind === ts.SyntaxKind.BinaryExpression &&
- binaryBooleanExpressionKind(node) !== undefined);
-}
-function binaryBooleanExpressionKind(node) {
- switch (node.operatorToken.kind) {
- case ts.SyntaxKind.AmpersandAmpersandToken:
- return "&&";
- case ts.SyntaxKind.BarBarToken:
- return "||";
- default:
- return undefined;
- }
-}
-function stringOr(parts) {
- switch (parts.length) {
- case 1:
- return parts[0];
- case 2:
- return parts[0] + " or " + parts[1];
- default:
- var res = "";
- for (var i = 0; i < parts.length - 1; i++) {
- res += parts[i] + ", ";
- }
- return res + "or " + parts[parts.length - 1];
- }
-}
-function isUnionType(type) {
- return tsutils_1.isTypeFlagSet(type, ts.TypeFlags.Union) && !tsutils_1.isTypeFlagSet(type, ts.TypeFlags.Enum);
-}
-function showLocation(n) {
- switch (n.kind) {
- case ts.SyntaxKind.PrefixUnaryExpression:
- return "operand for the '!' operator";
- case ts.SyntaxKind.ConditionalExpression:
- return "condition";
- case ts.SyntaxKind.ForStatement:
- return "'for' condition";
- case ts.SyntaxKind.IfStatement:
- return "'if' condition";
- case ts.SyntaxKind.WhileStatement:
- return "'while' condition";
- case ts.SyntaxKind.DoStatement:
- return "'do-while' condition";
- case ts.SyntaxKind.BinaryExpression:
- return "operand for the '" + binaryBooleanExpressionKind(n) + "' operator";
- }
-}
-function showFailure(location, ty, unionType, options) {
- var expectedTypes = showExpectedTypes(options);
- var expected = expectedTypes.length === 1
- ? "Only " + expectedTypes[0] + "s are allowed"
- : "Allowed types are " + stringOr(expectedTypes);
- var tyFail = showTypeFailure(ty, unionType, options.strictNullChecks);
- return "This type is not allowed in the " + showLocation(location) + " because it " + tyFail + ". " + expected + ".";
-}
-function showExpectedTypes(options) {
- var parts = ["boolean"];
- if (options.allowNullUnion) {
- parts.push("null-union");
- }
- if (options.allowUndefinedUnion) {
- parts.push("undefined-union");
- }
- if (options.allowString) {
- parts.push("string");
- }
- if (options.allowEnum) {
- parts.push("enum");
- }
- if (options.allowNumber) {
- parts.push("number");
- }
- if (options.allowBooleanOrUndefined) {
- parts.push("boolean-or-undefined");
- }
- return parts;
-}
-function showTypeFailure(ty, unionType, strictNullChecks) {
- var is = unionType ? "could be" : "is";
- switch (ty) {
- case 0 /* AlwaysTruthy */:
- return strictNullChecks
- ? "is always truthy"
- : "is always truthy. It may be null/undefined, but neither " +
- ("'" + OPTION_ALLOW_NULL_UNION + "' nor '" + OPTION_ALLOW_UNDEFINED_UNION + "' is set");
- case 1 /* AlwaysFalsy */:
- return "is always falsy";
- case 2 /* String */:
- return is + " a string";
- case 3 /* Number */:
- return is + " a number";
- case 4 /* Null */:
- return is + " null";
- case 5 /* Undefined */:
- return is + " undefined";
- case 6 /* Enum */:
- return is + " an enum";
- case 7 /* Mixes */:
- return "unions more than one truthy/falsy type";
- }
-}
-var templateObject_1, templateObject_2;
projects / dotfiles / .git / blobdiff