tsc-ts 0.0.10 → 0.1.0

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

@@ -53,10 +53,10 @@ export function checkPrefixUnaryExpression(c, node) {
         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));
+                c.error(node.operand, 642 /* 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)));
+                    c.error(node.operand, 875 /* Diagnostics.Operator_0_cannot_be_applied_to_type_1 */, tokenToString(node.operator), typeToString(c, getBaseTypeOfLiteralType(c, operandType)));
                 return c.numberType;
             }
             return getUnaryResultType(c, operandType);
@@ -84,10 +84,10 @@ export function checkPostfixUnaryExpression(c, node) {
     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);
+    const ok = checkArithmeticOperandType(c, operand, checkNonNullType(c, operandType, operand), 539 /* 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 */);
+        checkReferenceExpression(c, operand, 540 /* Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access */, 916 /* 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 */)) {
@@ -102,17 +102,17 @@ 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 */);
+        c.error(expr, 842 /* Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference */);
         return c.booleanType;
     }
-    if (expr.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+    if (expr.kind === 213 /* SyntaxKind.PropertyAccessExpression */ &&
         expr.name.kind === 80 /* SyntaxKind.PrivateIdentifier */)
-        c.error(expr, 1833 /* Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier */);
+        c.error(expr, 1853 /* 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 */);
+            c.error(expr, 843 /* Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property */);
         else
             checkDeleteExpressionMustBeOptional(c, expr, symbol);
     }
@@ -126,7 +126,7 @@ function checkDeleteExpressionMustBeOptional(c, expr, symbol) {
         ? (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 */);
+        c.error(expr, 929 /* 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) {
@@ -155,10 +155,11 @@ function isTypeAny(t) {
     return (t.flags & 1 /* TypeFlags.Any */) !== 0;
 }
 export function errorAndMaybeSuggestAwait(c, location, maybeMissingAwait, message, args) {
-    const diagnostic = createDiagnosticForNode(location, message, args);
+    // The related information goes on the reported diagnostic after it is added, as tsgo attaches it,
+    // so a later equal report compares unequal to it and is kept.
+    const diagnostic = c.error(location, message, ...args);
     if (maybeMissingAwait)
-        diagnostic.addRelatedInfo(createDiagnosticForNode(location, 905 /* Diagnostics.Did_you_forget_to_use_await */, []));
-    c.addDiagnostic(diagnostic);
+        diagnostic.addRelatedInfo(createDiagnosticForNode(location, 912 /* Diagnostics.Did_you_forget_to_use_await */, []));
     return diagnostic;
 }
 function checkArithmeticOperandType(c, operand, t, message, isAwaitValid) {
@@ -183,24 +184,24 @@ export function checkReferenceExpression(c, expr, invalidReference, invalidOptio
 }
 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 */)
+    while (node.kind === 219 /* SyntaxKind.ParenthesizedExpression */ ||
+        node.kind === 218 /* SyntaxKind.TypeAssertionExpression */ ||
+        node.kind === 236 /* SyntaxKind.AsExpression */ ||
+        node.kind === 240 /* SyntaxKind.SatisfiesExpression */ ||
+        node.kind === 237 /* 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 */)
+    while (node.kind === 219 /* SyntaxKind.ParenthesizedExpression */ ||
+        node.kind === 218 /* SyntaxKind.TypeAssertionExpression */ ||
+        node.kind === 236 /* SyntaxKind.AsExpression */ ||
+        node.kind === 240 /* SyntaxKind.SatisfiesExpression */ ||
+        node.kind === 237 /* SyntaxKind.NonNullExpression */ ||
+        node.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */ ||
+        node.kind === 349 /* SyntaxKind.PartiallyEmittedExpression */)
         node = getExpression(node);
     return node;
 }
@@ -210,18 +211,18 @@ export function checkBinaryExpression(c, node, checkMode) {
     const right = node.right;
     const operator = node.operatorToken.kind;
     if (operator === 63 /* SyntaxKind.EqualsToken */ &&
-        (left.kind === 211 /* SyntaxKind.ObjectLiteralExpression */ || left.kind === 210 /* SyntaxKind.ArrayLiteralExpression */))
+        (left.kind === 212 /* SyntaxKind.ObjectLiteralExpression */ || left.kind === 211 /* 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 */ &&
+        while (parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */ ||
+            (parent.kind === 228 /* 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 === 55 /* SyntaxKind.AmpersandAmpersandToken */ || parent.kind === 247 /* SyntaxKind.IfStatement */)
+            checkTestingKnownTruthyType(c, left, leftType, parent.kind === 247 /* SyntaxKind.IfStatement */ ? parent.thenStatement : undefined);
         if (operator !== 60 /* SyntaxKind.QuestionQuestionToken */)
             checkTruthinessOfType(c, leftType, left);
     }
@@ -266,12 +267,12 @@ function checkBinaryLikeExpressionWorker(c, errorNode, left, operator, right, le
             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));
+                    c.error(errorNode.operatorToken, 622 /* 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);
+            const leftOk = checkArithmeticOperandType(c, left, leftType, 543 /* 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, 544 /* 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 */)) ||
@@ -283,7 +284,7 @@ function checkBinaryLikeExpressionWorker(c, errorNode, left, operator, right, le
                     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 */);
+                    c.error(errorNode, 930 /* Diagnostics.Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later */);
                 resultType = c.bigintType;
             }
             else {
@@ -351,7 +352,7 @@ function checkBinaryLikeExpressionWorker(c, errorNode, left, operator, right, le
                         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');
+                    c.error(errorNode, 968 /* 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))
@@ -402,7 +403,7 @@ function checkBinaryLikeExpressionWorker(c, errorNode, left, operator, right, le
                 isSideEffectFree(left) &&
                 !isIndirectCall(left.parent) &&
                 !isInMultipleJsxRootsError(left))
-                c.error(left, 827 /* Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects */);
+                c.error(left, 834 /* Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects */);
             return rightType;
     }
     return c.errorType;
@@ -412,7 +413,7 @@ 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)
+        if (d.message === 798 /* Diagnostics.JSX_expressions_must_have_one_parent_element */ && d.pos <= start && start < d.end)
             return true;
     return false;
 }
@@ -442,7 +443,7 @@ function checkForDisallowedESSymbolOperand(c, left, right, leftType, rightType,
         offending = right;
     if (offending === undefined)
         return true;
-    c.error(offending, 635 /* Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol */, tokenToString(operator));
+    c.error(offending, 642 /* Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol */, tokenToString(operator));
     return false;
 }
 function isRelated(c, check, left, right) {
@@ -496,10 +497,10 @@ function reportOperatorError(c, leftType, operator, rightType, errorNode, check)
         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]);
+            errorAndMaybeSuggestAwait(c, errorNode, wouldWorkWithAwait, 548 /* 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]);
+    errorAndMaybeSuggestAwait(c, errorNode, wouldWorkWithAwait, 546 /* 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))
@@ -510,30 +511,30 @@ function checkAssignmentOperator(c, left, operator, right, leftType, rightType)
     let targetType = leftType;
     if (operator >= 64 /* SyntaxKind.FirstCompoundAssignment */ &&
         operator <= 78 /* SyntaxKind.LastCompoundAssignment */ &&
-        left.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        left.kind === 213 /* 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 */)) {
+    if (checkReferenceExpression(c, left, 545 /* Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access */, 918 /* 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 */ &&
+            left.kind === 213 /* 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 */;
+                    590 /* 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 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
         case 13 /* SyntaxKind.RegularExpressionLiteral */:
-        case 232 /* SyntaxKind.ClassExpression */:
-        case 219 /* SyntaxKind.FunctionExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 220 /* SyntaxKind.FunctionExpression */:
             return true;
     }
     return false;
@@ -543,7 +544,7 @@ function checkNaNEquality(c, errorNode, operator, left, right) {
     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');
+    const err = c.error(errorNode, 973 /* 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 */ ? '!' : '';
@@ -578,10 +579,10 @@ function checkShiftAmount(c, left, operator, right, errorNode) {
     if (result.kind !== 1 /* EvaluatedKind.Number */ || Math.abs(result.numberValue) < 32)
         return;
     let container = right.parent.parent;
-    while (container.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    while (container.kind === 219 /* 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 */, [
+    c.addErrorOrSuggestion(container.kind === 307 /* SyntaxKind.EnumMember */, createDiagnosticForNode(errorNode, 1655 /* Diagnostics.This_operation_can_be_simplified_This_shift_is_identical_to_0_1_2 */, [
         getSourceTextOfNode(file, left),
         tokenToString(operator),
         String(result.numberValue % 32),
@@ -592,12 +593,12 @@ function checkInstanceOfExpression(c, left, right, leftType, rightType, checkMod
         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 */);
+        c.error(left, 541 /* 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 */);
+    checkTypeAssignableTo(c, getReturnTypeOfSignature(c, signature), c.booleanType, right, 988 /* 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. */
@@ -616,11 +617,11 @@ export function resolveInstanceofExpression(c, node, checkMode) {
                 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 */);
+                return resolveCall(c, node, callSignatures, checkMode, 0 /* SignatureFlags.None */, 987 /* 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 */);
+            c.error(right, 542 /* 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);
         }
     }
@@ -664,7 +665,7 @@ function checkInExpression(c, left, right, leftType, rightType) {
     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));
+            c.error(right, 788 /* 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;
 }
@@ -712,8 +713,8 @@ export function checkTruthinessOfType(c, t, node) {
     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 */);
+            ? 999 /* Diagnostics.This_kind_of_expression_is_always_truthy */
+            : 1000 /* Diagnostics.This_kind_of_expression_is_always_falsy */);
     return t;
 }
 function getSyntacticTruthySemantics(c, nodeIn) {
@@ -724,23 +725,23 @@ function getSyntacticTruthySemantics(c, nodeIn) {
             const text = getText(node);
             return text === '0' || text === '1' ? 3 /* PredicateSemantics.Sometimes */ : 1 /* PredicateSemantics.Always */;
         }
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 221 /* 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 233 /* SyntaxKind.ClassExpression */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 286 /* SyntaxKind.JsxElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
         case 13 /* SyntaxKind.RegularExpressionLiteral */:
             return 1 /* PredicateSemantics.Always */;
-        case 223 /* SyntaxKind.VoidExpression */:
+        case 224 /* 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 */: {
+        case 229 /* SyntaxKind.ConditionalExpression */: {
             const cond = node;
             return getSyntacticTruthySemantics(c, cond.whenTrue) | getSyntacticTruthySemantics(c, cond.whenFalse);
         }
@@ -753,42 +754,42 @@ function getSyntacticTruthySemantics(c, nodeIn) {
 }
 function checkNullishCoalesceOperands(c, left, right) {
     const grandparent = left.parent.parent;
-    if (grandparent.kind === 227 /* SyntaxKind.BinaryExpression */) {
+    if (grandparent.kind === 228 /* 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));
+        if (outer.left.kind === 228 /* SyntaxKind.BinaryExpression */ && outer.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */)
+            grammarErrorOnNode(c, outer.left, 1158 /* 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 */) {
+    else if (left.kind === 228 /* 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 */));
+            grammarErrorOnNode(c, left, 1158 /* Diagnostics.X_0_and_1_operations_cannot_be_mixed_without_parentheses */, tokenToString(operator), tokenToString(60 /* SyntaxKind.QuestionQuestionToken */));
     }
-    else if (right.kind === 227 /* SyntaxKind.BinaryExpression */) {
+    else if (right.kind === 228 /* 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));
+            grammarErrorOnNode(c, right, 1158 /* 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 */);
+        c.error(leftTarget, 998 /* 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 */);
+        c.error(leftTarget, 996 /* 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 225 /* SyntaxKind.AwaitExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
+        case 238 /* SyntaxKind.MetaProperty */:
+        case 216 /* SyntaxKind.NewExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 231 /* SyntaxKind.YieldExpression */:
         case 109 /* SyntaxKind.ThisKeyword */:
             return 3 /* PredicateSemantics.Sometimes */;
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* SyntaxKind.BinaryExpression */: {
             const binary = node;
             switch (binary.operatorToken.kind) {
                 case 56 /* SyntaxKind.BarBarToken */:
@@ -799,13 +800,20 @@ function getSyntacticNullishnessSemantics(c, nodeIn) {
                 // 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);
+                // The left operand when it isn't nullish, otherwise the right operand.
+                case 60 /* SyntaxKind.QuestionQuestionToken */:
+                case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: {
+                    const left = getSyntacticNullishnessSemantics(c, binary.left);
+                    let result = left & 2 /* PredicateSemantics.Never */;
+                    if ((left & 1 /* PredicateSemantics.Always */) !== 0)
+                        result |= getSyntacticNullishnessSemantics(c, binary.right);
+                    return result;
+                }
             }
             return 2 /* PredicateSemantics.Never */;
         }
-        case 228 /* SyntaxKind.ConditionalExpression */: {
+        case 229 /* SyntaxKind.ConditionalExpression */: {
             const cond = node;
             return getSyntacticNullishnessSemantics(c, cond.whenTrue) | getSyntacticNullishnessSemantics(c, cond.whenFalse);
         }
@@ -838,7 +846,7 @@ export function checkTestingKnownTruthyType(c, condExpr, condType, body) {
         return;
     let expr = skipParentheses(condExpr);
     checkTestingKnownTruthyTypeWorker(c, expr, condType, body);
-    while (expr.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    while (expr.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         (expr.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ ||
             expr.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */)) {
         expr = skipParentheses(expr.left);
@@ -846,7 +854,7 @@ export function checkTestingKnownTruthyType(c, condExpr, condType, body) {
     }
 }
 function isLogicalOrCoalescingExpression(node) {
-    return (node.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    return (node.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         isLogicalOrCoalescingOperator(node.operatorToken.kind));
 }
 function checkTestingKnownTruthyTypeWorker(c, condExpr, condType, body) {
@@ -858,17 +866,17 @@ function checkTestingKnownTruthyTypeWorker(c, condExpr, condType, body) {
         return;
     }
     const t = location !== condExpr ? checkExpression(c, location) : condType;
-    if ((t.flags & 32768 /* TypeFlags.EnumLiteral */) !== 0 && location.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    if ((t.flags & 32768 /* TypeFlags.EnumLiteral */) !== 0 && location.kind === 213 /* 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');
+            c.error(location, 973 /* Diagnostics.This_condition_will_always_return_0 */, truthy ? 'true' : 'false');
             return;
         }
     }
-    const isPropertyExpressionCast = location.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+    const isPropertyExpressionCast = location.kind === 213 /* SyntaxKind.PropertyAccessExpression */ &&
         isTypeAssertion(location.expression);
     if (!hasTypeFacts(c, t, 4194304 /* TypeFacts.Truthy */) || isPropertyExpressionCast)
         return;
@@ -880,29 +888,29 @@ function checkTestingKnownTruthyTypeWorker(c, condExpr, condType, body) {
     let testedNode = undefined;
     if (location.kind === 79 /* SyntaxKind.Identifier */)
         testedNode = location;
-    else if (location.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    else if (location.kind === 213 /* 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 */ &&
+        ((condExpr.parent.kind === 228 /* 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 */)]);
+        errorAndMaybeSuggestAwait(c, location, true, 940 /* 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 */);
+        c.error(location, 913 /* 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 */;
+    return n.kind === 218 /* SyntaxKind.TypeAssertionExpression */ || n.kind === 236 /* SyntaxKind.AsExpression */;
 }
 function isSymbolUsedInBinaryExpressionChain(c, nodeIn, testedSymbol) {
     let node = nodeIn;
-    while (node.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+    while (node.kind === 228 /* SyntaxKind.BinaryExpression */ &&
         node.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */) {
         if (node.right.forEachChild(new SymbolUseFinder(c, testedSymbol)))
             return true;
@@ -945,7 +953,7 @@ class ConditionBodyUseFinder extends NodeVisitor {
         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 */))
+                (this.testedNode.kind === 79 /* SyntaxKind.Identifier */ && this.testedNode.parent.kind === 228 /* SyntaxKind.BinaryExpression */))
                 return true;
             let tested = this.testedNode.parent;
             let child = node.parent;
@@ -954,14 +962,14 @@ class ConditionBodyUseFinder extends NodeVisitor {
                     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 (tested.kind === 213 /* SyntaxKind.PropertyAccessExpression */ && child.kind === 213 /* 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 */) {
+                else if (tested.kind === 215 /* SyntaxKind.CallExpression */ && child.kind === 215 /* SyntaxKind.CallExpression */) {
                     child = getExpression(child);
                     tested = getExpression(tested);
                 }
@@ -983,8 +991,8 @@ function isSideEffectFree(expr) {
         case 79 /* SyntaxKind.Identifier */:
         case 10 /* SyntaxKind.StringLiteral */:
         case 13 /* SyntaxKind.RegularExpressionLiteral */:
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
-        case 229 /* SyntaxKind.TemplateExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
+        case 230 /* SyntaxKind.TemplateExpression */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
         case 8 /* SyntaxKind.NumericLiteral */:
         case 9 /* SyntaxKind.BigIntLiteral */:
@@ -992,27 +1000,27 @@ function isSideEffectFree(expr) {
         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 */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 223 /* SyntaxKind.TypeOfExpression */:
+        case 237 /* SyntaxKind.NonNullExpression */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 286 /* SyntaxKind.JsxElement */:
             return true;
-        case 228 /* SyntaxKind.ConditionalExpression */: {
+        case 229 /* SyntaxKind.ConditionalExpression */: {
             const cond = node;
             return isSideEffectFree(cond.whenTrue) && isSideEffectFree(cond.whenFalse);
         }
-        case 227 /* SyntaxKind.BinaryExpression */: {
+        case 228 /* SyntaxKind.BinaryExpression */: {
             const binary = node;
             if (isAssignmentOperator(binary.operatorToken.kind))
                 return false;
             return isSideEffectFree(binary.left) && isSideEffectFree(binary.right);
         }
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
             switch (node.operator) {
                 case 53 /* SyntaxKind.ExclamationToken */:
                 case 39 /* SyntaxKind.PlusToken */:
@@ -1029,12 +1037,12 @@ function isIndirectCall(node) {
     const left = node.left;
     const right = node.right;
     const parent = node.parent;
-    if (parent.kind !== 218 /* SyntaxKind.ParenthesizedExpression */ ||
+    if (parent.kind !== 219 /* 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 */;
+    const called = (grand.kind === 215 /* SyntaxKind.CallExpression */ && getExpression(grand) === parent) ||
+        grand.kind === 217 /* SyntaxKind.TaggedTemplateExpression */;
     return called && (isAccessExpression(right) || (right.kind === 79 /* SyntaxKind.Identifier */ && getText(right) === 'eval'));
 }