tsc-ts 0.0.3 → 0.0.5

package/dist/api/compiler/checker-operators.js

@@ -0,0 +1,1040 @@
+// Operator checking: unary, binary, conditional, `delete`, and truthiness and nullishness tests.
+import { checkExternalEmitHelpers } from './checker-emit-helpers.js';
+import { skipTrivia } from './scanner.js';
+import { NodeVisitor, getExpression, getText, } from './ast.js';
+import { getContainingClass, getSourceFileOfNode, getSourceTextOfNode, isAccessExpression, isEntityNameExpression, skipParentheses, } from './binder-utilities.js';
+import { isAssignmentOperator, isInJSFile } from './ast-utilities.js';
+import { ScriptTarget, getUseDefineForClassFields } from './options.js';
+import { tokenToString } from './scanner.js';
+import { internalSymbolNamePrefix } from './symbol.js';
+import { createDiagnosticForNode } from './checker.js';
+import { getResolvedSignature, isUntypedFunctionCall, resolveCall, resolveErrorCall, resolveUntypedCall, } from './checker-calls.js';
+import { getReturnTypeOfSignature } from './checker-signatures.js';
+import { getApparentType } from './checker-members.js';
+import { filterType, getBaseTypeOfLiteralType, getBaseTypeOfLiteralTypeForComparison, getBigIntLiteralType, getFreshTypeOfLiteralType, getNumberLiteralType, getUnionType, getUnionTypeEx, isEmptyAnonymousObjectType, isErrorType, someType, typesOf, } from './checker-type-factory.js';
+import { getBaseConstraintOrType, getPropertyOfType, getSignaturesOfType, getTypeOfPropertyOfType, } from './checker-members.js';
+import { getExportSymbolOfValueSymbolIfExported, getGlobalValueSymbol, getMergedSymbol } from './checker-symbols.js';
+import { getTypeOfSymbol, isReadonlySymbol } from './checker-symbol-types.js';
+import { getNonNullableType, getTypeFacts, hasTypeFacts } from './checker-flow.js';
+import { areTypesComparable, checkTypeAssignableTo, getTypeNamesForErrorDisplay, isTypeAssignableTo, isTypeComparableTo, isExactOptionalPropertyMismatch, isTypeSubtypeOf, } from './relations.js';
+import { checkTypeRelatedToAndOptionallyElaborate } from './checker-elaboration.js';
+import { isTypeAssignableToKindEx } from './checker-type-operators.js';
+import { typeToString } from './type-printer.js';
+import { getPropertyNameFromType, isTypeUsableAsPropertyName, maybeTypeOfKind } from './checker-utilities.js';
+import { getAwaitedTypeNoAlias, getAwaitedTypeOfPromise } from './checker-iteration.js';
+import { checkExpression, checkExpressionEx, checkNonNullType, checkPropertyAccessExpression, entityNameToString, getResolvedSymbol, getTypeOfExpression, parseBigIntText, } from './checker-expressions.js';
+import { checkDestructuringAssignment } from './checker-destructuring.js';
+import { evaluate } from './checker-evaluator.js';
+import { reportNonexistentProperty } from './checker-property-access.js';
+import { isUndefinedAssignmentToCommonJSExport } from './checker-javascript.js';
+import { getSymbolAtLocationWorker } from './checker-services.js';
+// ---- Unary operators
+export function checkPrefixUnaryExpression(c, node) {
+    const operandType = checkExpression(c, node.operand);
+    if (operandType === c.silentNeverType)
+        return c.silentNeverType;
+    switch (node.operand.kind) {
+        case 8 /* SyntaxKind.NumericLiteral */:
+            if (node.operator === 40 /* SyntaxKind.MinusToken */)
+                return getFreshTypeOfLiteralType(c, getNumberLiteralType(c, -Number(getText(node.operand))));
+            if (node.operator === 39 /* SyntaxKind.PlusToken */)
+                return getFreshTypeOfLiteralType(c, getNumberLiteralType(c, Number(getText(node.operand))));
+            break;
+        case 9 /* SyntaxKind.BigIntLiteral */:
+            if (node.operator === 40 /* SyntaxKind.MinusToken */) {
+                const value = parseBigIntText(getText(node.operand));
+                return getFreshTypeOfLiteralType(c, getBigIntLiteralType(c, value === '0' ? '0' : '-' + value));
+            }
+            break;
+    }
+    switch (node.operator) {
+        case 39 /* SyntaxKind.PlusToken */:
+        case 40 /* SyntaxKind.MinusToken */:
+        case 54 /* SyntaxKind.TildeToken */:
+            checkNonNullType(c, operandType, node.operand);
+            if (maybeTypeOfKindConsideringBaseConstraint(c, operandType, 16896 /* TypeFlags.ESSymbolLike */))
+                c.error(node.operand, 635 /* Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol */, tokenToString(node.operator));
+            if (node.operator === 39 /* SyntaxKind.PlusToken */) {
+                if (maybeTypeOfKindConsideringBaseConstraint(c, operandType, 4224 /* TypeFlags.BigIntLike */))
+                    c.error(node.operand, 868 /* Diagnostics.Operator_0_cannot_be_applied_to_type_1 */, tokenToString(node.operator), typeToString(c, getBaseTypeOfLiteralType(c, operandType)));
+                return c.numberType;
+            }
+            return getUnaryResultType(c, operandType);
+        case 53 /* SyntaxKind.ExclamationToken */: {
+            checkTruthinessOfType(c, operandType, node.operand);
+            const facts = getTypeFacts(c, operandType, 4194304 /* TypeFacts.Truthy */ | 8388608 /* TypeFacts.Falsy */);
+            if (facts === 4194304 /* TypeFacts.Truthy */)
+                return c.falseType;
+            if (facts === 8388608 /* TypeFacts.Falsy */)
+                return c.trueType;
+            return c.booleanType;
+        }
+        case 45 /* SyntaxKind.PlusPlusToken */:
+        case 46 /* SyntaxKind.MinusMinusToken */:
+            checkIncrementOperand(c, node.operand, operandType);
+            return getUnaryResultType(c, operandType);
+    }
+    return c.errorType;
+}
+export function checkPostfixUnaryExpression(c, node) {
+    const operandType = checkExpression(c, node.operand);
+    if (operandType === c.silentNeverType)
+        return c.silentNeverType;
+    checkIncrementOperand(c, node.operand, operandType);
+    return getUnaryResultType(c, operandType);
+}
+function checkIncrementOperand(c, operand, operandType) {
+    const ok = checkArithmeticOperandType(c, operand, checkNonNullType(c, operandType, operand), 532 /* Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type */, false);
+    // Only checked when the operand type is fine, to avoid cascading errors.
+    if (ok)
+        checkReferenceExpression(c, operand, 533 /* Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access */, 909 /* Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access */);
+}
+function getUnaryResultType(c, operandType) {
+    if (maybeTypeOfKind(operandType, 4224 /* TypeFlags.BigIntLike */)) {
+        return isTypeAssignableToKind(c, operandType, 3 /* TypeFlags.AnyOrUnknown */) ||
+            maybeTypeOfKind(operandType, 67648 /* TypeFlags.NumberLike */)
+            ? c.numberOrBigIntType
+            : c.bigintType;
+    }
+    return c.numberType;
+}
+export function checkDeleteExpression(c, node) {
+    checkExpression(c, getExpression(node));
+    const expr = skipParentheses(getExpression(node));
+    if (!isAccessExpression(expr)) {
+        c.error(expr, 835 /* Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference */);
+        return c.booleanType;
+    }
+    if (expr.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+        expr.name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
+        c.error(expr, 1833 /* Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier */);
+    const resolved = c.resolvedSymbols.get(expr.id);
+    if (resolved !== undefined) {
+        const symbol = getExportSymbolOfValueSymbolIfExported(c, resolved);
+        if (isReadonlySymbol(c, symbol))
+            c.error(expr, 836 /* Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property */);
+        else
+            checkDeleteExpressionMustBeOptional(c, expr, symbol);
+    }
+    return c.booleanType;
+}
+function checkDeleteExpressionMustBeOptional(c, expr, symbol) {
+    const t = getTypeOfSymbol(c, symbol);
+    if (!c.strictNullChecks || (t.flags & (3 /* TypeFlags.AnyOrUnknown */ | 262144 /* TypeFlags.Never */)) !== 0)
+        return;
+    const isOptional = c.exactOptionalPropertyTypes
+        ? (symbol.flags & 16777216 /* SymbolFlags.Optional */) !== 0
+        : hasTypeFacts(c, t, 16777216 /* TypeFacts.IsUndefined */);
+    if (!isOptional)
+        c.error(expr, 922 /* Diagnostics.The_operand_of_a_delete_operator_must_be_optional */);
+}
+/** Reports a grammar error unless the file already has syntax errors. */
+export function grammarErrorOnNode(c, node, message, ...args) {
+    if (getSourceFileOfNode(node).diagnostics.length !== 0)
+        return false;
+    c.error(node, message, ...args);
+    return true;
+}
+// ---- Arithmetic helpers
+function isTypeAssignableToKind(c, t, kind) {
+    return isTypeAssignableToKindEx(c, t, kind, false);
+}
+export function allTypesAssignableToKind(c, t, kind) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        for (const u of typesOf(t))
+            if (!allTypesAssignableToKind(c, u, kind))
+                return false;
+        return true;
+    }
+    return isTypeAssignableToKind(c, t, kind);
+}
+function maybeTypeOfKindConsideringBaseConstraint(c, t, kind) {
+    return maybeTypeOfKind(t, kind) || maybeTypeOfKind(getBaseConstraintOrType(c, t), kind);
+}
+function isTypeAny(t) {
+    return (t.flags & 1 /* TypeFlags.Any */) !== 0;
+}
+export function errorAndMaybeSuggestAwait(c, location, maybeMissingAwait, message, args) {
+    const diagnostic = createDiagnosticForNode(location, message, args);
+    if (maybeMissingAwait)
+        diagnostic.addRelatedInfo(createDiagnosticForNode(location, 905 /* Diagnostics.Did_you_forget_to_use_await */, []));
+    c.addDiagnostic(diagnostic);
+    return diagnostic;
+}
+function checkArithmeticOperandType(c, operand, t, message, isAwaitValid) {
+    if (isTypeAssignableTo(c, t, c.numberOrBigIntType))
+        return true;
+    const awaitedType = isAwaitValid ? getAwaitedTypeOfPromise(c, t) : undefined;
+    errorAndMaybeSuggestAwait(c, operand, awaitedType !== undefined && isTypeAssignableTo(c, awaitedType, c.numberOrBigIntType), message, []);
+    return false;
+}
+/** Whether `expr` can be assigned to; reports `invalidReference` or `invalidOptionalChain` otherwise. */
+export function checkReferenceExpression(c, expr, invalidReference, invalidOptionalChain) {
+    const node = skipAssertionsAndParentheses(expr);
+    if (node.kind !== 79 /* SyntaxKind.Identifier */ && !isAccessExpression(node)) {
+        c.error(expr, invalidReference);
+        return false;
+    }
+    if ((node.flags & 32 /* NodeFlags.OptionalChain */) !== 0) {
+        c.error(expr, invalidOptionalChain);
+        return false;
+    }
+    return true;
+}
+function skipAssertionsAndParentheses(nodeIn) {
+    let node = nodeIn;
+    while (node.kind === 218 /* SyntaxKind.ParenthesizedExpression */ ||
+        node.kind === 217 /* SyntaxKind.TypeAssertionExpression */ ||
+        node.kind === 235 /* SyntaxKind.AsExpression */ ||
+        node.kind === 239 /* SyntaxKind.SatisfiesExpression */ ||
+        node.kind === 236 /* SyntaxKind.NonNullExpression */)
+        node = getExpression(node);
+    return node;
+}
+/** `node` without parentheses, type assertions, `satisfies` and non-null assertions. */
+export function skipOuterExpressions(nodeIn) {
+    let node = nodeIn;
+    while (node.kind === 218 /* SyntaxKind.ParenthesizedExpression */ ||
+        node.kind === 217 /* SyntaxKind.TypeAssertionExpression */ ||
+        node.kind === 235 /* SyntaxKind.AsExpression */ ||
+        node.kind === 239 /* SyntaxKind.SatisfiesExpression */ ||
+        node.kind === 236 /* SyntaxKind.NonNullExpression */ ||
+        node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */ ||
+        node.kind === 348 /* SyntaxKind.PartiallyEmittedExpression */)
+        node = getExpression(node);
+    return node;
+}
+// ---- Binary operators
+export function checkBinaryExpression(c, node, checkMode) {
+    const left = node.left;
+    const right = node.right;
+    const operator = node.operatorToken.kind;
+    if (operator === 63 /* SyntaxKind.EqualsToken */ &&
+        (left.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ || left.kind === 210 /* SyntaxKind.ArrayLiteralExpression */))
+        return checkDestructuringAssignment(c, left, checkExpressionEx(c, right, checkMode), checkMode, right.kind === 109 /* SyntaxKind.ThisKeyword */);
+    const leftType = checkExpressionEx(c, left, checkMode);
+    const rightType = checkExpressionEx(c, right, checkMode);
+    if (isLogicalOrCoalescingOperator(operator)) {
+        let parent = node.parent;
+        while (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */ ||
+            (parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+                isLogicalOrCoalescingOperator(parent.operatorToken.kind)))
+            parent = parent.parent;
+        if (operator === 55 /* SyntaxKind.AmpersandAmpersandToken */ || parent.kind === 246 /* SyntaxKind.IfStatement */)
+            checkTestingKnownTruthyType(c, left, leftType, parent.kind === 246 /* SyntaxKind.IfStatement */ ? parent.thenStatement : undefined);
+        if (operator !== 60 /* SyntaxKind.QuestionQuestionToken */)
+            checkTruthinessOfType(c, leftType, left);
+    }
+    return checkBinaryLikeExpressionWorker(c, node, left, operator, right, leftType, rightType, checkMode);
+}
+function isLogicalOrCoalescingOperator(operator) {
+    return (operator === 55 /* SyntaxKind.AmpersandAmpersandToken */ ||
+        operator === 56 /* SyntaxKind.BarBarToken */ ||
+        operator === 60 /* SyntaxKind.QuestionQuestionToken */);
+}
+function checkBinaryLikeExpressionWorker(c, errorNode, left, operator, right, leftTypeIn, rightTypeIn, checkMode) {
+    let leftType = leftTypeIn;
+    let rightType = rightTypeIn;
+    switch (operator) {
+        case 41 /* SyntaxKind.AsteriskToken */:
+        case 42 /* SyntaxKind.AsteriskAsteriskToken */:
+        case 66 /* SyntaxKind.AsteriskEqualsToken */:
+        case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */:
+        case 43 /* SyntaxKind.SlashToken */:
+        case 68 /* SyntaxKind.SlashEqualsToken */:
+        case 44 /* SyntaxKind.PercentToken */:
+        case 69 /* SyntaxKind.PercentEqualsToken */:
+        case 40 /* SyntaxKind.MinusToken */:
+        case 65 /* SyntaxKind.MinusEqualsToken */:
+        case 47 /* SyntaxKind.LessThanLessThanToken */:
+        case 70 /* SyntaxKind.LessThanLessThanEqualsToken */:
+        case 48 /* SyntaxKind.GreaterThanGreaterThanToken */:
+        case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */:
+        case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */:
+        case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */:
+        case 51 /* SyntaxKind.BarToken */:
+        case 74 /* SyntaxKind.BarEqualsToken */:
+        case 52 /* SyntaxKind.CaretToken */:
+        case 78 /* SyntaxKind.CaretEqualsToken */:
+        case 50 /* SyntaxKind.AmpersandToken */:
+        case 73 /* SyntaxKind.AmpersandEqualsToken */: {
+            if (leftType === c.silentNeverType || rightType === c.silentNeverType)
+                return c.silentNeverType;
+            leftType = checkNonNullType(c, leftType, left);
+            rightType = checkNonNullType(c, rightType, right);
+            // Bitwise operators on two booleans suggest the logical operator.
+            if ((leftType.flags & 8448 /* TypeFlags.BooleanLike */) !== 0 && (rightType.flags & 8448 /* TypeFlags.BooleanLike */) !== 0) {
+                const suggested = getSuggestedBooleanOperator(operator);
+                if (suggested !== 0 /* SyntaxKind.Unknown */) {
+                    c.error(errorNode.operatorToken, 615 /* Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead */, tokenToString(operator), tokenToString(suggested));
+                    return c.numberType;
+                }
+            }
+            const leftOk = checkArithmeticOperandType(c, left, leftType, 536 /* Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type */, true);
+            const rightOk = checkArithmeticOperandType(c, right, rightType, 537 /* Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type */, true);
+            let resultType;
+            if ((isTypeAssignableToKind(c, leftType, 3 /* TypeFlags.AnyOrUnknown */) &&
+                isTypeAssignableToKind(c, rightType, 3 /* TypeFlags.AnyOrUnknown */)) ||
+                (!maybeTypeOfKind(leftType, 4224 /* TypeFlags.BigIntLike */) && !maybeTypeOfKind(rightType, 4224 /* TypeFlags.BigIntLike */)))
+                resultType = c.numberType;
+            else if (bothAreBigIntLike(c, leftType, rightType)) {
+                if (operator === 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */ ||
+                    operator === 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */)
+                    reportOperatorError(c, leftType, operator, rightType, errorNode, 0 /* RelatedCheck.None */);
+                else if ((operator === 42 /* SyntaxKind.AsteriskAsteriskToken */ || operator === 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */) &&
+                    c.languageVersion < ScriptTarget.ES2016)
+                    c.error(errorNode, 923 /* Diagnostics.Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later */);
+                resultType = c.bigintType;
+            }
+            else {
+                reportOperatorError(c, leftType, operator, rightType, errorNode, 1 /* RelatedCheck.BothBigIntLike */);
+                resultType = c.errorType;
+            }
+            if (leftOk && rightOk) {
+                checkAssignmentOperator(c, left, operator, right, leftType, resultType);
+                if (isShiftOperator(operator))
+                    checkShiftAmount(c, left, operator, right, errorNode);
+            }
+            return resultType;
+        }
+        case 39 /* SyntaxKind.PlusToken */:
+        case 64 /* SyntaxKind.PlusEqualsToken */: {
+            if (leftType === c.silentNeverType || rightType === c.silentNeverType)
+                return c.silentNeverType;
+            if (!isTypeAssignableToKind(c, leftType, 12583968 /* TypeFlags.StringLike */) &&
+                !isTypeAssignableToKind(c, rightType, 12583968 /* TypeFlags.StringLike */)) {
+                leftType = checkNonNullType(c, leftType, left);
+                rightType = checkNonNullType(c, rightType, right);
+            }
+            let resultType = undefined;
+            if (isTypeAssignableToKindEx(c, leftType, 67648 /* TypeFlags.NumberLike */, true) &&
+                isTypeAssignableToKindEx(c, rightType, 67648 /* TypeFlags.NumberLike */, true))
+                resultType = c.numberType;
+            else if (isTypeAssignableToKindEx(c, leftType, 4224 /* TypeFlags.BigIntLike */, true) &&
+                isTypeAssignableToKindEx(c, rightType, 4224 /* TypeFlags.BigIntLike */, true))
+                resultType = c.bigintType;
+            else if (isTypeAssignableToKindEx(c, leftType, 12583968 /* TypeFlags.StringLike */, true) ||
+                isTypeAssignableToKindEx(c, rightType, 12583968 /* TypeFlags.StringLike */, true))
+                resultType = c.stringType;
+            else if (isTypeAny(leftType) || isTypeAny(rightType))
+                resultType = isErrorType(c, leftType) || isErrorType(c, rightType) ? c.errorType : c.anyType;
+            // Symbols are not allowed at all in arithmetic expressions.
+            if (resultType !== undefined && !checkForDisallowedESSymbolOperand(c, left, right, leftType, rightType, operator))
+                return resultType;
+            if (resultType === undefined) {
+                reportOperatorError(c, leftType, operator, rightType, errorNode, 2 /* RelatedCheck.CloseEnoughForPlus */);
+                return c.anyType;
+            }
+            if (operator === 64 /* SyntaxKind.PlusEqualsToken */)
+                checkAssignmentOperator(c, left, operator, right, leftType, resultType);
+            return resultType;
+        }
+        case 29 /* SyntaxKind.LessThanToken */:
+        case 31 /* SyntaxKind.GreaterThanToken */:
+        case 32 /* SyntaxKind.LessThanEqualsToken */:
+        case 33 /* SyntaxKind.GreaterThanEqualsToken */:
+            if (checkForDisallowedESSymbolOperand(c, left, right, leftType, rightType, operator)) {
+                leftType = getBaseTypeOfLiteralTypeForComparison(c, checkNonNullType(c, leftType, left));
+                rightType = getBaseTypeOfLiteralTypeForComparison(c, checkNonNullType(c, rightType, right));
+                if (!isRelated(c, 3 /* RelatedCheck.Comparable */, leftType, rightType))
+                    reportOperatorError(c, leftType, operator, rightType, errorNode, 3 /* RelatedCheck.Comparable */);
+            }
+            return c.booleanType;
+        case 34 /* SyntaxKind.EqualsEqualsToken */:
+        case 35 /* SyntaxKind.ExclamationEqualsToken */:
+        case 36 /* SyntaxKind.EqualsEqualsEqualsToken */:
+        case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */:
+            // Flow analysis may check operands with temporarily narrower types; only report in normal checks.
+            if ((checkMode & 64 /* CheckMode.TypeOnly */) === 0) {
+                if ((isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) &&
+                    (!isInJSFile(left) ||
+                        operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */ ||
+                        operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */)) {
+                    const eqType = operator === 34 /* SyntaxKind.EqualsEqualsToken */ || operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */;
+                    c.error(errorNode, 961 /* Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value */, eqType ? 'false' : 'true');
+                }
+                checkNaNEquality(c, errorNode, operator, left, right);
+                if (!isRelated(c, 4 /* RelatedCheck.EqualityComparable */, leftType, rightType))
+                    reportOperatorError(c, leftType, operator, rightType, errorNode, 4 /* RelatedCheck.EqualityComparable */);
+            }
+            return c.booleanType;
+        case 103 /* SyntaxKind.InstanceOfKeyword */:
+            return checkInstanceOfExpression(c, left, right, leftType, rightType, checkMode);
+        case 102 /* SyntaxKind.InKeyword */:
+            return checkInExpression(c, left, right, leftType, rightType);
+        case 55 /* SyntaxKind.AmpersandAmpersandToken */:
+        case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: {
+            let resultType = leftType;
+            if (hasTypeFacts(c, leftType, 4194304 /* TypeFacts.Truthy */))
+                resultType = getUnionType(c, [
+                    extractDefinitelyFalsyTypes(c, c.strictNullChecks ? leftType : getBaseTypeOfLiteralType(c, rightType)),
+                    rightType,
+                ]);
+            if (operator === 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */)
+                checkAssignmentOperator(c, left, operator, right, leftType, rightType);
+            return resultType;
+        }
+        case 56 /* SyntaxKind.BarBarToken */:
+        case 75 /* SyntaxKind.BarBarEqualsToken */: {
+            let resultType = leftType;
+            if (hasTypeFacts(c, leftType, 8388608 /* TypeFacts.Falsy */))
+                resultType = getUnionTypeEx(c, [getNonNullableType(c, removeDefinitelyFalsyTypes(c, leftType)), rightType], 2 /* UnionReduction.Subtype */, undefined, undefined);
+            if (operator === 75 /* SyntaxKind.BarBarEqualsToken */)
+                checkAssignmentOperator(c, left, operator, right, leftType, rightType);
+            return resultType;
+        }
+        case 60 /* SyntaxKind.QuestionQuestionToken */:
+        case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: {
+            if (operator === 60 /* SyntaxKind.QuestionQuestionToken */)
+                checkNullishCoalesceOperands(c, left, right);
+            let resultType = leftType;
+            if (hasTypeFacts(c, leftType, 262144 /* TypeFacts.EQUndefinedOrNull */))
+                resultType = getUnionTypeEx(c, [getNonNullableType(c, leftType), rightType], 2 /* UnionReduction.Subtype */, undefined, undefined);
+            if (operator === 77 /* SyntaxKind.QuestionQuestionEqualsToken */)
+                checkAssignmentOperator(c, left, operator, right, leftType, rightType);
+            return resultType;
+        }
+        case 63 /* SyntaxKind.EqualsToken */:
+            checkAssignmentOperator(c, left, operator, right, leftType, rightType);
+            return rightType;
+        case 27 /* SyntaxKind.CommaToken */:
+            if (c.compilerOptions.allowUnreachableCode !== true &&
+                isSideEffectFree(left) &&
+                !isIndirectCall(left.parent) &&
+                !isInMultipleJsxRootsError(left))
+                c.error(left, 827 /* Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects */);
+            return rightType;
+    }
+    return c.errorType;
+}
+/** Whether `left` starts inside an "expressions must have one parent element" parse error. */
+function isInMultipleJsxRootsError(left) {
+    const file = getSourceFileOfNode(left);
+    const start = skipTrivia(file.text, left.pos);
+    for (const d of file.diagnostics)
+        if (d.message === 791 /* Diagnostics.JSX_expressions_must_have_one_parent_element */ && d.pos <= start && start < d.end)
+            return true;
+    return false;
+}
+function getSuggestedBooleanOperator(operator) {
+    switch (operator) {
+        case 51 /* SyntaxKind.BarToken */:
+        case 74 /* SyntaxKind.BarEqualsToken */:
+            return 56 /* SyntaxKind.BarBarToken */;
+        case 52 /* SyntaxKind.CaretToken */:
+        case 78 /* SyntaxKind.CaretEqualsToken */:
+            return 37 /* SyntaxKind.ExclamationEqualsEqualsToken */;
+        case 50 /* SyntaxKind.AmpersandToken */:
+        case 73 /* SyntaxKind.AmpersandEqualsToken */:
+            return 55 /* SyntaxKind.AmpersandAmpersandToken */;
+    }
+    return 0 /* SyntaxKind.Unknown */;
+}
+function bothAreBigIntLike(c, left, right) {
+    return (isTypeAssignableToKind(c, left, 4224 /* TypeFlags.BigIntLike */) && isTypeAssignableToKind(c, right, 4224 /* TypeFlags.BigIntLike */));
+}
+/** Returns true when neither operand is a symbol; reports the offending one otherwise. */
+function checkForDisallowedESSymbolOperand(c, left, right, leftType, rightType, operator) {
+    let offending = undefined;
+    if (maybeTypeOfKindConsideringBaseConstraint(c, leftType, 16896 /* TypeFlags.ESSymbolLike */))
+        offending = left;
+    else if (maybeTypeOfKindConsideringBaseConstraint(c, rightType, 16896 /* TypeFlags.ESSymbolLike */))
+        offending = right;
+    if (offending === undefined)
+        return true;
+    c.error(offending, 635 /* Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol */, tokenToString(operator));
+    return false;
+}
+function isRelated(c, check, left, right) {
+    switch (check) {
+        case 1 /* RelatedCheck.BothBigIntLike */:
+            return bothAreBigIntLike(c, left, right);
+        case 2 /* RelatedCheck.CloseEnoughForPlus */: {
+            const kind = 67648 /* TypeFlags.NumberLike */ | 4224 /* TypeFlags.BigIntLike */ | 12583968 /* TypeFlags.StringLike */ | 3 /* TypeFlags.AnyOrUnknown */;
+            return isTypeAssignableToKind(c, left, kind) && isTypeAssignableToKind(c, right, kind);
+        }
+        case 3 /* RelatedCheck.Comparable */: {
+            if (isTypeAny(left) || isTypeAny(right))
+                return true;
+            const leftNumeric = isTypeAssignableTo(c, left, c.numberOrBigIntType);
+            const rightNumeric = isTypeAssignableTo(c, right, c.numberOrBigIntType);
+            return (leftNumeric && rightNumeric) || (!leftNumeric && !rightNumeric && areTypesComparable(c, left, right));
+        }
+        case 4 /* RelatedCheck.EqualityComparable */:
+            return isTypeEqualityComparableTo(c, left, right) || isTypeEqualityComparableTo(c, right, left);
+    }
+    return false;
+}
+export function isTypeEqualityComparableTo(c, source, target) {
+    return (target.flags & 12 /* TypeFlags.Nullable */) !== 0 || isTypeComparableTo(c, source, target);
+}
+function reportOperatorError(c, leftType, operator, rightType, errorNode, check) {
+    let wouldWorkWithAwait = false;
+    let effectiveLeft = leftType;
+    let effectiveRight = rightType;
+    if (check !== 0 /* RelatedCheck.None */) {
+        const awaitedLeft = getAwaitedTypeNoAlias(c, leftType);
+        const awaitedRight = getAwaitedTypeNoAlias(c, rightType);
+        wouldWorkWithAwait =
+            !(awaitedLeft === leftType && awaitedRight === rightType) &&
+                awaitedLeft !== undefined &&
+                awaitedRight !== undefined &&
+                isRelated(c, check, awaitedLeft, awaitedRight);
+        if (!wouldWorkWithAwait) {
+            // Literal operands display as their base types when those are unrelated too.
+            const leftBase = getBaseTypeOfLiteralType(c, leftType);
+            const rightBase = getBaseTypeOfLiteralType(c, rightType);
+            if (!isRelated(c, check, leftBase, rightBase)) {
+                effectiveLeft = leftBase;
+                effectiveRight = rightBase;
+            }
+        }
+    }
+    const [leftStr, rightStr] = getTypeNamesForErrorDisplay(c, effectiveLeft, effectiveRight);
+    switch (operator) {
+        case 36 /* SyntaxKind.EqualsEqualsEqualsToken */:
+        case 34 /* SyntaxKind.EqualsEqualsToken */:
+        case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */:
+        case 35 /* SyntaxKind.ExclamationEqualsToken */:
+            errorAndMaybeSuggestAwait(c, errorNode, wouldWorkWithAwait, 541 /* Diagnostics.This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap */, [leftStr, rightStr]);
+            return;
+    }
+    errorAndMaybeSuggestAwait(c, errorNode, wouldWorkWithAwait, 539 /* Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2 */, [tokenToString(operator), leftStr, rightStr]);
+}
+function checkAssignmentOperator(c, left, operator, right, leftType, rightType) {
+    if (!isAssignmentOperator(operator))
+        return;
+    if (isUndefinedAssignmentToCommonJSExport(c, left, rightType))
+        return;
+    // A getter's type can be a subtype of its setter's, so compound assignments check against the setter.
+    let targetType = leftType;
+    if (operator >= 64 /* SyntaxKind.FirstCompoundAssignment */ &&
+        operator <= 78 /* SyntaxKind.LastCompoundAssignment */ &&
+        left.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        targetType = checkPropertyAccessExpression(c, left, true);
+    // Assignability is only checked when the target is a reference, to avoid cascading errors.
+    if (checkReferenceExpression(c, left, 538 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access */, 911 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access */)) {
+        let headMessage = undefined;
+        if (c.exactOptionalPropertyTypes &&
+            left.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+            maybeTypeOfKind(rightType, 4 /* TypeFlags.Undefined */)) {
+            const access = left;
+            const target = getTypeOfPropertyOfType(c, getTypeOfExpression(c, access.expression), getText(access.name));
+            if (isExactOptionalPropertyMismatch(c, rightType, target))
+                headMessage =
+                    583 /* Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target */;
+        }
+        checkTypeRelatedToAndOptionallyElaborate(c, rightType, targetType, c.assignableRelation, left, right, headMessage, undefined);
+    }
+}
+function isLiteralExpressionOfObject(node) {
+    switch (node.kind) {
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 13 /* SyntaxKind.RegularExpressionLiteral */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+            return true;
+    }
+    return false;
+}
+function checkNaNEquality(c, errorNode, operator, left, right) {
+    const isLeftNaN = isGlobalNaN(c, skipParentheses(left));
+    const isRightNaN = isGlobalNaN(c, skipParentheses(right));
+    if (!isLeftNaN && !isRightNaN)
+        return;
+    const err = c.error(errorNode, 966 /* Diagnostics.This_condition_will_always_return_0 */, operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */ || operator === 34 /* SyntaxKind.EqualsEqualsToken */ ? 'false' : 'true');
+    if (isLeftNaN && isRightNaN)
+        return;
+    const operatorString = operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */ || operator === 35 /* SyntaxKind.ExclamationEqualsToken */ ? '!' : '';
+    const location = isLeftNaN ? right : left;
+    const expression = skipParentheses(location);
+    const entityName = isEntityNameExpression(expression, false) ? entityNameToString(expression) : '...';
+    err.addRelatedInfo(createDiagnosticForNode(location, 303 /* Diagnostics.Did_you_mean_0 */, [
+        operatorString + 'Number.isNaN(' + entityName + ')',
+    ]));
+}
+function isGlobalNaN(c, expr) {
+    if (expr.kind !== 79 /* SyntaxKind.Identifier */ || getText(expr) !== 'NaN')
+        return false;
+    const globalNaNSymbol = c.globals.get('NaN');
+    return globalNaNSymbol !== undefined && getResolvedSymbol(c, expr) === getMergedSymbol(c, globalNaNSymbol);
+}
+function isShiftOperator(operator) {
+    switch (operator) {
+        case 47 /* SyntaxKind.LessThanLessThanToken */:
+        case 70 /* SyntaxKind.LessThanLessThanEqualsToken */:
+        case 48 /* SyntaxKind.GreaterThanGreaterThanToken */:
+        case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */:
+        case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */:
+        case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */:
+            return true;
+    }
+    return false;
+}
+/** Shifts by 32 or more wrap around; that's an error in enum members and a suggestion elsewhere. */
+function checkShiftAmount(c, left, operator, right, errorNode) {
+    const result = evaluate(c, right, right);
+    if (result.kind !== 1 /* EvaluatedKind.Number */ || Math.abs(result.numberValue) < 32)
+        return;
+    let container = right.parent.parent;
+    while (container.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+        container = container.parent;
+    const file = getSourceFileOfNode(left);
+    c.addErrorOrSuggestion(container.kind === 306 /* SyntaxKind.EnumMember */, createDiagnosticForNode(errorNode, 1644 /* Diagnostics.This_operation_can_be_simplified_This_shift_is_identical_to_0_1_2 */, [
+        getSourceTextOfNode(file, left),
+        tokenToString(operator),
+        String(result.numberValue % 32),
+    ]));
+}
+function checkInstanceOfExpression(c, left, right, leftType, rightType, checkMode) {
+    if (leftType === c.silentNeverType || rightType === c.silentNeverType)
+        return c.silentNeverType;
+    // Unknown left operands already reported an error.
+    if (!isTypeAny(leftType) && allTypesAssignableToKind(c, leftType, 12713980 /* TypeFlags.Primitive */))
+        c.error(left, 534 /* Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter */);
+    // `x instanceof C` is checked as the call `C[Symbol.hasInstance](x)`.
+    const signature = getResolvedSignature(c, left.parent, checkMode);
+    if (signature === c.resolvingSignature)
+        return c.silentNeverType;
+    checkTypeAssignableTo(c, getReturnTypeOfSignature(c, signature), c.booleanType, right, 981 /* Diagnostics.An_object_s_Symbol_hasInstance_method_must_return_a_boolean_value_for_it_to_be_used_on_the_right_hand_side_of_an_instanceof_expression */);
+    return c.booleanType;
+}
+/** The signature of `right[Symbol.hasInstance]` that `left instanceof right` calls, if any. */
+export function resolveInstanceofExpression(c, node, checkMode) {
+    const right = node.right;
+    const rightType = checkExpression(c, right);
+    if (!isTypeAny(rightType)) {
+        const hasInstanceMethodType = getSymbolHasInstanceMethodOfObjectType(c, rightType);
+        if (hasInstanceMethodType !== undefined) {
+            const apparentType = getApparentType(c, hasInstanceMethodType);
+            if (isErrorType(c, apparentType))
+                return resolveErrorCall(c, node);
+            const callSignatures = getSignaturesOfType(c, apparentType, 0 /* SignatureKind.Call */);
+            const constructSignatures = getSignaturesOfType(c, apparentType, 1 /* SignatureKind.Construct */);
+            if (isUntypedFunctionCall(c, hasInstanceMethodType, apparentType, callSignatures.length, constructSignatures.length))
+                return resolveUntypedCall(c, node);
+            // Argument errors explain how `left instanceof right` became `right[Symbol.hasInstance](left)`.
+            if (callSignatures.length !== 0)
+                return resolveCall(c, node, callSignatures, checkMode, 0 /* SignatureFlags.None */, 980 /* Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_assignable_to_the_first_argument_of_the_right_hand_side_s_Symbol_hasInstance_method */);
+        }
+        else if (!typeHasCallOrConstructSignatures(c, rightType) &&
+            !isTypeSubtypeOf(c, rightType, c.globalFunctionType)) {
+            c.error(right, 535 /* Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_either_of_type_any_a_class_function_or_other_type_assignable_to_the_Function_interface_type_or_an_object_type_with_a_Symbol_hasInstance_method */);
+            return resolveErrorCall(c, node);
+        }
+    }
+    return c.anySignature;
+}
+function typeHasCallOrConstructSignatures(c, t) {
+    return (getSignaturesOfType(c, t, 0 /* SignatureKind.Call */).length !== 0 ||
+        getSignaturesOfType(c, t, 1 /* SignatureKind.Construct */).length !== 0);
+}
+export function getSymbolHasInstanceMethodOfObjectType(c, t) {
+    if (!allTypesAssignableToKind(c, t, 131072 /* TypeFlags.NonPrimitive */))
+        return undefined;
+    const prop = getPropertyOfType(c, t, getPropertyNameForKnownSymbolName(c, 'hasInstance'));
+    if (prop === undefined)
+        return undefined;
+    const propType = getTypeOfSymbol(c, prop);
+    return getSignaturesOfType(c, propType, 0 /* SignatureKind.Call */).length !== 0 ? propType : undefined;
+}
+/** The member name of a well-known symbol such as `Symbol.iterator`. */
+export function getPropertyNameForKnownSymbolName(c, name) {
+    const ctor = getGlobalValueSymbol(c, 'Symbol', false);
+    if (ctor !== undefined) {
+        const uniqueType = getTypeOfPropertyOfType(c, getTypeOfSymbol(c, ctor), name);
+        if (uniqueType !== undefined && isTypeUsableAsPropertyName(uniqueType))
+            return getPropertyNameFromType(uniqueType);
+    }
+    return internalSymbolNamePrefix + '@' + name;
+}
+function checkInExpression(c, left, right, leftType, rightType) {
+    if (leftType === c.silentNeverType || rightType === c.silentNeverType)
+        return c.silentNeverType;
+    if (left.kind === 80 /* SyntaxKind.PrivateIdentifier */) {
+        if (c.languageVersion < ScriptTarget.ESNext || !getUseDefineForClassFields(c.compilerOptions))
+            checkExternalEmitHelpers(c, left, 32768 /* ExternalEmitHelpers.ClassPrivateFieldIn */);
+        // With the right side's type known, a private name that doesn't resolve is reported as missing on it.
+        if (c.resolvedSymbols.get(left.id) === undefined && getContainingClass(left) !== undefined)
+            reportNonexistentProperty(c, left, rightType);
+    }
+    else
+        checkTypeAssignableTo(c, checkNonNullType(c, leftType, left), c.stringNumberSymbolType, left, undefined);
+    if (checkTypeAssignableTo(c, checkNonNullType(c, rightType, right), c.nonPrimitiveType, right, undefined)) {
+        // `{}` is assignable to `object` but may stand for a primitive, as when narrowed from `unknown`.
+        if (hasEmptyObjectIntersection(c, rightType))
+            c.error(right, 781 /* Diagnostics.Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator */, typeToString(c, rightType));
+    }
+    return c.booleanType;
+}
+function hasEmptyObjectIntersection(c, t) {
+    return someType(t, (u) => u === c.unknownEmptyObjectType ||
+        ((u.flags & 268435456 /* TypeFlags.Intersection */) !== 0 && isEmptyAnonymousObjectType(c, getBaseConstraintOrType(c, u))));
+}
+// ---- Logical operators
+export function removeDefinitelyFalsyTypes(c, t) {
+    return filterType(c, t, (u) => hasTypeFacts(c, u, 4194304 /* TypeFacts.Truthy */));
+}
+function extractDefinitelyFalsyTypes(c, t) {
+    if ((t.flags & 134217728 /* TypeFlags.Union */) === 0)
+        return getDefinitelyFalsyPartOfType(c, t);
+    const types = [];
+    for (const u of typesOf(t))
+        types.push(getDefinitelyFalsyPartOfType(c, u));
+    return getUnionType(c, types);
+}
+function getDefinitelyFalsyPartOfType(c, t) {
+    if ((t.flags & 32 /* TypeFlags.String */) !== 0)
+        return c.emptyStringType;
+    if ((t.flags & 64 /* TypeFlags.Number */) !== 0)
+        return c.zeroType;
+    if ((t.flags & 128 /* TypeFlags.BigInt */) !== 0)
+        return c.zeroBigIntType;
+    if (t === c.regularFalseType ||
+        t === c.falseType ||
+        (t.flags & (16 /* TypeFlags.Void */ | 4 /* TypeFlags.Undefined */ | 8 /* TypeFlags.Null */ | 3 /* TypeFlags.AnyOrUnknown */)) !== 0)
+        return t;
+    if ((t.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 && t.stringValue === '')
+        return t;
+    if ((t.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0 && t.numberValue === 0)
+        return t;
+    if ((t.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0 && t.stringValue === '0')
+        return t;
+    return c.neverType;
+}
+/** Reports tests of `void` and of expressions that are syntactically always truthy or falsy. */
+export function checkTruthinessOfType(c, t, node) {
+    if ((t.flags & 16 /* TypeFlags.Void */) !== 0) {
+        c.error(node, 279 /* Diagnostics.An_expression_of_type_void_cannot_be_tested_for_truthiness */);
+        return t;
+    }
+    const semantics = getSyntacticTruthySemantics(c, node);
+    if (semantics !== 3 /* PredicateSemantics.Sometimes */)
+        c.error(node, semantics === 1 /* PredicateSemantics.Always */
+            ? 992 /* Diagnostics.This_kind_of_expression_is_always_truthy */
+            : 993 /* Diagnostics.This_kind_of_expression_is_always_falsy */);
+    return t;
+}
+function getSyntacticTruthySemantics(c, nodeIn) {
+    const node = skipOuterExpressions(nodeIn);
+    switch (node.kind) {
+        case 8 /* SyntaxKind.NumericLiteral */: {
+            // `while (0)` and `while (1)` are idioms.
+            const text = getText(node);
+            return text === '0' || text === '1' ? 3 /* PredicateSemantics.Sometimes */ : 1 /* PredicateSemantics.Always */;
+        }
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 285 /* SyntaxKind.JsxElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 13 /* SyntaxKind.RegularExpressionLiteral */:
+            return 1 /* PredicateSemantics.Always */;
+        case 223 /* SyntaxKind.VoidExpression */:
+        case 105 /* SyntaxKind.NullKeyword */:
+            return 2 /* PredicateSemantics.Never */;
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+            return getText(node) !== '' ? 1 /* PredicateSemantics.Always */ : 2 /* PredicateSemantics.Never */;
+        case 228 /* SyntaxKind.ConditionalExpression */: {
+            const cond = node;
+            return getSyntacticTruthySemantics(c, cond.whenTrue) | getSyntacticTruthySemantics(c, cond.whenFalse);
+        }
+        case 79 /* SyntaxKind.Identifier */:
+            if (getResolvedSymbol(c, node) === c.undefinedSymbol)
+                return 2 /* PredicateSemantics.Never */;
+            break;
+    }
+    return 3 /* PredicateSemantics.Sometimes */;
+}
+function checkNullishCoalesceOperands(c, left, right) {
+    const grandparent = left.parent.parent;
+    if (grandparent.kind === 227 /* SyntaxKind.BinaryExpression */) {
+        const outer = grandparent;
+        if (outer.left.kind === 227 /* SyntaxKind.BinaryExpression */ && outer.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */)
+            grammarErrorOnNode(c, outer.left, 1151 /* Diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses */, tokenToString(60 /* SyntaxKind.QuestionQuestionToken */), tokenToString(outer.operatorToken.kind));
+    }
+    else if (left.kind === 227 /* SyntaxKind.BinaryExpression */) {
+        const operator = left.operatorToken.kind;
+        if (operator === 56 /* SyntaxKind.BarBarToken */ || operator === 55 /* SyntaxKind.AmpersandAmpersandToken */)
+            grammarErrorOnNode(c, left, 1151 /* Diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses */, tokenToString(operator), tokenToString(60 /* SyntaxKind.QuestionQuestionToken */));
+    }
+    else if (right.kind === 227 /* SyntaxKind.BinaryExpression */) {
+        const operator = right.operatorToken.kind;
+        if (operator === 55 /* SyntaxKind.AmpersandAmpersandToken */)
+            grammarErrorOnNode(c, right, 1151 /* Diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses */, tokenToString(60 /* SyntaxKind.QuestionQuestionToken */), tokenToString(operator));
+    }
+    const leftTarget = skipOuterExpressions(left);
+    const semantics = getSyntacticNullishnessSemantics(c, leftTarget);
+    if (semantics === 1 /* PredicateSemantics.Always */)
+        c.error(leftTarget, 991 /* Diagnostics.This_expression_is_always_nullish */);
+    else if (semantics !== 3 /* PredicateSemantics.Sometimes */)
+        c.error(leftTarget, 989 /* Diagnostics.Right_operand_of_is_unreachable_because_the_left_operand_is_never_nullish */);
+}
+function getSyntacticNullishnessSemantics(c, nodeIn) {
+    const node = skipOuterExpressions(nodeIn);
+    switch (node.kind) {
+        case 224 /* SyntaxKind.AwaitExpression */:
+        case 214 /* SyntaxKind.CallExpression */:
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 237 /* SyntaxKind.MetaProperty */:
+        case 215 /* SyntaxKind.NewExpression */:
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 230 /* SyntaxKind.YieldExpression */:
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return 3 /* PredicateSemantics.Sometimes */;
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            const binary = node;
+            switch (binary.operatorToken.kind) {
+                case 56 /* SyntaxKind.BarBarToken */:
+                case 75 /* SyntaxKind.BarBarEqualsToken */:
+                case 55 /* SyntaxKind.AmpersandAmpersandToken */:
+                case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+                    return 3 /* PredicateSemantics.Sometimes */;
+                // The right operand decides.
+                case 27 /* SyntaxKind.CommaToken */:
+                case 63 /* SyntaxKind.EqualsToken */:
+                case 60 /* SyntaxKind.QuestionQuestionToken */:
+                case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+                    return getSyntacticNullishnessSemantics(c, binary.right);
+            }
+            return 2 /* PredicateSemantics.Never */;
+        }
+        case 228 /* SyntaxKind.ConditionalExpression */: {
+            const cond = node;
+            return getSyntacticNullishnessSemantics(c, cond.whenTrue) | getSyntacticNullishnessSemantics(c, cond.whenFalse);
+        }
+        case 105 /* SyntaxKind.NullKeyword */:
+            return 1 /* PredicateSemantics.Always */;
+        case 79 /* SyntaxKind.Identifier */:
+            return getResolvedSymbol(c, node) === c.undefinedSymbol
+                ? 1 /* PredicateSemantics.Always */
+                : 3 /* PredicateSemantics.Sometimes */;
+    }
+    return 2 /* PredicateSemantics.Never */;
+}
+// ---- Conditions
+export function checkConditionalExpression(c, node, checkMode) {
+    const t = checkTruthinessExpression(c, node.condition, checkMode);
+    checkTestingKnownTruthyType(c, node.condition, t, node.whenTrue);
+    const type1 = checkExpressionEx(c, node.whenTrue, checkMode);
+    const type2 = checkExpressionEx(c, node.whenFalse, checkMode);
+    return getUnionTypeEx(c, [type1, type2], 2 /* UnionReduction.Subtype */, undefined, undefined);
+}
+export function checkTruthinessExpression(c, node, checkMode) {
+    return checkTruthinessOfType(c, checkExpressionEx(c, node, checkMode), node);
+}
+/**
+ * Reports conditions on functions and promises that are always defined and not used in `body`,
+ * which usually means a missing call or `await`. Only under strictNullChecks.
+ */
+export function checkTestingKnownTruthyType(c, condExpr, condType, body) {
+    if (!c.strictNullChecks)
+        return;
+    let expr = skipParentheses(condExpr);
+    checkTestingKnownTruthyTypeWorker(c, expr, condType, body);
+    while (expr.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        (expr.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ ||
+            expr.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */)) {
+        expr = skipParentheses(expr.left);
+        checkTestingKnownTruthyTypeWorker(c, expr, condType, body);
+    }
+}
+function isLogicalOrCoalescingExpression(node) {
+    return (node.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        isLogicalOrCoalescingOperator(node.operatorToken.kind));
+}
+function checkTestingKnownTruthyTypeWorker(c, condExpr, condType, body) {
+    const location = isLogicalOrCoalescingExpression(condExpr)
+        ? skipParentheses(condExpr.right)
+        : condExpr;
+    if (isLogicalOrCoalescingExpression(location)) {
+        checkTestingKnownTruthyType(c, location, condType, body);
+        return;
+    }
+    const t = location !== condExpr ? checkExpression(c, location) : condType;
+    if ((t.flags & 32768 /* TypeFlags.EnumLiteral */) !== 0 && location.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        const leftSymbol = c.resolvedSymbols.get(location.expression.id);
+        if (leftSymbol !== undefined && (leftSymbol.flags & 384 /* SymbolFlags.Enum */) !== 0) {
+            // An enum member with a known value is always truthy or always falsy.
+            const value = t;
+            const truthy = (t.flags & 1024 /* TypeFlags.StringLiteral */) !== 0 ? value.stringValue !== '' : value.numberValue !== 0;
+            c.error(location, 966 /* Diagnostics.This_condition_will_always_return_0 */, truthy ? 'true' : 'false');
+            return;
+        }
+    }
+    const isPropertyExpressionCast = location.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+        isTypeAssertion(location.expression);
+    if (!hasTypeFacts(c, t, 4194304 /* TypeFacts.Truthy */) || isPropertyExpressionCast)
+        return;
+    // Known-truthy tests are only reported for functions and promises: values from declarations
+    // without strictNullChecks would produce too many false positives otherwise.
+    const isPromise = getAwaitedTypeOfPromise(c, t) !== undefined;
+    if (getSignaturesOfType(c, t, 0 /* SignatureKind.Call */).length === 0 && !isPromise)
+        return;
+    let testedNode = undefined;
+    if (location.kind === 79 /* SyntaxKind.Identifier */)
+        testedNode = location;
+    else if (location.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        testedNode = location.name;
+    const testedSymbol = testedNode !== undefined ? getSymbolAtLocationWorker(c, testedNode, false) : undefined;
+    if (testedSymbol === undefined && !isPromise)
+        return;
+    const isUsed = testedSymbol !== undefined &&
+        ((condExpr.parent.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+            isSymbolUsedInBinaryExpressionChain(c, condExpr.parent, testedSymbol)) ||
+            (body !== undefined && isSymbolUsedInConditionBody(c, condExpr, body, testedNode, testedSymbol)));
+    if (isUsed)
+        return;
+    if (isPromise)
+        errorAndMaybeSuggestAwait(c, location, true, 933 /* Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined */, [typeToString(c, t, undefined, 64 /* TypeFormatFlags.UseFullyQualifiedType */)]);
+    else
+        c.error(location, 906 /* Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead */);
+}
+export function isTypeAssertion(node) {
+    const n = skipParentheses(node);
+    return n.kind === 217 /* SyntaxKind.TypeAssertionExpression */ || n.kind === 235 /* SyntaxKind.AsExpression */;
+}
+function isSymbolUsedInBinaryExpressionChain(c, nodeIn, testedSymbol) {
+    let node = nodeIn;
+    while (node.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        node.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */) {
+        if (node.right.forEachChild(new SymbolUseFinder(c, testedSymbol)))
+            return true;
+        node = node.parent;
+    }
+    return false;
+}
+/** Finds an identifier referring to a symbol. */
+class SymbolUseFinder extends NodeVisitor {
+    c;
+    symbol;
+    constructor(c, symbol) {
+        super();
+        this.c = c;
+        this.symbol = symbol;
+    }
+    visitNode(node) {
+        if (node.kind === 79 /* SyntaxKind.Identifier */ && getSymbolAtLocationWorker(this.c, node, false) === this.symbol)
+            return true;
+        return node.forEachChild(this);
+    }
+}
+function isSymbolUsedInConditionBody(c, expr, body, testedNode, testedSymbol) {
+    return body.forEachChild(new ConditionBodyUseFinder(c, expr, testedNode, testedSymbol));
+}
+/** Finds a use of the tested symbol on the same target as in the condition. */
+class ConditionBodyUseFinder extends NodeVisitor {
+    c;
+    expr;
+    testedNode;
+    testedSymbol;
+    constructor(c, expr, testedNode, testedSymbol) {
+        super();
+        this.c = c;
+        this.expr = expr;
+        this.testedNode = testedNode;
+        this.testedSymbol = testedSymbol;
+    }
+    visitNode(node) {
+        if (node.kind === 79 /* SyntaxKind.Identifier */ && getSymbolAtLocationWorker(this.c, node, false) === this.testedSymbol) {
+            // A simple identifier test needs no target comparison.
+            if (this.expr.kind === 79 /* SyntaxKind.Identifier */ ||
+                (this.testedNode.kind === 79 /* SyntaxKind.Identifier */ && this.testedNode.parent.kind === 227 /* SyntaxKind.BinaryExpression */))
+                return true;
+            let tested = this.testedNode.parent;
+            let child = node.parent;
+            while (tested !== undefined && child !== undefined) {
+                if (tested.kind === 79 /* SyntaxKind.Identifier */ && child.kind === 79 /* SyntaxKind.Identifier */)
+                    return getSymbolAtLocationWorker(this.c, tested, false) === getSymbolAtLocationWorker(this.c, child, false);
+                if (tested.kind === 109 /* SyntaxKind.ThisKeyword */ && child.kind === 109 /* SyntaxKind.ThisKeyword */)
+                    return true;
+                if (tested.kind === 212 /* SyntaxKind.PropertyAccessExpression */ && child.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+                    if (getSymbolAtLocationWorker(this.c, tested.name, false) !==
+                        getSymbolAtLocationWorker(this.c, child.name, false))
+                        return false;
+                    child = getExpression(child);
+                    tested = getExpression(tested);
+                }
+                else if (tested.kind === 214 /* SyntaxKind.CallExpression */ && child.kind === 214 /* SyntaxKind.CallExpression */) {
+                    child = getExpression(child);
+                    tested = getExpression(tested);
+                }
+                else
+                    return false;
+            }
+        }
+        return node.forEachChild(this);
+    }
+}
+// ---- Comma operator
+/**
+ * Whether evaluating `expr` itself has no side effects, as a smell test for discarded values
+ * like the left side of a comma.
+ */
+function isSideEffectFree(expr) {
+    const node = skipParentheses(expr);
+    switch (node.kind) {
+        case 79 /* SyntaxKind.Identifier */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 13 /* SyntaxKind.RegularExpressionLiteral */:
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 229 /* SyntaxKind.TemplateExpression */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 111 /* SyntaxKind.TrueKeyword */:
+        case 96 /* SyntaxKind.FalseKeyword */:
+        case 105 /* SyntaxKind.NullKeyword */:
+        case 157 /* SyntaxKind.UndefinedKeyword */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 222 /* SyntaxKind.TypeOfExpression */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 285 /* SyntaxKind.JsxElement */:
+            return true;
+        case 228 /* SyntaxKind.ConditionalExpression */: {
+            const cond = node;
+            return isSideEffectFree(cond.whenTrue) && isSideEffectFree(cond.whenFalse);
+        }
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            const binary = node;
+            if (isAssignmentOperator(binary.operatorToken.kind))
+                return false;
+            return isSideEffectFree(binary.left) && isSideEffectFree(binary.right);
+        }
+        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+            switch (node.operator) {
+                case 53 /* SyntaxKind.ExclamationToken */:
+                case 39 /* SyntaxKind.PlusToken */:
+                case 40 /* SyntaxKind.MinusToken */:
+                case 54 /* SyntaxKind.TildeToken */:
+                    return true;
+            }
+            return false;
+    }
+    return false;
+}
+/** `(0, x.f)(...)` or `(0, eval)(...)`, which call without passing `this`. */
+function isIndirectCall(node) {
+    const left = node.left;
+    const right = node.right;
+    const parent = node.parent;
+    if (parent.kind !== 218 /* SyntaxKind.ParenthesizedExpression */ ||
+        left.kind !== 8 /* SyntaxKind.NumericLiteral */ ||
+        getText(left) !== '0')
+        return false;
+    const grand = parent.parent;
+    const called = (grand.kind === 214 /* SyntaxKind.CallExpression */ && getExpression(grand) === parent) ||
+        grand.kind === 216 /* SyntaxKind.TaggedTemplateExpression */;
+    return called && (isAccessExpression(right) || (right.kind === 79 /* SyntaxKind.Identifier */ && getText(right) === 'eval'));
+}