typescript 4.6.1-rc → 4.6.3

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = "".concat(ts.versionMajorMinor, ".1-rc");
+    ts.version = "4.6.3";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -4840,6 +4840,8 @@ var ts;
         TypeFlags[TypeFlags["ESSymbolLike"] = 12288] = "ESSymbolLike";
         TypeFlags[TypeFlags["VoidLike"] = 49152] = "VoidLike";
         /* @internal */
+        TypeFlags[TypeFlags["DefinitelyNonNullable"] = 470302716] = "DefinitelyNonNullable";
+        /* @internal */
         TypeFlags[TypeFlags["DisjointDomains"] = 469892092] = "DisjointDomains";
         TypeFlags[TypeFlags["UnionOrIntersection"] = 3145728] = "UnionOrIntersection";
         TypeFlags[TypeFlags["StructuredType"] = 3670016] = "StructuredType";
@@ -8081,6 +8083,8 @@ var ts;
         Property_0_cannot_have_an_initializer_because_it_is_marked_abstract: diag(1267, ts.DiagnosticCategory.Error, "Property_0_cannot_have_an_initializer_because_it_is_marked_abstract_1267", "Property '{0}' cannot have an initializer because it is marked abstract."),
         An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type: diag(1268, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type_1268", "An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type."),
         Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided: diag(1269, ts.DiagnosticCategory.Error, "Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided_1269", "Cannot use 'export import' on a type or type-only namespace when the '--isolatedModules' flag is provided."),
+        Decorator_function_return_type_0_is_not_assignable_to_type_1: diag(1270, ts.DiagnosticCategory.Error, "Decorator_function_return_type_0_is_not_assignable_to_type_1_1270", "Decorator function return type '{0}' is not assignable to type '{1}'."),
+        Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any: diag(1271, ts.DiagnosticCategory.Error, "Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any_1271", "Decorator function return type is '{0}' but is expected to be 'void' or 'any'."),
         with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."),
         await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."),
         Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern: diag(1312, ts.DiagnosticCategory.Error, "Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_1312", "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern."),
@@ -31350,18 +31354,8 @@ var ts;
             if (tryParseSemicolon()) {
                 return;
             }
-            // If an initializer was parsed but there is still an error in finding the next semicolon,
-            // we generally know there was an error already reported in the initializer...
-            //   class Example { a = new Map([), ) }
-            //                                ~
             if (initializer) {
-                // ...unless we've found the start of a block after a property declaration, in which
-                // case we can know that regardless of the initializer we should complain on the block.
-                //   class Example { a = 0 {} }
-                //                         ~
-                if (token() === 18 /* OpenBraceToken */) {
-                    parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(26 /* SemicolonToken */));
-                }
+                parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(26 /* SemicolonToken */));
                 return;
             }
             parseErrorForMissingSemicolonAfter(name);
@@ -46941,8 +46935,7 @@ var ts;
         IntersectionState[IntersectionState["Source"] = 1] = "Source";
         IntersectionState[IntersectionState["Target"] = 2] = "Target";
         IntersectionState[IntersectionState["PropertyCheck"] = 4] = "PropertyCheck";
-        IntersectionState[IntersectionState["UnionIntersectionCheck"] = 8] = "UnionIntersectionCheck";
-        IntersectionState[IntersectionState["InPropertyCheck"] = 16] = "InPropertyCheck";
+        IntersectionState[IntersectionState["InPropertyCheck"] = 8] = "InPropertyCheck";
     })(IntersectionState || (IntersectionState = {}));
     var RecursionFlags;
     (function (RecursionFlags) {
@@ -63228,11 +63221,11 @@ var ts;
             var overflow = false;
             var overrideNextErrorInfo = 0; // How many `reportRelationError` calls should be skipped in the elaboration pyramid
             var lastSkippedInfo;
-            var incompatibleStack = [];
+            var incompatibleStack;
             var inPropertyCheck = false;
             ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
             var result = isRelatedTo(source, target, 3 /* Both */, /*reportErrors*/ !!errorNode, headMessage);
-            if (incompatibleStack.length) {
+            if (incompatibleStack) {
                 reportIncompatibleStack();
             }
             if (overflow) {
@@ -63289,19 +63282,19 @@ var ts;
                 return {
                     errorInfo: errorInfo,
                     lastSkippedInfo: lastSkippedInfo,
-                    incompatibleStack: incompatibleStack.slice(),
+                    incompatibleStack: incompatibleStack === null || incompatibleStack === void 0 ? void 0 : incompatibleStack.slice(),
                     overrideNextErrorInfo: overrideNextErrorInfo,
-                    relatedInfo: !relatedInfo ? undefined : relatedInfo.slice()
+                    relatedInfo: relatedInfo === null || relatedInfo === void 0 ? void 0 : relatedInfo.slice(),
                 };
             }
             function reportIncompatibleError(message, arg0, arg1, arg2, arg3) {
                 overrideNextErrorInfo++; // Suppress the next relation error
                 lastSkippedInfo = undefined; // Reset skipped info cache
-                incompatibleStack.push([message, arg0, arg1, arg2, arg3]);
+                (incompatibleStack || (incompatibleStack = [])).push([message, arg0, arg1, arg2, arg3]);
             }
             function reportIncompatibleStack() {
-                var stack = incompatibleStack;
-                incompatibleStack = [];
+                var stack = incompatibleStack || [];
+                incompatibleStack = undefined;
                 var info = lastSkippedInfo;
                 lastSkippedInfo = undefined;
                 if (stack.length === 1) {
@@ -63407,7 +63400,7 @@ var ts;
             }
             function reportError(message, arg0, arg1, arg2, arg3) {
                 ts.Debug.assert(!!errorNode);
-                if (incompatibleStack.length)
+                if (incompatibleStack)
                     reportIncompatibleStack();
                 if (message.elidedInCompatabilityPyramid)
                     return;
@@ -63423,7 +63416,7 @@ var ts;
                 }
             }
             function reportRelationError(message, source, target) {
-                if (incompatibleStack.length)
+                if (incompatibleStack)
                     reportIncompatibleStack();
                 var _a = getTypeNamesForErrorDisplay(source, target), sourceType = _a[0], targetType = _a[1];
                 var generalizedSource = source;
@@ -63535,7 +63528,9 @@ var ts;
                     if (isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors ? reportError : undefined)) {
                         return -1 /* True */;
                     }
-                    reportErrorResults(originalSource, originalTarget, 0 /* False */, !!(ts.getObjectFlags(originalSource) & 2048 /* JsxAttributes */));
+                    if (reportErrors) {
+                        reportErrorResults(originalSource, originalTarget, originalSource, originalTarget, headMessage);
+                    }
                     return 0 /* False */;
                 }
                 // Normalize the source and target types: Turn fresh literal types into regular literal types,
@@ -63547,7 +63542,12 @@ var ts;
                 if (source === target)
                     return -1 /* True */;
                 if (relation === identityRelation) {
-                    return isIdenticalTo(source, target, recursionFlags);
+                    if (source.flags !== target.flags)
+                        return 0 /* False */;
+                    if (source.flags & 67358815 /* Singleton */)
+                        return -1 /* True */;
+                    traceUnionsOrIntersectionsTooLarge(source, target);
+                    return recursiveTypeRelatedTo(source, target, /*reportErrors*/ false, 0 /* None */, recursionFlags);
                 }
                 // We fastpath comparing a type parameter to exactly its constraint, as this is _super_ common,
                 // and otherwise, for type parameters in large unions, causes us to need to compare the union to itself,
@@ -63557,163 +63557,130 @@ var ts;
                 if (source.flags & 262144 /* TypeParameter */ && getConstraintOfType(source) === target) {
                     return -1 /* True */;
                 }
-                // Try to see if we're relating something like `Foo` -> `Bar | null | undefined`.
-                // If so, reporting the `null` and `undefined` in the type is hardly useful.
-                // First, see if we're even relating an object type to a union.
-                // Then see if the target is stripped down to a single non-union type.
-                // Note
-                //  * We actually want to remove null and undefined naively here (rather than using getNonNullableType),
-                //    since we don't want to end up with a worse error like "`Foo` is not assignable to `NonNullable<T>`"
-                //    when dealing with generics.
-                //  * We also don't deal with primitive source types, since we already halt elaboration below.
-                if (target.flags & 1048576 /* Union */ && source.flags & 524288 /* Object */ &&
-                    target.types.length <= 3 && maybeTypeOfKind(target, 98304 /* Nullable */)) {
-                    var nullStrippedTarget = extractTypesOfKind(target, ~98304 /* Nullable */);
-                    if (!(nullStrippedTarget.flags & (1048576 /* Union */ | 131072 /* Never */))) {
-                        target = getNormalizedType(nullStrippedTarget, /*writing*/ true);
-                    }
-                    if (source === nullStrippedTarget)
-                        return -1 /* True */;
+                // See if we're relating a definitely non-nullable type to a union that includes null and/or undefined
+                // plus a single non-nullable type. If so, remove null and/or undefined from the target type.
+                if (source.flags & 470302716 /* DefinitelyNonNullable */ && target.flags & 1048576 /* Union */) {
+                    var types = target.types;
+                    var candidate = types.length === 2 && types[0].flags & 98304 /* Nullable */ ? types[1] :
+                        types.length === 3 && types[0].flags & 98304 /* Nullable */ && types[1].flags & 98304 /* Nullable */ ? types[2] :
+                            undefined;
+                    if (candidate && !(candidate.flags & 98304 /* Nullable */)) {
+                        target = getNormalizedType(candidate, /*writing*/ true);
+                        if (source === target)
+                            return -1 /* True */;
+                    }
                 }
                 if (relation === comparableRelation && !(target.flags & 131072 /* Never */) && isSimpleTypeRelatedTo(target, source, relation) ||
                     isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined))
                     return -1 /* True */;
-                var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 2048 /* JsxAttributes */);
-                var isPerformingExcessPropertyChecks = !(intersectionState & 2 /* Target */) && (isObjectLiteralType(source) && ts.getObjectFlags(source) & 16384 /* FreshLiteral */);
-                if (isPerformingExcessPropertyChecks) {
-                    if (hasExcessProperties(source, target, reportErrors)) {
+                if (source.flags & 469499904 /* StructuredOrInstantiable */ || target.flags & 469499904 /* StructuredOrInstantiable */) {
+                    var isPerformingExcessPropertyChecks = !(intersectionState & 2 /* Target */) && (isObjectLiteralType(source) && ts.getObjectFlags(source) & 16384 /* FreshLiteral */);
+                    if (isPerformingExcessPropertyChecks) {
+                        if (hasExcessProperties(source, target, reportErrors)) {
+                            if (reportErrors) {
+                                reportRelationError(headMessage, source, originalTarget.aliasSymbol ? originalTarget : target);
+                            }
+                            return 0 /* False */;
+                        }
+                    }
+                    var isPerformingCommonPropertyChecks = relation !== comparableRelation && !(intersectionState & 2 /* Target */) &&
+                        source.flags & (131068 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source !== globalObjectType &&
+                        target.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target) &&
+                        (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source));
+                    var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 2048 /* JsxAttributes */);
+                    if (isPerformingCommonPropertyChecks && !hasCommonProperties(source, target, isComparingJsxAttributes)) {
                         if (reportErrors) {
-                            reportRelationError(headMessage, source, originalTarget.aliasSymbol ? originalTarget : target);
+                            var sourceString = typeToString(originalSource.aliasSymbol ? originalSource : source);
+                            var targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target);
+                            var calls = getSignaturesOfType(source, 0 /* Call */);
+                            var constructs = getSignaturesOfType(source, 1 /* Construct */);
+                            if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, 1 /* Source */, /*reportErrors*/ false) ||
+                                constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, 1 /* Source */, /*reportErrors*/ false)) {
+                                reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, sourceString, targetString);
+                            }
+                            else {
+                                reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, sourceString, targetString);
+                            }
                         }
                         return 0 /* False */;
                     }
-                }
-                var isPerformingCommonPropertyChecks = relation !== comparableRelation && !(intersectionState & 2 /* Target */) &&
-                    source.flags & (131068 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source !== globalObjectType &&
-                    target.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target) &&
-                    (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source));
-                if (isPerformingCommonPropertyChecks && !hasCommonProperties(source, target, isComparingJsxAttributes)) {
-                    if (reportErrors) {
-                        var sourceString = typeToString(originalSource.aliasSymbol ? originalSource : source);
-                        var targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target);
-                        var calls = getSignaturesOfType(source, 0 /* Call */);
-                        var constructs = getSignaturesOfType(source, 1 /* Construct */);
-                        if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, 1 /* Source */, /*reportErrors*/ false) ||
-                            constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, 1 /* Source */, /*reportErrors*/ false)) {
-                            reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, sourceString, targetString);
-                        }
-                        else {
-                            reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, sourceString, targetString);
-                        }
+                    traceUnionsOrIntersectionsTooLarge(source, target);
+                    var skipCaching = source.flags & 1048576 /* Union */ && source.types.length < 4 && !(target.flags & 1048576 /* Union */) ||
+                        target.flags & 1048576 /* Union */ && target.types.length < 4 && !(source.flags & 469499904 /* StructuredOrInstantiable */);
+                    var result_7 = skipCaching ?
+                        unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) :
+                        recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags);
+                    // For certain combinations involving intersections and optional, excess, or mismatched properties we need
+                    // an extra property check where the intersection is viewed as a single object. The following are motivating
+                    // examples that all should be errors, but aren't without this extra property check:
+                    //
+                    //   let obj: { a: { x: string } } & { c: number } = { a: { x: 'hello', y: 2 }, c: 5 };  // Nested excess property
+                    //
+                    //   declare let wrong: { a: { y: string } };
+                    //   let weak: { a?: { x?: number } } & { c?: string } = wrong;  // Nested weak object type
+                    //
+                    //   function foo<T extends object>(x: { a?: string }, y: T & { a: boolean }) {
+                    //     x = y;  // Mismatched property in source intersection
+                    //   }
+                    //
+                    // We suppress recursive intersection property checks because they can generate lots of work when relating
+                    // recursive intersections that are structurally similar but not exactly identical. See #37854.
+                    if (result_7 && !inPropertyCheck && (target.flags & 2097152 /* Intersection */ && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
+                        isNonGenericObjectType(target) && !isArrayType(target) && !isTupleType(target) && source.flags & 2097152 /* Intersection */ && getApparentType(source).flags & 3670016 /* StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 524288 /* NonInferrableType */); }))) {
+                        inPropertyCheck = true;
+                        result_7 &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* PropertyCheck */, recursionFlags);
+                        inPropertyCheck = false;
+                    }
+                    if (result_7) {
+                        return result_7;
                     }
-                    return 0 /* False */;
-                }
-                traceUnionsOrIntersectionsTooLarge(source, target);
-                var result = 0 /* False */;
-                var saveErrorInfo = captureErrorCalculationState();
-                if ((source.flags & 1048576 /* Union */ || target.flags & 1048576 /* Union */) && getConstituentCount(source) * getConstituentCount(target) < 4) {
-                    // We skip caching when source or target is a union with no more than three constituents.
-                    result = structuredTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */);
                 }
-                else if (source.flags & 3145728 /* UnionOrIntersection */ || target.flags & 3145728 /* UnionOrIntersection */) {
-                    result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState | 8 /* UnionIntersectionCheck */, recursionFlags);
+                if (reportErrors) {
+                    reportErrorResults(originalSource, originalTarget, source, target, headMessage);
                 }
-                if (!result && !(source.flags & 1048576 /* Union */) && (source.flags & (469499904 /* StructuredOrInstantiable */) || target.flags & 469499904 /* StructuredOrInstantiable */)) {
-                    if (result = recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags)) {
-                        resetErrorInfo(saveErrorInfo);
+                return 0 /* False */;
+            }
+            function reportErrorResults(originalSource, originalTarget, source, target, headMessage) {
+                var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
+                var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
+                source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
+                target = (originalTarget.aliasSymbol || targetHasBase) ? originalTarget : target;
+                var maybeSuppress = overrideNextErrorInfo > 0;
+                if (maybeSuppress) {
+                    overrideNextErrorInfo--;
+                }
+                if (source.flags & 524288 /* Object */ && target.flags & 524288 /* Object */) {
+                    var currentError = errorInfo;
+                    tryElaborateArrayLikeErrors(source, target, /*reportErrors*/ true);
+                    if (errorInfo !== currentError) {
+                        maybeSuppress = !!errorInfo;
+                    }
+                }
+                if (source.flags & 524288 /* Object */ && target.flags & 131068 /* Primitive */) {
+                    tryElaborateErrorsForPrimitivesAndObjects(source, target);
+                }
+                else if (source.symbol && source.flags & 524288 /* Object */ && globalObjectType === source) {
+                    reportError(ts.Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
+                }
+                else if (ts.getObjectFlags(source) & 2048 /* JsxAttributes */ && target.flags & 2097152 /* Intersection */) {
+                    var targetTypes = target.types;
+                    var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
+                    var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
+                    if (!isErrorType(intrinsicAttributes) && !isErrorType(intrinsicClassAttributes) &&
+                        (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) {
+                        // do not report top error
+                        return;
                     }
                 }
-                if (!result && source.flags & (2097152 /* Intersection */ | 262144 /* TypeParameter */)) {
-                    // The combined constraint of an intersection type is the intersection of the constraints of
-                    // the constituents. When an intersection type contains instantiable types with union type
-                    // constraints, there are situations where we need to examine the combined constraint. One is
-                    // when the target is a union type. Another is when the intersection contains types belonging
-                    // to one of the disjoint domains. For example, given type variables T and U, each with the
-                    // constraint 'string | number', the combined constraint of 'T & U' is 'string | number' and
-                    // we need to check this constraint against a union on the target side. Also, given a type
-                    // variable V constrained to 'string | number', 'V & number' has a combined constraint of
-                    // 'string & number | number & number' which reduces to just 'number'.
-                    // This also handles type parameters, as a type parameter with a union constraint compared against a union
-                    // needs to have its constraint hoisted into an intersection with said type parameter, this way
-                    // the type param can be compared with itself in the target (with the influence of its constraint to match other parts)
-                    // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)`
-                    var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* Union */));
-                    if (constraint && (source.flags & 2097152 /* Intersection */ || target.flags & 1048576 /* Union */)) {
-                        if (everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
-                            // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
-                            if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
-                                resetErrorInfo(saveErrorInfo);
-                            }
-                        }
-                    }
+                else {
+                    errorInfo = elaborateNeverIntersection(errorInfo, originalTarget);
                 }
-                // For certain combinations involving intersections and optional, excess, or mismatched properties we need
-                // an extra property check where the intersection is viewed as a single object. The following are motivating
-                // examples that all should be errors, but aren't without this extra property check:
-                //
-                //   let obj: { a: { x: string } } & { c: number } = { a: { x: 'hello', y: 2 }, c: 5 };  // Nested excess property
-                //
-                //   declare let wrong: { a: { y: string } };
-                //   let weak: { a?: { x?: number } } & { c?: string } = wrong;  // Nested weak object type
-                //
-                //   function foo<T extends object>(x: { a?: string }, y: T & { a: boolean }) {
-                //     x = y;  // Mismatched property in source intersection
-                //   }
-                //
-                // We suppress recursive intersection property checks because they can generate lots of work when relating
-                // recursive intersections that are structurally similar but not exactly identical. See #37854.
-                if (result && !inPropertyCheck && (target.flags & 2097152 /* Intersection */ && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
-                    isNonGenericObjectType(target) && !isArrayType(target) && !isTupleType(target) && source.flags & 2097152 /* Intersection */ && getApparentType(source).flags & 3670016 /* StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 524288 /* NonInferrableType */); }))) {
-                    inPropertyCheck = true;
-                    result &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* PropertyCheck */, recursionFlags);
-                    inPropertyCheck = false;
-                }
-                reportErrorResults(source, target, result, isComparingJsxAttributes);
-                return result;
-                function reportErrorResults(source, target, result, isComparingJsxAttributes) {
-                    if (!result && reportErrors) {
-                        var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource);
-                        var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget);
-                        source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source;
-                        target = (originalTarget.aliasSymbol || targetHasBase) ? originalTarget : target;
-                        var maybeSuppress = overrideNextErrorInfo > 0;
-                        if (maybeSuppress) {
-                            overrideNextErrorInfo--;
-                        }
-                        if (source.flags & 524288 /* Object */ && target.flags & 524288 /* Object */) {
-                            var currentError = errorInfo;
-                            tryElaborateArrayLikeErrors(source, target, reportErrors);
-                            if (errorInfo !== currentError) {
-                                maybeSuppress = !!errorInfo;
-                            }
-                        }
-                        if (source.flags & 524288 /* Object */ && target.flags & 131068 /* Primitive */) {
-                            tryElaborateErrorsForPrimitivesAndObjects(source, target);
-                        }
-                        else if (source.symbol && source.flags & 524288 /* Object */ && globalObjectType === source) {
-                            reportError(ts.Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead);
-                        }
-                        else if (isComparingJsxAttributes && target.flags & 2097152 /* Intersection */) {
-                            var targetTypes = target.types;
-                            var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode);
-                            var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode);
-                            if (!isErrorType(intrinsicAttributes) && !isErrorType(intrinsicClassAttributes) &&
-                                (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) {
-                                // do not report top error
-                                return result;
-                            }
-                        }
-                        else {
-                            errorInfo = elaborateNeverIntersection(errorInfo, originalTarget);
-                        }
-                        if (!headMessage && maybeSuppress) {
-                            lastSkippedInfo = [source, target];
-                            // Used by, eg, missing property checking to replace the top-level message with a more informative one
-                            return result;
-                        }
-                        reportRelationError(headMessage, source, target);
-                    }
+                if (!headMessage && maybeSuppress) {
+                    lastSkippedInfo = [source, target];
+                    // Used by, eg, missing property checking to replace the top-level message with a more informative one
+                    return;
                 }
+                reportRelationError(headMessage, source, target);
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
                 if (!ts.tracing) {
@@ -63740,21 +63707,6 @@ var ts;
                     }
                 }
             }
-            function isIdenticalTo(source, target, recursionFlags) {
-                if (source.flags !== target.flags)
-                    return 0 /* False */;
-                if (source.flags & 67358815 /* Singleton */)
-                    return -1 /* True */;
-                traceUnionsOrIntersectionsTooLarge(source, target);
-                if (source.flags & 3145728 /* UnionOrIntersection */) {
-                    var result_7 = eachTypeRelatedToSomeType(source, target);
-                    if (result_7) {
-                        result_7 &= eachTypeRelatedToSomeType(target, source);
-                    }
-                    return result_7;
-                }
-                return recursiveTypeRelatedTo(source, target, /*reportErrors*/ false, 0 /* None */, recursionFlags);
-            }
             function getTypeOfPropertyInTypes(types, name) {
                 var appendPropType = function (propTypes, type) {
                     var _a;
@@ -63853,6 +63805,41 @@ var ts;
             function shouldCheckAsExcessProperty(prop, container) {
                 return prop.valueDeclaration && container.valueDeclaration && prop.valueDeclaration.parent === container.valueDeclaration;
             }
+            function unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) {
+                // Note that these checks are specifically ordered to produce correct results. In particular,
+                // we need to deconstruct unions before intersections (because unions are always at the top),
+                // and we need to handle "each" relations before "some" relations for the same kind of type.
+                if (source.flags & 1048576 /* Union */) {
+                    return relation === comparableRelation ?
+                        someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState) :
+                        eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState);
+                }
+                if (target.flags & 1048576 /* Union */) {
+                    return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068 /* Primitive */) && !(target.flags & 131068 /* Primitive */));
+                }
+                if (target.flags & 2097152 /* Intersection */) {
+                    return typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2 /* Target */);
+                }
+                // Source is an intersection. For the comparable relation, if the target is a primitive type we hoist the
+                // constraints of all non-primitive types in the source into a new intersection. We do this because the
+                // intersection may further constrain the constraints of the non-primitive types. For example, given a type
+                // parameter 'T extends 1 | 2', the intersection 'T & 1' should be reduced to '1' such that it doesn't
+                // appear to be comparable to '2'.
+                if (relation === comparableRelation && target.flags & 131068 /* Primitive */) {
+                    var constraints = ts.sameMap(source.types, getBaseConstraintOrType);
+                    if (constraints !== source.types) {
+                        source = getIntersectionType(constraints);
+                        if (!(source.flags & 2097152 /* Intersection */)) {
+                            return isRelatedTo(source, target, 1 /* Source */, /*reportErrors*/ false);
+                        }
+                    }
+                }
+                // Check to see if any constituents of the intersection are immediately related to the target.
+                // Don't report errors though. Elaborating on whether a source constituent is related to the target is
+                // not actually useful and leads to some confusing error messages. Instead, we rely on the caller
+                // checking whether the full intersection viewed as an object is related to the target.
+                return someTypeRelatedToType(source, target, /*reportErrors*/ false, 1 /* Source */);
+            }
             function eachTypeRelatedToSomeType(source, target) {
                 var result = -1 /* True */;
                 var sourceTypes = source.types;
@@ -63888,8 +63875,11 @@ var ts;
                     }
                 }
                 if (reportErrors) {
+                    // Elaborate only if we can find a best matching type in the target union
                     var bestMatchingType = getBestMatchingType(source, target, isRelatedTo);
-                    isRelatedTo(source, bestMatchingType || targetTypes[targetTypes.length - 1], 2 /* Target */, /*reportErrors*/ true);
+                    if (bestMatchingType) {
+                        isRelatedTo(source, bestMatchingType, 2 /* Target */, /*reportErrors*/ true);
+                    }
                 }
                 return 0 /* False */;
             }
@@ -64025,7 +64015,7 @@ var ts;
                 if (overflow) {
                     return 0 /* False */;
                 }
-                var keyIntersectionState = intersectionState | (inPropertyCheck ? 16 /* InPropertyCheck */ : 0);
+                var keyIntersectionState = intersectionState | (inPropertyCheck ? 8 /* InPropertyCheck */ : 0);
                 var id = getRelationKey(source, target, keyIntersectionState, relation, /*ingnoreConstraints*/ false);
                 var entry = relation.get(id);
                 if (entry !== undefined) {
@@ -64093,6 +64083,7 @@ var ts;
                         return originalHandler(onlyUnreliable);
                     };
                 }
+                var result;
                 if (expandingFlags === 3 /* Both */) {
                     ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "recursiveTypeRelatedTo_DepthLimit", {
                         sourceId: source.id,
@@ -64102,8 +64093,13 @@ var ts;
                         depth: sourceDepth,
                         targetDepth: targetDepth
                     });
+                    result = 3 /* Maybe */;
+                }
+                else {
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* CheckTypes */, "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id });
+                    result = structuredTypeRelatedTo(source, target, reportErrors, intersectionState);
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
                 }
-                var result = expandingFlags !== 3 /* Both */ ? structuredTypeRelatedTo(source, target, reportErrors, intersectionState) : 3 /* Maybe */;
                 if (outofbandVarianceMarkerHandler) {
                     outofbandVarianceMarkerHandler = originalHandler;
                 }
@@ -64135,98 +64131,97 @@ var ts;
                 return result;
             }
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
-                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* CheckTypes */, "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id });
-                var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState);
-                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
-                return result;
-            }
-            function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState) {
                 if (intersectionState & 4 /* PropertyCheck */) {
                     return propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* None */);
                 }
-                if (intersectionState & 8 /* UnionIntersectionCheck */) {
-                    // Note that these checks are specifically ordered to produce correct results. In particular,
-                    // we need to deconstruct unions before intersections (because unions are always at the top),
-                    // and we need to handle "each" relations before "some" relations for the same kind of type.
-                    if (source.flags & 1048576 /* Union */) {
-                        return relation === comparableRelation ?
-                            someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState & ~8 /* UnionIntersectionCheck */) :
-                            eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* Primitive */), intersectionState & ~8 /* UnionIntersectionCheck */);
-                    }
-                    if (target.flags & 1048576 /* Union */) {
-                        return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068 /* Primitive */) && !(target.flags & 131068 /* Primitive */));
-                    }
-                    if (target.flags & 2097152 /* Intersection */) {
-                        return typeRelatedToEachType(getRegularTypeOfObjectLiteral(source), target, reportErrors, 2 /* Target */);
-                    }
-                    // Source is an intersection. For the comparable relation, if the target is a primitive type we hoist the
-                    // constraints of all non-primitive types in the source into a new intersection. We do this because the
-                    // intersection may further constrain the constraints of the non-primitive types. For example, given a type
-                    // parameter 'T extends 1 | 2', the intersection 'T & 1' should be reduced to '1' such that it doesn't
-                    // appear to be comparable to '2'.
-                    if (relation === comparableRelation && target.flags & 131068 /* Primitive */) {
-                        var constraints = ts.sameMap(source.types, getBaseConstraintOrType);
-                        if (constraints !== source.types) {
-                            source = getIntersectionType(constraints);
-                            if (!(source.flags & 2097152 /* Intersection */)) {
-                                return isRelatedTo(source, target, 1 /* Source */, /*reportErrors*/ false);
-                            }
+                var result;
+                var originalErrorInfo;
+                var varianceCheckFailed = false;
+                var saveErrorInfo = captureErrorCalculationState();
+                var sourceFlags = source.flags;
+                var targetFlags = target.flags;
+                if (relation === identityRelation) {
+                    // We've already checked that source.flags and target.flags are identical
+                    if (sourceFlags & 3145728 /* UnionOrIntersection */) {
+                        var result_8 = eachTypeRelatedToSomeType(source, target);
+                        if (result_8) {
+                            result_8 &= eachTypeRelatedToSomeType(target, source);
                         }
+                        return result_8;
                     }
-                    // Check to see if any constituents of the intersection are immediately related to the target.
-                    //
-                    // Don't report errors though. Checking whether a constituent is related to the source is not actually
-                    // useful and leads to some confusing error messages. Instead it is better to let the below checks
-                    // take care of this, or to not elaborate at all. For instance,
-                    //
-                    //    - For an object type (such as 'C = A & B'), users are usually more interested in structural errors.
-                    //
-                    //    - For a union type (such as '(A | B) = (C & D)'), it's better to hold onto the whole intersection
-                    //          than to report that 'D' is not assignable to 'A' or 'B'.
-                    //
-                    //    - For a primitive type or type parameter (such as 'number = A & B') there is no point in
-                    //          breaking the intersection apart.
-                    return someTypeRelatedToType(source, target, /*reportErrors*/ false, 1 /* Source */);
-                }
-                var flags = source.flags & target.flags;
-                if (relation === identityRelation && !(flags & 524288 /* Object */)) {
-                    if (flags & 4194304 /* Index */) {
+                    if (sourceFlags & 4194304 /* Index */) {
                         return isRelatedTo(source.type, target.type, 3 /* Both */, /*reportErrors*/ false);
                     }
-                    var result_8 = 0 /* False */;
-                    if (flags & 8388608 /* IndexedAccess */) {
-                        if (result_8 = isRelatedTo(source.objectType, target.objectType, 3 /* Both */, /*reportErrors*/ false)) {
-                            if (result_8 &= isRelatedTo(source.indexType, target.indexType, 3 /* Both */, /*reportErrors*/ false)) {
-                                return result_8;
+                    if (sourceFlags & 8388608 /* IndexedAccess */) {
+                        if (result = isRelatedTo(source.objectType, target.objectType, 3 /* Both */, /*reportErrors*/ false)) {
+                            if (result &= isRelatedTo(source.indexType, target.indexType, 3 /* Both */, /*reportErrors*/ false)) {
+                                return result;
                             }
                         }
                     }
-                    if (flags & 16777216 /* Conditional */) {
+                    if (sourceFlags & 16777216 /* Conditional */) {
                         if (source.root.isDistributive === target.root.isDistributive) {
-                            if (result_8 = isRelatedTo(source.checkType, target.checkType, 3 /* Both */, /*reportErrors*/ false)) {
-                                if (result_8 &= isRelatedTo(source.extendsType, target.extendsType, 3 /* Both */, /*reportErrors*/ false)) {
-                                    if (result_8 &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
-                                        if (result_8 &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
-                                            return result_8;
+                            if (result = isRelatedTo(source.checkType, target.checkType, 3 /* Both */, /*reportErrors*/ false)) {
+                                if (result &= isRelatedTo(source.extendsType, target.extendsType, 3 /* Both */, /*reportErrors*/ false)) {
+                                    if (result &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
+                                        if (result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* Both */, /*reportErrors*/ false)) {
+                                            return result;
                                         }
                                     }
                                 }
                             }
                         }
                     }
-                    if (flags & 33554432 /* Substitution */) {
+                    if (sourceFlags & 33554432 /* Substitution */) {
                         return isRelatedTo(source.substitute, target.substitute, 3 /* Both */, /*reportErrors*/ false);
                     }
-                    return 0 /* False */;
+                    if (!(sourceFlags & 524288 /* Object */)) {
+                        return 0 /* False */;
+                    }
+                }
+                else if (sourceFlags & 3145728 /* UnionOrIntersection */ || targetFlags & 3145728 /* UnionOrIntersection */) {
+                    if (result = unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState)) {
+                        return result;
+                    }
+                    if (source.flags & 2097152 /* Intersection */ || source.flags & 262144 /* TypeParameter */ && target.flags & 1048576 /* Union */) {
+                        // The combined constraint of an intersection type is the intersection of the constraints of
+                        // the constituents. When an intersection type contains instantiable types with union type
+                        // constraints, there are situations where we need to examine the combined constraint. One is
+                        // when the target is a union type. Another is when the intersection contains types belonging
+                        // to one of the disjoint domains. For example, given type variables T and U, each with the
+                        // constraint 'string | number', the combined constraint of 'T & U' is 'string | number' and
+                        // we need to check this constraint against a union on the target side. Also, given a type
+                        // variable V constrained to 'string | number', 'V & number' has a combined constraint of
+                        // 'string & number | number & number' which reduces to just 'number'.
+                        // This also handles type parameters, as a type parameter with a union constraint compared against a union
+                        // needs to have its constraint hoisted into an intersection with said type parameter, this way
+                        // the type param can be compared with itself in the target (with the influence of its constraint to match other parts)
+                        // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)`
+                        var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* Union */));
+                        if (constraint && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
+                            // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
+                            if (result = isRelatedTo(constraint, target, 1 /* Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) {
+                                resetErrorInfo(saveErrorInfo);
+                                return result;
+                            }
+                        }
+                    }
+                    // The ordered decomposition above doesn't handle all cases. Specifically, we also need to handle:
+                    // Source is instantiable (e.g. source has union or intersection constraint).
+                    // Source is an object, target is a union (e.g. { a, b: boolean } <=> { a, b: true } | { a, b: false }).
+                    // Source is an intersection, target is an object (e.g. { a } & { b } <=> { a, b }).
+                    // Source is an intersection, target is a union (e.g. { a } & { b: boolean } <=> { a, b: true } | { a, b: false }).
+                    // Source is an intersection, target instantiable (e.g. string & { tag } <=> T["a"] constrained to string & { tag }).
+                    if (!(sourceFlags & 465829888 /* Instantiable */ ||
+                        sourceFlags & 524288 /* Object */ && targetFlags & 1048576 /* Union */ ||
+                        sourceFlags & 2097152 /* Intersection */ && targetFlags & (524288 /* Object */ | 1048576 /* Union */ | 465829888 /* Instantiable */))) {
+                        return 0 /* False */;
+                    }
                 }
-                var result;
-                var originalErrorInfo;
-                var varianceCheckFailed = false;
-                var saveErrorInfo = captureErrorCalculationState();
                 // We limit alias variance probing to only object and conditional types since their alias behavior
                 // is more predictable than other, interned types, which may or may not have an alias depending on
                 // the order in which things were checked.
-                if (source.flags & (524288 /* Object */ | 16777216 /* Conditional */) && source.aliasSymbol &&
+                if (sourceFlags & (524288 /* Object */ | 16777216 /* Conditional */) && source.aliasSymbol &&
                     source.aliasTypeArguments && source.aliasSymbol === target.aliasSymbol &&
                     !(source.aliasTypeArgumentsContainsMarker || target.aliasTypeArgumentsContainsMarker)) {
                     var variances = getAliasVariances(source.aliasSymbol);
@@ -64244,7 +64239,7 @@ var ts;
                     isSingleElementGenericTupleType(target) && (target.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source) || source)) && (result = isRelatedTo(source, getTypeArguments(target)[0], 2 /* Target */))) {
                     return result;
                 }
-                if (target.flags & 262144 /* TypeParameter */) {
+                if (targetFlags & 262144 /* TypeParameter */) {
                     // A source type { [P in Q]: X } is related to a target type T if keyof T is related to Q and X is related to T[Q].
                     if (ts.getObjectFlags(source) & 32 /* Mapped */ && !source.declaration.nameType && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source), 3 /* Both */)) {
                         if (!(getMappedTypeModifiers(source) & 4 /* IncludeOptional */)) {
@@ -64256,10 +64251,10 @@ var ts;
                         }
                     }
                 }
-                else if (target.flags & 4194304 /* Index */) {
+                else if (targetFlags & 4194304 /* Index */) {
                     var targetType_1 = target.type;
                     // A keyof S is related to a keyof T if T is related to S.
-                    if (source.flags & 4194304 /* Index */) {
+                    if (sourceFlags & 4194304 /* Index */) {
                         if (result = isRelatedTo(targetType_1, source.type, 3 /* Both */, /*reportErrors*/ false)) {
                             return result;
                         }
@@ -64310,8 +64305,8 @@ var ts;
                         }
                     }
                 }
-                else if (target.flags & 8388608 /* IndexedAccess */) {
-                    if (source.flags & 8388608 /* IndexedAccess */) {
+                else if (targetFlags & 8388608 /* IndexedAccess */) {
+                    if (sourceFlags & 8388608 /* IndexedAccess */) {
                         // Relate components directly before falling back to constraint relationships
                         // A type S[K] is related to a type T[J] if S is related to T and K is related to J.
                         if (result = isRelatedTo(source.objectType, target.objectType, 3 /* Both */, reportErrors)) {
@@ -64417,7 +64412,7 @@ var ts;
                         }
                     }
                 }
-                else if (target.flags & 16777216 /* Conditional */) {
+                else if (targetFlags & 16777216 /* Conditional */) {
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(target, targetStack, targetDepth, 10)) {
@@ -64442,8 +64437,8 @@ var ts;
                         }
                     }
                 }
-                else if (target.flags & 134217728 /* TemplateLiteral */) {
-                    if (source.flags & 134217728 /* TemplateLiteral */) {
+                else if (targetFlags & 134217728 /* TemplateLiteral */) {
+                    if (sourceFlags & 134217728 /* TemplateLiteral */) {
                         if (relation === comparableRelation) {
                             return templateLiteralTypesDefinitelyUnrelated(source, target) ? 0 /* False */ : -1 /* True */;
                         }
@@ -64455,11 +64450,11 @@ var ts;
                         return -1 /* True */;
                     }
                 }
-                if (source.flags & 8650752 /* TypeVariable */) {
-                    // IndexedAccess comparisons are handled above in the `target.flags & TypeFlage.IndexedAccess` branch
-                    if (!(source.flags & 8388608 /* IndexedAccess */ && target.flags & 8388608 /* IndexedAccess */)) {
+                if (sourceFlags & 8650752 /* TypeVariable */) {
+                    // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
+                    if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
                         var constraint = getConstraintOfType(source);
-                        if (!constraint || (source.flags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
+                        if (!constraint || (sourceFlags & 262144 /* TypeParameter */ && constraint.flags & 1 /* Any */)) {
                             // A type variable with no constraint is not related to the non-primitive object type.
                             if (result = isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */), 3 /* Both */)) {
                                 resetErrorInfo(saveErrorInfo);
@@ -64472,7 +64467,7 @@ var ts;
                             return result;
                         }
                         // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example
-                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && !(target.flags & source.flags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
+                        else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* Source */, reportErrors && !(targetFlags & sourceFlags & 262144 /* TypeParameter */), /*headMessage*/ undefined, intersectionState)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
                         }
@@ -64489,14 +64484,14 @@ var ts;
                         }
                     }
                 }
-                else if (source.flags & 4194304 /* Index */) {
+                else if (sourceFlags & 4194304 /* Index */) {
                     if (result = isRelatedTo(keyofConstraintType, target, 1 /* Source */, reportErrors)) {
                         resetErrorInfo(saveErrorInfo);
                         return result;
                     }
                 }
-                else if (source.flags & 134217728 /* TemplateLiteral */ && !(target.flags & 524288 /* Object */)) {
-                    if (!(target.flags & 134217728 /* TemplateLiteral */)) {
+                else if (sourceFlags & 134217728 /* TemplateLiteral */ && !(targetFlags & 524288 /* Object */)) {
+                    if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
                         var constraint = getBaseConstraintOfType(source);
                         if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, 1 /* Source */, reportErrors))) {
                             resetErrorInfo(saveErrorInfo);
@@ -64504,8 +64499,8 @@ var ts;
                         }
                     }
                 }
-                else if (source.flags & 268435456 /* StringMapping */) {
-                    if (target.flags & 268435456 /* StringMapping */ && source.symbol === target.symbol) {
+                else if (sourceFlags & 268435456 /* StringMapping */) {
+                    if (targetFlags & 268435456 /* StringMapping */ && source.symbol === target.symbol) {
                         if (result = isRelatedTo(source.type, target.type, 3 /* Both */, reportErrors)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
@@ -64519,14 +64514,14 @@ var ts;
                         }
                     }
                 }
-                else if (source.flags & 16777216 /* Conditional */) {
+                else if (sourceFlags & 16777216 /* Conditional */) {
                     // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive
                     // conditional type and bail out with a Ternary.Maybe result.
                     if (isDeeplyNestedType(source, sourceStack, sourceDepth, 10)) {
                         resetErrorInfo(saveErrorInfo);
                         return 3 /* Maybe */;
                     }
-                    if (target.flags & 16777216 /* Conditional */) {
+                    if (targetFlags & 16777216 /* Conditional */) {
                         // Two conditional types 'T1 extends U1 ? X1 : Y1' and 'T2 extends U2 ? X2 : Y2' are related if
                         // one of T1 and T2 is related to the other, U1 and U2 are identical types, X1 is related to X2,
                         // and Y1 is related to Y2.
@@ -64586,9 +64581,10 @@ var ts;
                         }
                         return 0 /* False */;
                     }
-                    var sourceIsPrimitive = !!(source.flags & 131068 /* Primitive */);
+                    var sourceIsPrimitive = !!(sourceFlags & 131068 /* Primitive */);
                     if (relation !== identityRelation) {
                         source = getApparentType(source);
+                        sourceFlags = source.flags;
                     }
                     else if (isGenericMappedType(source)) {
                         return 0 /* False */;
@@ -64630,7 +64626,7 @@ var ts;
                     // In a check of the form X = A & B, we will have previously checked if A relates to X or B relates
                     // to X. Failing both of those we want to check if the aggregation of A and B's members structurally
                     // relates to X. Thus, we include intersection types on the source side here.
-                    if (source.flags & (524288 /* Object */ | 2097152 /* Intersection */) && target.flags & 524288 /* Object */) {
+                    if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 524288 /* Object */) {
                         // Report structural errors only if we haven't reported any errors yet
                         var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo.errorInfo && !sourceIsPrimitive;
                         result = propertiesRelatedTo(source, target, reportStructuralErrors, /*excludedProperties*/ undefined, intersectionState);
@@ -64654,7 +64650,7 @@ var ts;
                     // there exists a constituent of T for every combination of the discriminants of S
                     // with respect to T. We do not report errors here, as we will use the existing
                     // error result from checking each constituent of the union.
-                    if (source.flags & (524288 /* Object */ | 2097152 /* Intersection */) && target.flags & 1048576 /* Union */) {
+                    if (sourceFlags & (524288 /* Object */ | 2097152 /* Intersection */) && targetFlags & 1048576 /* Union */) {
                         var objectOnlyTarget = extractTypesOfKind(target, 524288 /* Object */ | 2097152 /* Intersection */ | 33554432 /* Substitution */);
                         if (objectOnlyTarget.flags & 1048576 /* Union */) {
                             var result_9 = typeRelatedToDiscriminatedType(source, objectOnlyTarget);
@@ -65169,7 +65165,6 @@ var ts;
                     }
                 }
                 var result = -1 /* True */;
-                var saveErrorInfo = captureErrorCalculationState();
                 var incompatibleReporter = kind === 1 /* Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn;
                 var sourceObjectFlags = ts.getObjectFlags(source);
                 var targetObjectFlags = ts.getObjectFlags(target);
@@ -65210,6 +65205,7 @@ var ts;
                 else {
                     outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) {
                         var t = targetSignatures_1[_i];
+                        var saveErrorInfo = captureErrorCalculationState();
                         // Only elaborate errors from the first failure
                         var shouldElaborateErrors = reportErrors;
                         for (var _c = 0, sourceSignatures_1 = sourceSignatures; _c < sourceSignatures_1.length; _c++) {
@@ -68380,9 +68376,6 @@ var ts;
                 getUnionType(ts.map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) :
                 mapType(type, mapper);
         }
-        function getConstituentCount(type) {
-            return type.flags & 1048576 /* Union */ ? type.types.length : 1;
-        }
         function extractTypesOfKind(type, kind) {
             return filterType(type, function (t) { return (t.flags & kind) !== 0; });
         }
@@ -69956,7 +69949,7 @@ var ts;
             var substituteConstraints = !(checkMode && checkMode & 2 /* Inferential */) &&
                 someType(type, isGenericTypeWithUnionConstraint) &&
                 (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode));
-            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ && !isMappedTypeGenericIndexedAccess(t) ? getBaseConstraintOrType(t) : t; }) : type;
+            return substituteConstraints ? mapType(type, function (t) { return t.flags & 465829888 /* Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type;
         }
         function isExportOrExportExpression(location) {
             return !!ts.findAncestor(location, function (n) {
@@ -70028,6 +70021,9 @@ var ts;
                             if (parentType && parentType.flags & 1048576 /* Union */ && !(parent.kind === 163 /* Parameter */ && isSymbolAssigned(symbol))) {
                                 var pattern = declaration.parent;
                                 var narrowedType = getFlowTypeOfReference(pattern, parentType, parentType, /*flowContainer*/ undefined, location.flowNode);
+                                if (narrowedType.flags & 131072 /* Never */) {
+                                    return neverType;
+                                }
                                 return getBindingElementTypeFromParentType(declaration, narrowedType);
                             }
                         }
@@ -76048,21 +76044,22 @@ var ts;
                     if (links.type === unknownType) {
                         links.type = getTypeFromBindingPattern(declaration.name);
                     }
-                    assignBindingElementTypes(declaration.name);
+                    assignBindingElementTypes(declaration.name, links.type);
                 }
             }
         }
         // When contextual typing assigns a type to a parameter that contains a binding pattern, we also need to push
         // the destructured type into the contained binding elements.
-        function assignBindingElementTypes(pattern) {
+        function assignBindingElementTypes(pattern, parentType) {
             for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) {
                 var element = _a[_i];
                 if (!ts.isOmittedExpression(element)) {
+                    var type = getBindingElementTypeFromParentType(element, parentType);
                     if (element.name.kind === 79 /* Identifier */) {
-                        getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element);
+                        getSymbolLinks(getSymbolOfNode(element)).type = type;
                     }
                     else {
-                        assignBindingElementTypes(element.name);
+                        assignBindingElementTypes(element.name, type);
                     }
                 }
             }
@@ -79803,28 +79800,24 @@ var ts;
             if (returnType.flags & 1 /* Any */) {
                 return;
             }
+            var headMessage;
             var expectedReturnType;
-            var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node);
-            var errorInfo;
             switch (node.parent.kind) {
                 case 256 /* ClassDeclaration */:
+                    headMessage = ts.Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
                     var classSymbol = getSymbolOfNode(node.parent);
                     var classConstructorType = getTypeOfSymbol(classSymbol);
                     expectedReturnType = getUnionType([classConstructorType, voidType]);
                     break;
-                case 163 /* Parameter */:
-                    expectedReturnType = voidType;
-                    errorInfo = ts.chainDiagnosticMessages(
-                    /*details*/ undefined, ts.Diagnostics.The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any);
-                    break;
                 case 166 /* PropertyDeclaration */:
+                case 163 /* Parameter */:
+                    headMessage = ts.Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any;
                     expectedReturnType = voidType;
-                    errorInfo = ts.chainDiagnosticMessages(
-                    /*details*/ undefined, ts.Diagnostics.The_return_type_of_a_property_decorator_function_must_be_either_void_or_any);
                     break;
                 case 168 /* MethodDeclaration */:
                 case 171 /* GetAccessor */:
                 case 172 /* SetAccessor */:
+                    headMessage = ts.Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
                     var methodType = getTypeOfNode(node.parent);
                     var descriptorType = createTypedPropertyDescriptorType(methodType);
                     expectedReturnType = getUnionType([descriptorType, voidType]);
@@ -79832,7 +79825,7 @@ var ts;
                 default:
                     return ts.Debug.fail();
             }
-            checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage, function () { return errorInfo; });
+            checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage);
         }
         /**
          * If a TypeNode can be resolved to a value symbol imported from an external module, it is
@@ -82105,9 +82098,9 @@ var ts;
             var containsArguments = containsArgumentsReference(node);
             if (containsArguments) {
                 var lastJSDocParam = ts.lastOrUndefined(jsdocParameters);
-                if (lastJSDocParam && ts.isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression &&
+                if (isJs && lastJSDocParam && ts.isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression &&
                     lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) {
-                    errorOrSuggestion(isJs, lastJSDocParam.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(lastJSDocParam.name));
+                    error(lastJSDocParam.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(lastJSDocParam.name));
                 }
             }
             else {
@@ -82117,7 +82110,9 @@ var ts;
                         return;
                     }
                     if (ts.isQualifiedName(name)) {
-                        errorOrSuggestion(isJs, name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(name), ts.entityNameToString(name.left));
+                        if (isJs) {
+                            error(name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(name), ts.entityNameToString(name.left));
+                        }
                     }
                     else {
                         errorOrSuggestion(isJs, name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(name));
@@ -87296,28 +87291,27 @@ var ts;
         }
         function findMostOverlappyType(source, unionTarget) {
             var bestMatch;
-            var matchingCount = 0;
-            for (var _i = 0, _a = unionTarget.types; _i < _a.length; _i++) {
-                var target = _a[_i];
-                var overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
-                if (overlap.flags & 4194304 /* Index */) {
-                    // perfect overlap of keys
-                    bestMatch = target;
-                    matchingCount = Infinity;
-                }
-                else if (overlap.flags & 1048576 /* Union */) {
-                    // We only want to account for literal types otherwise.
-                    // If we have a union of index types, it seems likely that we
-                    // needed to elaborate between two generic mapped types anyway.
-                    var len = ts.length(ts.filter(overlap.types, isUnitType));
-                    if (len >= matchingCount) {
-                        bestMatch = target;
-                        matchingCount = len;
-                    }
-                }
-                else if (isUnitType(overlap) && 1 >= matchingCount) {
-                    bestMatch = target;
-                    matchingCount = 1;
+            if (!(source.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
+                var matchingCount = 0;
+                for (var _i = 0, _a = unionTarget.types; _i < _a.length; _i++) {
+                    var target = _a[_i];
+                    if (!(target.flags & (131068 /* Primitive */ | 406847488 /* InstantiablePrimitive */))) {
+                        var overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
+                        if (overlap.flags & 4194304 /* Index */) {
+                            // perfect overlap of keys
+                            return target;
+                        }
+                        else if (isUnitType(overlap) || overlap.flags & 1048576 /* Union */) {
+                            // We only want to account for literal types otherwise.
+                            // If we have a union of index types, it seems likely that we
+                            // needed to elaborate between two generic mapped types anyway.
+                            var len = overlap.flags & 1048576 /* Union */ ? ts.countWhere(overlap.types, isUnitType) : 1;
+                            if (len >= matchingCount) {
+                                bestMatch = target;
+                                matchingCount = len;
+                            }
+                        }
+                    }
                 }
             }
             return bestMatch;
@@ -140010,6 +140004,41 @@ var ts;
                 if (ts.scanner.getToken() === 1 /* EndOfFileToken */) {
                     break;
                 }
+                if (ts.scanner.getToken() === 15 /* TemplateHead */) {
+                    var stack = [ts.scanner.getToken()];
+                    var token = ts.scanner.scan();
+                    loop: while (ts.length(stack)) {
+                        switch (token) {
+                            case 1 /* EndOfFileToken */:
+                                break loop;
+                            case 100 /* ImportKeyword */:
+                                tryConsumeImport();
+                                break;
+                            case 15 /* TemplateHead */:
+                                stack.push(token);
+                                break;
+                            case 18 /* OpenBraceToken */:
+                                if (ts.length(stack)) {
+                                    stack.push(token);
+                                }
+                                break;
+                            case 19 /* CloseBraceToken */:
+                                if (ts.length(stack)) {
+                                    if (ts.lastOrUndefined(stack) === 15 /* TemplateHead */) {
+                                        if (ts.scanner.reScanTemplateToken(/* isTaggedTemplate */ false) === 17 /* TemplateTail */) {
+                                            stack.pop();
+                                        }
+                                    }
+                                    else {
+                                        stack.pop();
+                                    }
+                                }
+                                break;
+                        }
+                        token = ts.scanner.scan();
+                    }
+                    nextToken();
+                }
                 // check if at least one of alternative have moved scanner forward
                 if (tryConsumeDeclare() ||
                     tryConsumeImport() ||
@@ -156817,7 +156846,7 @@ var ts;
                     // cannot find either start or end node
                     return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] };
                 }
-                if (ts.isJSDoc(start)) {
+                if (start.flags & 4194304 /* JSDoc */) {
                     return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractJSDoc)] };
                 }
                 if (start.parent !== end.parent) {