typescript 4.7.0-dev.20220216 → 4.7.0-dev.20220220

package/lib/tsserverlibrary.js

@@ -294,7 +294,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 = ts.versionMajorMinor + ".0-dev.20220216";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220220";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -2617,7 +2617,7 @@ var ts;
         Debug.checkEachDefined = checkEachDefined;
         function assertNever(member, message, stackCrawlMark) {
             if (message === void 0) { message = "Illegal value:"; }
-            var detail = typeof member === "object" && ts.hasProperty(member, "kind") && ts.hasProperty(member, "pos") && formatSyntaxKind ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member);
+            var detail = typeof member === "object" && ts.hasProperty(member, "kind") && ts.hasProperty(member, "pos") ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member);
             return fail(message + " " + detail, stackCrawlMark || assertNever);
         }
         Debug.assertNever = assertNever;
@@ -5114,13 +5114,14 @@ var ts;
         // Flags that require TypeFlags.Object
         ObjectFlags[ObjectFlags["ContainsSpread"] = 4194304] = "ContainsSpread";
         ObjectFlags[ObjectFlags["ObjectRestType"] = 8388608] = "ObjectRestType";
+        ObjectFlags[ObjectFlags["InstantiationExpressionType"] = 16777216] = "InstantiationExpressionType";
         /* @internal */
-        ObjectFlags[ObjectFlags["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
+        ObjectFlags[ObjectFlags["IsClassInstanceClone"] = 33554432] = "IsClassInstanceClone";
         // Flags that require TypeFlags.Object and ObjectFlags.Reference
         /* @internal */
-        ObjectFlags[ObjectFlags["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
+        ObjectFlags[ObjectFlags["IdenticalBaseTypeCalculated"] = 67108864] = "IdenticalBaseTypeCalculated";
         /* @internal */
-        ObjectFlags[ObjectFlags["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
+        ObjectFlags[ObjectFlags["IdenticalBaseTypeExists"] = 134217728] = "IdenticalBaseTypeExists";
         // Flags that require TypeFlags.UnionOrIntersection or TypeFlags.Substitution
         /* @internal */
         ObjectFlags[ObjectFlags["IsGenericTypeComputed"] = 4194304] = "IsGenericTypeComputed";
@@ -8338,7 +8339,6 @@ var ts;
         Unexpected_token_Did_you_mean_or_rbrace: diag(1381, ts.DiagnosticCategory.Error, "Unexpected_token_Did_you_mean_or_rbrace_1381", "Unexpected token. Did you mean `{'}'}` or `}`?"),
         Unexpected_token_Did_you_mean_or_gt: diag(1382, ts.DiagnosticCategory.Error, "Unexpected_token_Did_you_mean_or_gt_1382", "Unexpected token. Did you mean `{'>'}` or `>`?"),
         Only_named_exports_may_use_export_type: diag(1383, ts.DiagnosticCategory.Error, "Only_named_exports_may_use_export_type_1383", "Only named exports may use 'export type'."),
-        A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list: diag(1384, ts.DiagnosticCategory.Error, "A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list_1384", "A 'new' expression with type arguments must always be followed by a parenthesized argument list."),
         Function_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1385, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_a_union_type_1385", "Function type notation must be parenthesized when used in a union type."),
         Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1386, ts.DiagnosticCategory.Error, "Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type_1386", "Constructor type notation must be parenthesized when used in a union type."),
         Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1387, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1387", "Function type notation must be parenthesized when used in an intersection type."),
@@ -8724,6 +8724,7 @@ var ts;
         Cannot_assign_to_0_because_it_is_an_import: diag(2632, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_an_import_2632", "Cannot assign to '{0}' because it is an import."),
         JSX_property_access_expressions_cannot_include_JSX_namespace_names: diag(2633, ts.DiagnosticCategory.Error, "JSX_property_access_expressions_cannot_include_JSX_namespace_names_2633", "JSX property access expressions cannot include JSX namespace names"),
         _0_index_signatures_are_incompatible: diag(2634, ts.DiagnosticCategory.Error, "_0_index_signatures_are_incompatible_2634", "'{0}' index signatures are incompatible."),
+        Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable: diag(2635, ts.DiagnosticCategory.Error, "Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable_2635", "Type '{0}' has no signatures for which the type argument list is applicable."),
         Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."),
         A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."),
         Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."),
@@ -9769,7 +9770,7 @@ var ts;
         Fix_all_implicit_this_errors: diag(95107, ts.DiagnosticCategory.Message, "Fix_all_implicit_this_errors_95107", "Fix all implicit-'this' errors"),
         Wrap_invalid_character_in_an_expression_container: diag(95108, ts.DiagnosticCategory.Message, "Wrap_invalid_character_in_an_expression_container_95108", "Wrap invalid character in an expression container"),
         Wrap_all_invalid_characters_in_an_expression_container: diag(95109, ts.DiagnosticCategory.Message, "Wrap_all_invalid_characters_in_an_expression_container_95109", "Wrap all invalid characters in an expression container"),
-        Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_json_to_read_more_about_this_file: diag(95110, ts.DiagnosticCategory.Message, "Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_json_to_read_more_about_this_file_95110", "Visit https://aka.ms/tsconfig.json to read more about this file"),
+        Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file: diag(95110, ts.DiagnosticCategory.Message, "Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file_95110", "Visit https://aka.ms/tsconfig to read more about this file"),
         Add_a_return_statement: diag(95111, ts.DiagnosticCategory.Message, "Add_a_return_statement_95111", "Add a return statement"),
         Remove_braces_from_arrow_function_body: diag(95112, ts.DiagnosticCategory.Message, "Remove_braces_from_arrow_function_body_95112", "Remove braces from arrow function body"),
         Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal: diag(95113, ts.DiagnosticCategory.Message, "Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal_95113", "Wrap the following body with parentheses which should be an object literal"),
@@ -13615,6 +13616,7 @@ var ts;
             case 110 /* TrueKeyword */:
             case 106 /* SuperKeyword */:
             case 229 /* NonNullExpression */:
+            case 227 /* ExpressionWithTypeArguments */:
             case 230 /* MetaProperty */:
             case 100 /* ImportKeyword */: // technically this is only an Expression if it's in a CallExpression
                 return true;
@@ -15328,7 +15330,7 @@ var ts;
             case 114 /* VoidKeyword */:
                 return node.parent.kind !== 216 /* VoidExpression */;
             case 227 /* ExpressionWithTypeArguments */:
-                return !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+                return ts.isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
             case 162 /* TypeParameter */:
                 return node.parent.kind === 194 /* MappedType */ || node.parent.kind === 189 /* InferType */;
             // Identifiers and qualified names may be type nodes, depending on their context. Climb
@@ -15365,7 +15367,7 @@ var ts;
                 }
                 switch (parent.kind) {
                     case 227 /* ExpressionWithTypeArguments */:
-                        return !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
+                        return ts.isHeritageClause(parent.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
                     case 162 /* TypeParameter */:
                         return node === parent.constraint;
                     case 342 /* JSDocTemplateTag */:
@@ -16068,7 +16070,7 @@ var ts;
             case 296 /* SpreadAssignment */:
                 return true;
             case 227 /* ExpressionWithTypeArguments */:
-                return parent.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent);
+                return parent.expression === node && !isPartOfTypeNode(parent);
             case 295 /* ShorthandPropertyAssignment */:
                 return parent.objectAssignmentInitializer === node;
             default:
@@ -23055,16 +23057,18 @@ var ts;
             return updateConstructorTypeNode1(node, node.modifiers, typeParameters, parameters, type);
         }
         // @api
-        function createTypeQueryNode(exprName) {
+        function createTypeQueryNode(exprName, typeArguments) {
             var node = createBaseNode(180 /* TypeQuery */);
             node.exprName = exprName;
+            node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments);
             node.transformFlags = 1 /* ContainsTypeScript */;
             return node;
         }
         // @api
-        function updateTypeQueryNode(node, exprName) {
+        function updateTypeQueryNode(node, exprName, typeArguments) {
             return node.exprName !== exprName
-                ? update(createTypeQueryNode(exprName), node)
+                || node.typeArguments !== typeArguments
+                ? update(createTypeQueryNode(exprName, typeArguments), node)
                 : node;
         }
         // @api
@@ -30188,7 +30192,8 @@ var ts;
                     visitNode(cbNode, node.parameterName) ||
                     visitNode(cbNode, node.type);
             case 180 /* TypeQuery */:
-                return visitNode(cbNode, node.exprName);
+                return visitNode(cbNode, node.exprName) ||
+                    visitNodes(cbNode, cbNodes, node.typeArguments);
             case 181 /* TypeLiteral */:
                 return visitNodes(cbNode, cbNodes, node.members);
             case 182 /* ArrayType */:
@@ -32721,7 +32726,9 @@ var ts;
         function parseTypeQuery() {
             var pos = getNodePos();
             parseExpected(112 /* TypeOfKeyword */);
-            return finishNode(factory.createTypeQueryNode(parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true)), pos);
+            var entityName = parseEntityName(/*allowReservedWords*/ true, /*allowPrivateIdentifiers*/ true);
+            var typeArguments = tryParseTypeArguments();
+            return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos);
         }
         function parseTypeParameter() {
             var pos = getNodePos();
@@ -34791,20 +34798,30 @@ var ts;
                     expression = parsePropertyAccessExpressionRest(pos, expression, questionDotToken);
                     continue;
                 }
-                if (!questionDotToken && token() === 53 /* ExclamationToken */ && !scanner.hasPrecedingLineBreak()) {
-                    nextToken();
-                    expression = finishNode(factory.createNonNullExpression(expression), pos);
-                    continue;
-                }
                 // when in the [Decorator] context, we do not parse ElementAccess as it could be part of a ComputedPropertyName
                 if ((questionDotToken || !inDecoratorContext()) && parseOptional(22 /* OpenBracketToken */)) {
                     expression = parseElementAccessExpressionRest(pos, expression, questionDotToken);
                     continue;
                 }
                 if (isTemplateStartOfTaggedTemplate()) {
-                    expression = parseTaggedTemplateRest(pos, expression, questionDotToken, /*typeArguments*/ undefined);
+                    // Absorb type arguments into TemplateExpression when preceding expression is ExpressionWithTypeArguments
+                    expression = !questionDotToken && expression.kind === 227 /* ExpressionWithTypeArguments */ ?
+                        parseTaggedTemplateRest(pos, expression.expression, questionDotToken, expression.typeArguments) :
+                        parseTaggedTemplateRest(pos, expression, questionDotToken, /*typeArguments*/ undefined);
                     continue;
                 }
+                if (!questionDotToken) {
+                    if (token() === 53 /* ExclamationToken */ && !scanner.hasPrecedingLineBreak()) {
+                        nextToken();
+                        expression = finishNode(factory.createNonNullExpression(expression), pos);
+                        continue;
+                    }
+                    var typeArguments = tryParse(parseTypeArgumentsInExpression);
+                    if (typeArguments) {
+                        expression = finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
+                        continue;
+                    }
+                }
                 return expression;
             }
         }
@@ -34824,38 +34841,30 @@ var ts;
         function parseCallExpressionRest(pos, expression) {
             while (true) {
                 expression = parseMemberExpressionRest(pos, expression, /*allowOptionalChain*/ true);
+                var typeArguments = void 0;
                 var questionDotToken = parseOptionalToken(28 /* QuestionDotToken */);
-                // handle 'foo<<T>()'
-                // parse template arguments only in TypeScript files (not in JavaScript files).
-                if ((contextFlags & 131072 /* JavaScriptFile */) === 0 && (token() === 29 /* LessThanToken */ || token() === 47 /* LessThanLessThanToken */)) {
-                    // See if this is the start of a generic invocation.  If so, consume it and
-                    // keep checking for postfix expressions.  Otherwise, it's just a '<' that's
-                    // part of an arithmetic expression.  Break out so we consume it higher in the
-                    // stack.
-                    var typeArguments = tryParse(parseTypeArgumentsInExpression);
-                    if (typeArguments) {
-                        if (isTemplateStartOfTaggedTemplate()) {
-                            expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
-                            continue;
-                        }
-                        var argumentList = parseArgumentList();
-                        var callExpr = questionDotToken || tryReparseOptionalChain(expression) ?
-                            factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) :
-                            factory.createCallExpression(expression, typeArguments, argumentList);
-                        expression = finishNode(callExpr, pos);
+                if (questionDotToken) {
+                    typeArguments = tryParse(parseTypeArgumentsInExpression);
+                    if (isTemplateStartOfTaggedTemplate()) {
+                        expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments);
                         continue;
                     }
                 }
-                else if (token() === 20 /* OpenParenToken */) {
+                if (typeArguments || token() === 20 /* OpenParenToken */) {
+                    // Absorb type arguments into CallExpression when preceding expression is ExpressionWithTypeArguments
+                    if (!questionDotToken && expression.kind === 227 /* ExpressionWithTypeArguments */) {
+                        typeArguments = expression.typeArguments;
+                        expression = expression.expression;
+                    }
                     var argumentList = parseArgumentList();
                     var callExpr = questionDotToken || tryReparseOptionalChain(expression) ?
-                        factory.createCallChain(expression, questionDotToken, /*typeArguments*/ undefined, argumentList) :
-                        factory.createCallExpression(expression, /*typeArguments*/ undefined, argumentList);
+                        factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) :
+                        factory.createCallExpression(expression, typeArguments, argumentList);
                     expression = finishNode(callExpr, pos);
                     continue;
                 }
                 if (questionDotToken) {
-                    // We failed to parse anything, so report a missing identifier here.
+                    // We parsed `?.` but then failed to parse anything, so report a missing identifier here.
                     var name = createMissingNode(79 /* Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics.Identifier_expected);
                     expression = finishNode(factory.createPropertyAccessChain(expression, questionDotToken, name), pos);
                 }
@@ -34883,21 +34892,25 @@ var ts;
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
                 return undefined;
             }
-            // If we have a '<', then only parse this as a argument list if the type arguments
-            // are complete and we have an open paren.  if we don't, rewind and return nothing.
-            return typeArguments && canFollowTypeArgumentsInExpression()
-                ? typeArguments
-                : undefined;
+            // We successfully parsed a type argument list. The next token determines whether we want to
+            // treat it as such. If the type argument list is followed by `(` or a template literal, as in
+            // `f<number>(42)`, we favor the type argument interpretation even though JavaScript would view
+            // it as a relational expression.
+            return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : undefined;
         }
         function canFollowTypeArgumentsInExpression() {
             switch (token()) {
+                // These tokens can follow a type argument list in a call expression.
                 case 20 /* OpenParenToken */: // foo<x>(
                 case 14 /* NoSubstitutionTemplateLiteral */: // foo<T> `...`
                 case 15 /* TemplateHead */: // foo<T> `...${100}...`
-                // these are the only tokens can legally follow a type argument
-                // list. So we definitely want to treat them as type arg lists.
+                // These tokens can't follow in a call expression, nor can they start an
+                // expression. So, consider the type argument list part of an instantiation
+                // expression.
                 // falls through
+                case 27 /* CommaToken */: // foo<x>,
                 case 24 /* DotToken */: // foo<x>.
+                case 28 /* QuestionDotToken */: // foo<x>?.
                 case 21 /* CloseParenToken */: // foo<x>)
                 case 23 /* CloseBracketToken */: // foo<x>]
                 case 58 /* ColonToken */: // foo<x>:
@@ -34915,20 +34928,10 @@ var ts;
                 case 51 /* BarToken */: // foo<x> |
                 case 19 /* CloseBraceToken */: // foo<x> }
                 case 1 /* EndOfFileToken */: // foo<x>
-                    // these cases can't legally follow a type arg list.  However, they're not legal
-                    // expressions either.  The user is probably in the middle of a generic type. So
-                    // treat it as such.
                     return true;
-                case 27 /* CommaToken */: // foo<x>,
-                case 18 /* OpenBraceToken */: // foo<x> {
-                // We don't want to treat these as type arguments.  Otherwise we'll parse this
-                // as an invocation expression.  Instead, we want to parse out the expression
-                // in isolation from the type arguments.
-                // falls through
-                default:
-                    // Anything else treat as an expression.
-                    return false;
             }
+            // Treat anything else as an expression.
+            return false;
         }
         function parsePrimaryExpression() {
             switch (token()) {
@@ -35109,26 +35112,15 @@ var ts;
                 return finishNode(factory.createMetaProperty(103 /* NewKeyword */, name), pos);
             }
             var expressionPos = getNodePos();
-            var expression = parsePrimaryExpression();
+            var expression = parseMemberExpressionRest(expressionPos, parsePrimaryExpression(), /*allowOptionalChain*/ false);
             var typeArguments;
-            while (true) {
-                expression = parseMemberExpressionRest(expressionPos, expression, /*allowOptionalChain*/ false);
-                typeArguments = tryParse(parseTypeArgumentsInExpression);
-                if (isTemplateStartOfTaggedTemplate()) {
-                    ts.Debug.assert(!!typeArguments, "Expected a type argument list; all plain tagged template starts should be consumed in 'parseMemberExpressionRest'");
-                    expression = parseTaggedTemplateRest(expressionPos, expression, /*optionalChain*/ undefined, typeArguments);
-                    typeArguments = undefined;
-                }
-                break;
-            }
-            var argumentsArray;
-            if (token() === 20 /* OpenParenToken */) {
-                argumentsArray = parseArgumentList();
-            }
-            else if (typeArguments) {
-                parseErrorAt(pos, scanner.getStartPos(), ts.Diagnostics.A_new_expression_with_type_arguments_must_always_be_followed_by_a_parenthesized_argument_list);
+            // Absorb type arguments into NewExpression when preceding expression is ExpressionWithTypeArguments
+            if (expression.kind === 227 /* ExpressionWithTypeArguments */) {
+                typeArguments = expression.typeArguments;
+                expression = expression.expression;
             }
-            return finishNode(factory.createNewExpression(expression, typeArguments, argumentsArray), pos);
+            var argumentList = token() === 20 /* OpenParenToken */ ? parseArgumentList() : undefined;
+            return finishNode(factory.createNewExpression(expression, typeArguments, argumentList), pos);
         }
         // STATEMENTS
         function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) {
@@ -36217,6 +36209,9 @@ var ts;
         function parseExpressionWithTypeArguments() {
             var pos = getNodePos();
             var expression = parseLeftHandSideExpressionOrHigher();
+            if (expression.kind === 227 /* ExpressionWithTypeArguments */) {
+                return expression;
+            }
             var typeArguments = tryParseTypeArguments();
             return finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos);
         }
@@ -40662,7 +40657,7 @@ var ts;
             var result = [];
             result.push("{");
             result.push(tab + "\"compilerOptions\": {");
-            result.push("" + tab + tab + "/* " + ts.getLocaleSpecificMessage(ts.Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_json_to_read_more_about_this_file) + " */");
+            result.push("" + tab + tab + "/* " + ts.getLocaleSpecificMessage(ts.Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file) + " */");
             result.push("");
             // Print out each row, aligning all the descriptions on the same column.
             for (var _a = 0, entries_2 = entries; _a < entries_2.length; _a++) {
@@ -51225,7 +51220,7 @@ var ts;
             // get symbol of the first identifier of the entityName
             var meaning;
             if (entityName.parent.kind === 180 /* TypeQuery */ ||
-                ts.isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent) ||
+                entityName.parent.kind === 227 /* ExpressionWithTypeArguments */ && !ts.isPartOfTypeNode(entityName.parent) ||
                 entityName.parent.kind === 161 /* ComputedPropertyName */) {
                 // Typeof value
                 meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
@@ -51336,7 +51331,7 @@ var ts;
             return flags & 814775659 /* NodeBuilderFlagsMask */;
         }
         function isClassInstanceSide(type) {
-            return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || (!!(type.flags & 524288 /* Object */) && !!(ts.getObjectFlags(type) & 16777216 /* IsClassInstanceClone */)));
+            return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || (!!(type.flags & 524288 /* Object */) && !!(ts.getObjectFlags(type) & 33554432 /* IsClassInstanceClone */)));
         }
         function createNodeBuilder() {
             return {
@@ -55265,7 +55260,7 @@ var ts;
                 members_4, exportedType.callSignatures, exportedType.constructSignatures, exportedType.indexInfos);
                 result.objectFlags |= (ts.getObjectFlags(type) & 8192 /* JSLiteral */); // Propagate JSLiteral flag
                 if (result.symbol && result.symbol.flags & 32 /* Class */ && type === getDeclaredTypeOfClassOrInterface(result.symbol)) {
-                    result.objectFlags |= 16777216 /* IsClassInstanceClone */; // Propagate the knowledge that this type is equivalent to the symbol's class instance type
+                    result.objectFlags |= 33554432 /* IsClassInstanceClone */; // Propagate the knowledge that this type is equivalent to the symbol's class instance type
                 }
                 return result;
             }
@@ -57311,87 +57306,87 @@ var ts;
          * Converts an AnonymousType to a ResolvedType.
          */
         function resolveAnonymousTypeMembers(type) {
-            var symbol = getMergedSymbol(type.symbol);
             if (type.target) {
                 setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-                var members = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false);
+                var members_6 = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false);
                 var callSignatures = instantiateSignatures(getSignaturesOfType(type.target, 0 /* Call */), type.mapper);
                 var constructSignatures = instantiateSignatures(getSignaturesOfType(type.target, 1 /* Construct */), type.mapper);
-                var indexInfos = instantiateIndexInfos(getIndexInfosOfType(type.target), type.mapper);
-                setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
+                var indexInfos_1 = instantiateIndexInfos(getIndexInfosOfType(type.target), type.mapper);
+                setStructuredTypeMembers(type, members_6, callSignatures, constructSignatures, indexInfos_1);
+                return;
             }
-            else if (symbol.flags & 2048 /* TypeLiteral */) {
+            var symbol = getMergedSymbol(type.symbol);
+            if (symbol.flags & 2048 /* TypeLiteral */) {
                 setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-                var members = getMembersOfSymbol(symbol);
-                var callSignatures = getSignaturesOfSymbol(members.get("__call" /* Call */));
-                var constructSignatures = getSignaturesOfSymbol(members.get("__new" /* New */));
-                var indexInfos = getIndexInfosOfSymbol(symbol);
-                setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos);
+                var members_7 = getMembersOfSymbol(symbol);
+                var callSignatures = getSignaturesOfSymbol(members_7.get("__call" /* Call */));
+                var constructSignatures = getSignaturesOfSymbol(members_7.get("__new" /* New */));
+                var indexInfos_2 = getIndexInfosOfSymbol(symbol);
+                setStructuredTypeMembers(type, members_7, callSignatures, constructSignatures, indexInfos_2);
+                return;
             }
-            else {
-                // Combinations of function, class, enum and module
-                var members = emptySymbols;
-                var indexInfos = void 0;
-                if (symbol.exports) {
-                    members = getExportsOfSymbol(symbol);
-                    if (symbol === globalThisSymbol) {
-                        var varsOnly_1 = new ts.Map();
-                        members.forEach(function (p) {
-                            if (!(p.flags & 418 /* BlockScoped */)) {
-                                varsOnly_1.set(p.escapedName, p);
-                            }
-                        });
-                        members = varsOnly_1;
-                    }
+            // Combinations of function, class, enum and module
+            var members = emptySymbols;
+            var indexInfos;
+            if (symbol.exports) {
+                members = getExportsOfSymbol(symbol);
+                if (symbol === globalThisSymbol) {
+                    var varsOnly_1 = new ts.Map();
+                    members.forEach(function (p) {
+                        if (!(p.flags & 418 /* BlockScoped */)) {
+                            varsOnly_1.set(p.escapedName, p);
+                        }
+                    });
+                    members = varsOnly_1;
                 }
-                var baseConstructorIndexInfo = void 0;
-                setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, ts.emptyArray);
-                if (symbol.flags & 32 /* Class */) {
-                    var classType = getDeclaredTypeOfClassOrInterface(symbol);
-                    var baseConstructorType = getBaseConstructorTypeOfClass(classType);
-                    if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 8650752 /* TypeVariable */)) {
-                        members = ts.createSymbolTable(getNamedOrIndexSignatureMembers(members));
-                        addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
-                    }
-                    else if (baseConstructorType === anyType) {
-                        baseConstructorIndexInfo = createIndexInfo(stringType, anyType, /*isReadonly*/ false);
-                    }
+            }
+            var baseConstructorIndexInfo;
+            setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, ts.emptyArray);
+            if (symbol.flags & 32 /* Class */) {
+                var classType = getDeclaredTypeOfClassOrInterface(symbol);
+                var baseConstructorType = getBaseConstructorTypeOfClass(classType);
+                if (baseConstructorType.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 8650752 /* TypeVariable */)) {
+                    members = ts.createSymbolTable(getNamedOrIndexSignatureMembers(members));
+                    addInheritedMembers(members, getPropertiesOfType(baseConstructorType));
                 }
-                var indexSymbol = getIndexSymbolFromSymbolTable(members);
-                if (indexSymbol) {
-                    indexInfos = getIndexInfosOfIndexSymbol(indexSymbol);
+                else if (baseConstructorType === anyType) {
+                    baseConstructorIndexInfo = createIndexInfo(stringType, anyType, /*isReadonly*/ false);
                 }
-                else {
-                    if (baseConstructorIndexInfo) {
-                        indexInfos = ts.append(indexInfos, baseConstructorIndexInfo);
-                    }
-                    if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* Enum */ ||
-                        ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296 /* NumberLike */); }))) {
-                        indexInfos = ts.append(indexInfos, enumNumberIndexInfo);
-                    }
+            }
+            var indexSymbol = getIndexSymbolFromSymbolTable(members);
+            if (indexSymbol) {
+                indexInfos = getIndexInfosOfIndexSymbol(indexSymbol);
+            }
+            else {
+                if (baseConstructorIndexInfo) {
+                    indexInfos = ts.append(indexInfos, baseConstructorIndexInfo);
                 }
-                setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, indexInfos || ts.emptyArray);
-                // We resolve the members before computing the signatures because a signature may use
-                // typeof with a qualified name expression that circularly references the type we are
-                // in the process of resolving (see issue #6072). The temporarily empty signature list
-                // will never be observed because a qualified name can't reference signatures.
-                if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
-                    type.callSignatures = getSignaturesOfSymbol(symbol);
+                if (symbol.flags & 384 /* Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* Enum */ ||
+                    ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296 /* NumberLike */); }))) {
+                    indexInfos = ts.append(indexInfos, enumNumberIndexInfo);
                 }
-                // And likewise for construct signatures for classes
-                if (symbol.flags & 32 /* Class */) {
-                    var classType_1 = getDeclaredTypeOfClassOrInterface(symbol);
-                    var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* Constructor */)) : ts.emptyArray;
-                    if (symbol.flags & 16 /* Function */) {
-                        constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ?
-                            createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */) :
-                            undefined; }));
-                    }
-                    if (!constructSignatures.length) {
-                        constructSignatures = getDefaultConstructSignatures(classType_1);
-                    }
-                    type.constructSignatures = constructSignatures;
+            }
+            setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, indexInfos || ts.emptyArray);
+            // We resolve the members before computing the signatures because a signature may use
+            // typeof with a qualified name expression that circularly references the type we are
+            // in the process of resolving (see issue #6072). The temporarily empty signature list
+            // will never be observed because a qualified name can't reference signatures.
+            if (symbol.flags & (16 /* Function */ | 8192 /* Method */)) {
+                type.callSignatures = getSignaturesOfSymbol(symbol);
+            }
+            // And likewise for construct signatures for classes
+            if (symbol.flags & 32 /* Class */) {
+                var classType_1 = getDeclaredTypeOfClassOrInterface(symbol);
+                var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* Constructor */)) : ts.emptyArray;
+                if (symbol.flags & 16 /* Function */) {
+                    constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ?
+                        createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* PropagatingFlags */) :
+                        undefined; }));
                 }
+                if (!constructSignatures.length) {
+                    constructSignatures = getDefaultConstructSignatures(classType_1);
+                }
+                type.constructSignatures = constructSignatures;
             }
         }
         function replaceIndexedAccess(instantiable, type, replacement) {
@@ -58392,8 +58387,8 @@ var ts;
             var stringIndexInfo;
             var applicableInfo;
             var applicableInfos;
-            for (var _i = 0, indexInfos_1 = indexInfos; _i < indexInfos_1.length; _i++) {
-                var info = indexInfos_1[_i];
+            for (var _i = 0, indexInfos_3 = indexInfos; _i < indexInfos_3.length; _i++) {
+                var info = indexInfos_3[_i];
                 if (info.keyType === stringType) {
                     stringIndexInfo = info;
                 }
@@ -58966,14 +58961,14 @@ var ts;
         }
         function getIndexInfosOfIndexSymbol(indexSymbol) {
             if (indexSymbol.declarations) {
-                var indexInfos_2 = [];
+                var indexInfos_4 = [];
                 var _loop_14 = function (declaration) {
                     if (declaration.parameters.length === 1) {
                         var parameter = declaration.parameters[0];
                         if (parameter.type) {
                             forEachType(getTypeFromTypeNode(parameter.type), function (keyType) {
-                                if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos_2, keyType)) {
-                                    indexInfos_2.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasEffectiveModifier(declaration, 64 /* Readonly */), declaration));
+                                if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos_4, keyType)) {
+                                    indexInfos_4.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasEffectiveModifier(declaration, 64 /* Readonly */), declaration));
                                 }
                             });
                         }
@@ -58983,7 +58978,7 @@ var ts;
                     var declaration = _a[_i];
                     _loop_14(declaration);
                 }
-                return indexInfos_2;
+                return indexInfos_4;
             }
             return ts.emptyArray;
         }
@@ -59531,7 +59526,7 @@ var ts;
                 // The expression is processed as an identifier expression (section 4.3)
                 // or property access expression(section 4.10),
                 // the widened type(section 3.9) of which becomes the result.
-                var type = ts.isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) : checkExpression(node.exprName);
+                var type = checkExpressionWithTypeArguments(node);
                 links.resolvedType = getRegularTypeOfLiteralType(getWidenedType(type));
             }
             return links.resolvedType;
@@ -62235,7 +62230,9 @@ var ts;
             return result;
         }
         function getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
-            var declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.symbol.declarations[0];
+            var declaration = type.objectFlags & 4 /* Reference */ ? type.node :
+                type.objectFlags & 16777216 /* InstantiationExpressionType */ ? type.node :
+                    type.symbol.declarations[0];
             var links = getNodeLinks(declaration);
             var target = type.objectFlags & 4 /* Reference */ ? links.resolvedType :
                 type.objectFlags & 64 /* Instantiated */ ? type.target : type;
@@ -62251,8 +62248,8 @@ var ts;
                     outerTypeParameters = ts.addRange(outerTypeParameters, templateTagParameters);
                 }
                 typeParameters = outerTypeParameters || ts.emptyArray;
-                var allDeclarations_1 = type.objectFlags & 4 /* Reference */ ? [declaration] : type.symbol.declarations;
-                typeParameters = (target.objectFlags & 4 /* Reference */ || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ?
+                var allDeclarations_1 = type.objectFlags & (4 /* Reference */ | 16777216 /* InstantiationExpressionType */) ? [declaration] : type.symbol.declarations;
+                typeParameters = (target.objectFlags & (4 /* Reference */ | 16777216 /* InstantiationExpressionType */) || target.symbol.flags & 8192 /* Method */ || target.symbol.flags & 2048 /* TypeLiteral */) && !target.aliasTypeArguments ?
                     ts.filter(typeParameters, function (tp) { return ts.some(allDeclarations_1, function (d) { return isTypeParameterPossiblyReferenced(tp, d); }); }) :
                     typeParameters;
                 links.outerTypeParameters = typeParameters;
@@ -62424,6 +62421,9 @@ var ts;
                 mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper);
                 freshTypeParameter.mapper = mapper;
             }
+            if (type.objectFlags & 16777216 /* InstantiationExpressionType */) {
+                result.node = type.node;
+            }
             result.target = type;
             result.mapper = mapper;
             result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -63189,10 +63189,6 @@ var ts;
             if (sourceRestType || targetRestType) {
                 void instantiateType(sourceRestType || targetRestType, reportUnreliableMarkers);
             }
-            if (sourceRestType && targetRestType && sourceCount !== targetCount) {
-                // We're not able to relate misaligned complex rest parameters
-                return 0 /* False */;
-            }
             var kind = target.declaration ? target.declaration.kind : 0 /* Unknown */;
             var strictVariance = !(checkMode & 3 /* Callback */) && strictFunctionTypes && kind !== 168 /* MethodDeclaration */ &&
                 kind !== 167 /* MethodSignature */ && kind !== 170 /* Constructor */;
@@ -65617,8 +65613,8 @@ var ts;
                 var indexInfos = getIndexInfosOfType(target);
                 var targetHasStringIndex = ts.some(indexInfos, function (info) { return info.keyType === stringType; });
                 var result = -1 /* True */;
-                for (var _i = 0, indexInfos_3 = indexInfos; _i < indexInfos_3.length; _i++) {
-                    var targetInfo = indexInfos_3[_i];
+                for (var _i = 0, indexInfos_5 = indexInfos; _i < indexInfos_5.length; _i++) {
+                    var targetInfo = indexInfos_5[_i];
                     var related = !sourceIsPrimitive && targetHasStringIndex && targetInfo.type.flags & 1 /* Any */ ? -1 /* True */ :
                         isGenericMappedType(source) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source), targetInfo.type, 3 /* Both */, reportErrors) :
                             typeRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState);
@@ -66225,10 +66221,10 @@ var ts;
             if (!(ts.getObjectFlags(type) & 4 /* Reference */) || !(ts.getObjectFlags(type.target) & 3 /* ClassOrInterface */)) {
                 return undefined;
             }
-            if (ts.getObjectFlags(type) & 33554432 /* IdenticalBaseTypeCalculated */) {
-                return ts.getObjectFlags(type) & 67108864 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : undefined;
+            if (ts.getObjectFlags(type) & 67108864 /* IdenticalBaseTypeCalculated */) {
+                return ts.getObjectFlags(type) & 134217728 /* IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : undefined;
             }
-            type.objectFlags |= 33554432 /* IdenticalBaseTypeCalculated */;
+            type.objectFlags |= 67108864 /* IdenticalBaseTypeCalculated */;
             var target = type.target;
             if (ts.getObjectFlags(target) & 1 /* Class */) {
                 var baseTypeNode = getBaseTypeNodeOfClass(target);
@@ -66249,7 +66245,7 @@ var ts;
             if (ts.length(getTypeArguments(type)) > ts.length(target.typeParameters)) {
                 instantiatedBase = getTypeWithThisArgument(instantiatedBase, ts.last(getTypeArguments(type)));
             }
-            type.objectFlags |= 67108864 /* IdenticalBaseTypeExists */;
+            type.objectFlags |= 134217728 /* IdenticalBaseTypeExists */;
             return type.cachedEquivalentBaseType = instantiatedBase;
         }
         function isEmptyLiteralType(type) {
@@ -66913,7 +66909,7 @@ var ts;
             var result = !!(type.flags & 465829888 /* Instantiable */ ||
                 type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || ts.forEach(getTypeArguments(type), couldContainTypeVariables)) ||
                     objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations ||
-                    objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 8388608 /* ObjectRestType */)) ||
+                    objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 8388608 /* ObjectRestType */ | 16777216 /* InstantiationExpressionType */)) ||
                 type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && ts.some(type.types, couldContainTypeVariables));
             if (type.flags & 3899393 /* ObjectFlagsType */) {
                 type.objectFlags |= 1048576 /* CouldContainTypeVariablesComputed */ | (result ? 2097152 /* CouldContainTypeVariables */ : 0);
@@ -67830,8 +67826,8 @@ var ts;
                 var priority = (ts.getObjectFlags(source) & ts.getObjectFlags(target) & 32 /* Mapped */) ? 8 /* HomomorphicMappedType */ : 0;
                 var indexInfos = getIndexInfosOfType(target);
                 if (isObjectTypeWithInferableIndex(source)) {
-                    for (var _i = 0, indexInfos_4 = indexInfos; _i < indexInfos_4.length; _i++) {
-                        var targetInfo = indexInfos_4[_i];
+                    for (var _i = 0, indexInfos_6 = indexInfos; _i < indexInfos_6.length; _i++) {
+                        var targetInfo = indexInfos_6[_i];
                         var propTypes = [];
                         for (var _a = 0, _b = getPropertiesOfType(source); _a < _b.length; _a++) {
                             var prop = _b[_a];
@@ -67851,8 +67847,8 @@ var ts;
                         }
                     }
                 }
-                for (var _e = 0, indexInfos_5 = indexInfos; _e < indexInfos_5.length; _e++) {
-                    var targetInfo = indexInfos_5[_e];
+                for (var _e = 0, indexInfos_7 = indexInfos; _e < indexInfos_7.length; _e++) {
+                    var targetInfo = indexInfos_7[_e];
                     var sourceInfo = getApplicableIndexInfo(source, targetInfo.keyType);
                     if (sourceInfo) {
                         inferWithPriority(sourceInfo.type, targetInfo.type, priority);
@@ -70250,7 +70246,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) {
@@ -76016,6 +76012,72 @@ var ts;
             return node.flags & 32 /* OptionalChain */ ? checkNonNullChain(node) :
                 getNonNullableType(checkExpression(node.expression));
         }
+        function checkExpressionWithTypeArguments(node) {
+            checkGrammarExpressionWithTypeArguments(node);
+            var exprType = node.kind === 227 /* ExpressionWithTypeArguments */ ? checkExpression(node.expression) :
+                ts.isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) :
+                    checkExpression(node.exprName);
+            var typeArguments = node.typeArguments;
+            if (exprType === silentNeverType || isErrorType(exprType) || !ts.some(typeArguments)) {
+                return exprType;
+            }
+            var hasSomeApplicableSignature = false;
+            var nonApplicableType;
+            var result = getInstantiatedType(exprType);
+            var errorType = hasSomeApplicableSignature ? nonApplicableType : exprType;
+            if (errorType) {
+                diagnostics.add(ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable, typeToString(errorType)));
+            }
+            return result;
+            function getInstantiatedType(type) {
+                var hasSignatures = false;
+                var hasApplicableSignature = false;
+                var result = getInstantiatedTypePart(type);
+                hasSomeApplicableSignature || (hasSomeApplicableSignature = hasApplicableSignature);
+                if (hasSignatures && !hasApplicableSignature) {
+                    nonApplicableType !== null && nonApplicableType !== void 0 ? nonApplicableType : (nonApplicableType = type);
+                }
+                return result;
+                function getInstantiatedTypePart(type) {
+                    if (type.flags & 524288 /* Object */) {
+                        var resolved = resolveStructuredTypeMembers(type);
+                        var callSignatures = getInstantiatedSignatures(resolved.callSignatures);
+                        var constructSignatures = getInstantiatedSignatures(resolved.constructSignatures);
+                        hasSignatures || (hasSignatures = resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0);
+                        hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0);
+                        if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) {
+                            var result_11 = createAnonymousType(undefined, resolved.members, callSignatures, constructSignatures, resolved.indexInfos);
+                            result_11.objectFlags |= 16777216 /* InstantiationExpressionType */;
+                            result_11.node = node;
+                            return result_11;
+                        }
+                    }
+                    else if (type.flags & 58982400 /* InstantiableNonPrimitive */) {
+                        var constraint = getBaseConstraintOfType(type);
+                        if (constraint) {
+                            var instantiated = getInstantiatedTypePart(constraint);
+                            if (instantiated !== constraint) {
+                                return instantiated;
+                            }
+                        }
+                    }
+                    else if (type.flags & 1048576 /* Union */) {
+                        return mapType(type, getInstantiatedType);
+                    }
+                    else if (type.flags & 2097152 /* Intersection */) {
+                        return getIntersectionType(ts.sameMap(type.types, getInstantiatedTypePart));
+                    }
+                    return type;
+                }
+            }
+            function getInstantiatedSignatures(signatures) {
+                var applicableSignatures = ts.filter(signatures, function (sig) { return !!sig.typeParameters && hasCorrectTypeArgumentArity(sig, typeArguments); });
+                return ts.sameMap(applicableSignatures, function (sig) {
+                    var typeArgumentTypes = checkTypeArguments(sig, typeArguments, /*reportErrors*/ true);
+                    return typeArgumentTypes ? getSignatureInstantiation(sig, typeArgumentTypes, ts.isInJSFile(sig.declaration)) : sig;
+                });
+            }
+        }
         function checkMetaProperty(node) {
             checkGrammarMetaProperty(node);
             if (node.keywordToken === 103 /* NewKeyword */) {
@@ -77505,7 +77567,7 @@ var ts;
                     if (operator === 55 /* AmpersandAmpersandToken */ || operator === 56 /* BarBarToken */ || operator === 60 /* QuestionQuestionToken */) {
                         if (operator === 55 /* AmpersandAmpersandToken */) {
                             var parent = ts.walkUpParenthesizedExpressions(node.parent);
-                            checkTestingKnownTruthyCallableOrAwaitableType(node.left, leftType, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
+                            checkTestingKnownTruthyCallableOrAwaitableType(node.left, ts.isIfStatement(parent) ? parent.thenStatement : undefined);
                         }
                         checkTruthinessOfType(leftType, node.left);
                     }
@@ -78012,8 +78074,8 @@ var ts;
             return type;
         }
         function checkConditionalExpression(node, checkMode) {
-            var type = checkTruthinessExpression(node.condition);
-            checkTestingKnownTruthyCallableOrAwaitableType(node.condition, type, node.whenTrue);
+            checkTruthinessExpression(node.condition);
+            checkTestingKnownTruthyCallableOrAwaitableType(node.condition, node.whenTrue);
             var type1 = checkExpression(node.whenTrue, checkMode);
             var type2 = checkExpression(node.whenFalse, checkMode);
             return getUnionType([type1, type2], 2 /* Subtype */);
@@ -78532,6 +78594,8 @@ var ts;
                     return checkAssertion(node);
                 case 229 /* NonNullExpression */:
                     return checkNonNullAssertion(node);
+                case 227 /* ExpressionWithTypeArguments */:
+                    return checkExpressionWithTypeArguments(node);
                 case 230 /* MetaProperty */:
                     return checkMetaProperty(node);
                 case 214 /* DeleteExpression */:
@@ -79735,12 +79799,12 @@ var ts;
                     case 264 /* ImportEqualsDeclaration */:
                     case 267 /* NamespaceImport */:
                     case 266 /* ImportClause */:
-                        var result_11 = 0 /* None */;
+                        var result_12 = 0 /* None */;
                         var target = resolveAlias(getSymbolOfNode(d));
                         ts.forEach(target.declarations, function (d) {
-                            result_11 |= getDeclarationSpaces(d);
+                            result_12 |= getDeclarationSpaces(d);
                         });
-                        return result_11;
+                        return result_12;
                     case 253 /* VariableDeclaration */:
                     case 202 /* BindingElement */:
                     case 255 /* FunctionDeclaration */:
@@ -81167,50 +81231,59 @@ var ts;
         function checkIfStatement(node) {
             // Grammar checking
             checkGrammarStatementInAmbientContext(node);
-            var type = checkTruthinessExpression(node.expression);
-            checkTestingKnownTruthyCallableOrAwaitableType(node.expression, type, node.thenStatement);
+            checkTruthinessExpression(node.expression);
+            checkTestingKnownTruthyCallableOrAwaitableType(node.expression, node.thenStatement);
             checkSourceElement(node.thenStatement);
             if (node.thenStatement.kind === 235 /* EmptyStatement */) {
                 error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
             }
             checkSourceElement(node.elseStatement);
         }
-        function checkTestingKnownTruthyCallableOrAwaitableType(condExpr, type, body) {
+        function checkTestingKnownTruthyCallableOrAwaitableType(condExpr, body) {
             if (!strictNullChecks)
                 return;
-            if (getFalsyFlags(type))
-                return;
-            var location = ts.isBinaryExpression(condExpr) ? condExpr.right : condExpr;
-            if (ts.isPropertyAccessExpression(location) && isTypeAssertion(location.expression)) {
-                return;
-            }
-            var testedNode = ts.isIdentifier(location) ? location
-                : ts.isPropertyAccessExpression(location) ? location.name
-                    : ts.isBinaryExpression(location) && ts.isIdentifier(location.right) ? location.right
-                        : undefined;
-            // While it technically should be invalid for any known-truthy value
-            // to be tested, we de-scope to functions and Promises unreferenced in
-            // the block as a heuristic to identify the most common bugs. There
-            // are too many false positives for values sourced from type
-            // definitions without strictNullChecks otherwise.
-            var callSignatures = getSignaturesOfType(type, 0 /* Call */);
-            var isPromise = !!getAwaitedTypeOfPromise(type);
-            if (callSignatures.length === 0 && !isPromise) {
-                return;
-            }
-            var testedSymbol = testedNode && getSymbolAtLocation(testedNode);
-            if (!testedSymbol && !isPromise) {
-                return;
-            }
-            var isUsed = testedSymbol && ts.isBinaryExpression(condExpr.parent) && isSymbolUsedInBinaryExpressionChain(condExpr.parent, testedSymbol)
-                || testedSymbol && body && isSymbolUsedInConditionBody(condExpr, body, testedNode, testedSymbol);
-            if (!isUsed) {
-                if (isPromise) {
-                    errorAndMaybeSuggestAwait(location, 
-                    /*maybeMissingAwait*/ true, ts.Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined, getTypeNameForErrorDisplay(type));
+            helper(condExpr, body);
+            while (ts.isBinaryExpression(condExpr) && condExpr.operatorToken.kind === 56 /* BarBarToken */) {
+                condExpr = condExpr.left;
+                helper(condExpr, body);
+            }
+            function helper(condExpr, body) {
+                var location = ts.isBinaryExpression(condExpr) &&
+                    (condExpr.operatorToken.kind === 56 /* BarBarToken */ || condExpr.operatorToken.kind === 55 /* AmpersandAmpersandToken */)
+                    ? condExpr.right
+                    : condExpr;
+                var type = checkTruthinessExpression(location);
+                var isPropertyExpressionCast = ts.isPropertyAccessExpression(location) && isTypeAssertion(location.expression);
+                if (getFalsyFlags(type) || isPropertyExpressionCast)
+                    return;
+                // While it technically should be invalid for any known-truthy value
+                // to be tested, we de-scope to functions and Promises unreferenced in
+                // the block as a heuristic to identify the most common bugs. There
+                // are too many false positives for values sourced from type
+                // definitions without strictNullChecks otherwise.
+                var callSignatures = getSignaturesOfType(type, 0 /* Call */);
+                var isPromise = !!getAwaitedTypeOfPromise(type);
+                if (callSignatures.length === 0 && !isPromise) {
+                    return;
                 }
-                else {
-                    error(location, ts.Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead);
+                var testedNode = ts.isIdentifier(location) ? location
+                    : ts.isPropertyAccessExpression(location) ? location.name
+                        : ts.isBinaryExpression(location) && ts.isIdentifier(location.right) ? location.right
+                            : undefined;
+                var testedSymbol = testedNode && getSymbolAtLocation(testedNode);
+                if (!testedSymbol && !isPromise) {
+                    return;
+                }
+                var isUsed = testedSymbol && ts.isBinaryExpression(condExpr.parent) && isSymbolUsedInBinaryExpressionChain(condExpr.parent, testedSymbol)
+                    || testedSymbol && body && isSymbolUsedInConditionBody(condExpr, body, testedNode, testedSymbol);
+                if (!isUsed) {
+                    if (isPromise) {
+                        errorAndMaybeSuggestAwait(location, 
+                        /*maybeMissingAwait*/ true, ts.Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined, getTypeNameForErrorDisplay(type));
+                    }
+                    else {
+                        error(location, ts.Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead);
+                    }
                 }
             }
         }
@@ -82299,8 +82372,8 @@ var ts;
                 }
             }
             if (indexInfos.length > 1) {
-                for (var _d = 0, indexInfos_6 = indexInfos; _d < indexInfos_6.length; _d++) {
-                    var info = indexInfos_6[_d];
+                for (var _d = 0, indexInfos_8 = indexInfos; _d < indexInfos_8.length; _d++) {
+                    var info = indexInfos_8[_d];
                     checkIndexConstraintForIndexSignature(type, info);
                 }
             }
@@ -82326,8 +82399,8 @@ var ts;
                     error(errorNode, ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3, symbolToString(prop), typeToString(propType), typeToString(info.keyType), typeToString(info.type));
                 }
             };
-            for (var _i = 0, indexInfos_7 = indexInfos; _i < indexInfos_7.length; _i++) {
-                var info = indexInfos_7[_i];
+            for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
+                var info = indexInfos_9[_i];
                 _loop_27(info);
             }
         }
@@ -82349,8 +82422,8 @@ var ts;
                     error(errorNode, ts.Diagnostics._0_index_type_1_is_not_assignable_to_2_index_type_3, typeToString(checkInfo.keyType), typeToString(checkInfo.type), typeToString(info.keyType), typeToString(info.type));
                 }
             };
-            for (var _i = 0, indexInfos_8 = indexInfos; _i < indexInfos_8.length; _i++) {
-                var info = indexInfos_8[_i];
+            for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
+                var info = indexInfos_10[_i];
                 _loop_28(info);
             }
         }
@@ -82399,9 +82472,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 {
@@ -82411,7 +82484,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));
@@ -84004,10 +84079,10 @@ var ts;
                         }
                         // ECMA262: 15.2.1.1 It is a Syntax Error if the ExportedNames of ModuleItemList contains any duplicate entries.
                         // (TS Exceptions: namespaces, function overloads, enums, and interfaces)
-                        if (flags & (1920 /* Namespace */ | 64 /* Interface */ | 384 /* Enum */)) {
+                        if (flags & (1920 /* Namespace */ | 384 /* Enum */)) {
                             return;
                         }
-                        var exportedDeclarationsCount = ts.countWhere(declarations, isNotOverloadAndNotAccessor);
+                        var exportedDeclarationsCount = ts.countWhere(declarations, ts.and(isNotOverloadAndNotAccessor, ts.not(ts.isInterfaceDeclaration)));
                         if (flags & 524288 /* TypeAlias */ && exportedDeclarationsCount <= 2) {
                             // it is legal to merge type alias with other values
                             // so count should be either 1 (just type alias) or 2 (type alias + merged value)
@@ -87983,7 +88058,7 @@ var ts;
                 return factory.updateConstructorTypeNode(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
             case 180 /* TypeQuery */:
                 ts.Debug.type(node);
-                return factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName));
+                return factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
             case 181 /* TypeLiteral */:
                 ts.Debug.type(node);
                 return factory.updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, ts.isTypeElement));
@@ -90875,8 +90950,8 @@ var ts;
         function generateClassElementDecorationExpressions(node, isStatic) {
             var members = getDecoratedClassElements(node, isStatic);
             var expressions;
-            for (var _i = 0, members_6 = members; _i < members_6.length; _i++) {
-                var member = members_6[_i];
+            for (var _i = 0, members_8 = members; _i < members_8.length; _i++) {
+                var member = members_8[_i];
                 var expression = generateClassElementDecorationExpression(node, member);
                 if (expression) {
                     if (!expressions) {
@@ -96221,8 +96296,8 @@ var ts;
         function convertJsxChildrenToChildrenPropAssignment(children) {
             var nonWhitespaceChildren = ts.getSemanticJsxChildren(children);
             if (ts.length(nonWhitespaceChildren) === 1 && !nonWhitespaceChildren[0].dotDotDotToken) {
-                var result_12 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
-                return result_12 && factory.createPropertyAssignment("children", result_12);
+                var result_13 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
+                return result_13 && factory.createPropertyAssignment("children", result_13);
             }
             var result = ts.mapDefined(children, transformJsxChildToExpression);
             return ts.length(result) ? factory.createPropertyAssignment("children", factory.createArrayLiteralExpression(result)) : undefined;
@@ -109860,6 +109935,8 @@ var ts;
                         return emitAsExpression(node);
                     case 229 /* NonNullExpression */:
                         return emitNonNullExpression(node);
+                    case 227 /* ExpressionWithTypeArguments */:
+                        return emitExpressionWithTypeArguments(node);
                     case 230 /* MetaProperty */:
                         return emitMetaProperty(node);
                     case 231 /* SyntheticExpression */:
@@ -110304,6 +110381,7 @@ var ts;
             writeKeyword("typeof");
             writeSpace();
             emit(node.exprName);
+            emitTypeArguments(node, node.typeArguments);
         }
         function emitTypeLiteral(node) {
             writePunctuation("{");
@@ -115277,15 +115355,15 @@ var ts;
                 // which per above occurred during the current program creation.
                 // Since we assume the filesystem does not change during program creation,
                 // it is safe to reuse resolutions from the earlier call.
-                var result_13 = [];
+                var result_14 = [];
                 var i = 0;
                 for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) {
                     var moduleName = moduleNames_1[_i];
                     var resolvedModule = file.resolvedModules.get(moduleName, getModeForResolutionAtIndex(file, i));
                     i++;
-                    result_13.push(resolvedModule);
+                    result_14.push(resolvedModule);
                 }
-                return result_13;
+                return result_14;
             }
             // At this point, we know at least one of the following hold:
             // - file has local declarations for ambient modules
@@ -120403,9 +120481,9 @@ var ts;
             if (!preferSymlinks) {
                 // Symlinks inside ignored paths are already filtered out of the symlink cache,
                 // so we only need to remove them from the realpath filenames.
-                var result_14 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
-                if (result_14)
-                    return result_14;
+                var result_15 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); });
+                if (result_15)
+                    return result_15;
             }
             var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath();
             var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd);
@@ -120425,10 +120503,10 @@ var ts;
                     for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) {
                         var symlinkDirectory = symlinkDirectories_1[_i];
                         var option = ts.resolvePath(symlinkDirectory, relative);
-                        var result_15 = cb(option, target === referenceRedirect);
+                        var result_16 = cb(option, target === referenceRedirect);
                         shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths
-                        if (result_15)
-                            return result_15;
+                        if (result_16)
+                            return result_16;
                     }
                 });
             });
@@ -124686,7 +124764,7 @@ var ts;
             case 199 /* ImportType */:
                 return !node.parent.isTypeOf;
             case 227 /* ExpressionWithTypeArguments */:
-                return !ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent);
+                return ts.isPartOfTypeNode(node.parent);
         }
         return false;
     }
@@ -126713,14 +126791,15 @@ var ts;
                 : "linkplain";
         var parts = [linkPart("{@" + prefix + " ")];
         if (!link.name) {
-            if (link.text)
+            if (link.text) {
                 parts.push(linkTextPart(link.text));
+            }
         }
         else {
             var symbol = checker === null || checker === void 0 ? void 0 : checker.getSymbolAtLocation(link.name);
             var suffix = findLinkNameEnd(link.text);
             var name = ts.getTextOfNode(link.name) + link.text.slice(0, suffix);
-            var text = link.text.slice(suffix);
+            var text = skipSeparatorFromLinkText(link.text.slice(suffix));
             var decl = (symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration) || ((_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]);
             if (decl) {
                 parts.push(linkNamePart(name, decl));
@@ -126735,6 +126814,15 @@ var ts;
         return parts;
     }
     ts.buildLinkParts = buildLinkParts;
+    function skipSeparatorFromLinkText(text) {
+        var pos = 0;
+        if (text.charCodeAt(pos++) === 124 /* bar */) {
+            while (pos < text.length && text.charCodeAt(pos) === 32 /* space */)
+                pos++;
+            return text.slice(pos);
+        }
+        return text;
+    }
     function findLinkNameEnd(text) {
         if (text.indexOf("()") === 0)
             return 2;
@@ -137971,9 +138059,18 @@ var ts;
         JsDoc.getJsDocTagsFromDeclarations = getJsDocTagsFromDeclarations;
         function getDisplayPartsFromComment(comment, checker) {
             if (typeof comment === "string") {
-                return [ts.textPart(comment)];
+                return [ts.textPart(skipSeparatorFromComment(comment))];
+            }
+            return ts.flatMap(comment, function (node) { return node.kind === 319 /* JSDocText */ ? [ts.textPart(skipSeparatorFromComment(node.text))] : ts.buildLinkParts(node, checker); });
+        }
+        function skipSeparatorFromComment(text) {
+            var pos = 0;
+            if (text.charCodeAt(pos++) === 45 /* minus */) {
+                while (pos < text.length && text.charCodeAt(pos) === 32 /* space */)
+                    pos++;
+                return text.slice(pos);
             }
-            return ts.flatMap(comment, function (node) { return node.kind === 319 /* JSDocText */ ? [ts.textPart(node.text)] : ts.buildLinkParts(node, checker); });
+            return text;
         }
         function getCommentDisplayParts(tag, checker) {
             var comment = tag.comment, kind = tag.kind;
@@ -155351,7 +155448,7 @@ var ts;
                 /*dotDotDotToken*/ undefined, 
                 /*name*/ names && names[i] || "arg" + i, 
                 /*questionToken*/ minArgumentCount !== undefined && i >= minArgumentCount ? ts.factory.createToken(57 /* QuestionToken */) : undefined, 
-                /*type*/ inJs ? undefined : types && types[i] || ts.factory.createKeywordTypeNode(130 /* AnyKeyword */), 
+                /*type*/ inJs ? undefined : types && types[i] || ts.factory.createKeywordTypeNode(154 /* UnknownKeyword */), 
                 /*initializer*/ undefined);
                 parameters.push(newParameter);
             }
@@ -155379,11 +155476,10 @@ var ts;
             var maxArgsParameterSymbolNames = maxArgsSignature.parameters.map(function (symbol) { return symbol.name; });
             var parameters = createDummyParameters(maxNonRestArgs, maxArgsParameterSymbolNames, /* types */ undefined, minArgumentCount, /*inJs*/ false);
             if (someSigHasRestParameter) {
-                var anyArrayType = ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(130 /* AnyKeyword */));
                 var restParameter = ts.factory.createParameterDeclaration(
                 /*decorators*/ undefined, 
                 /*modifiers*/ undefined, ts.factory.createToken(25 /* DotDotDotToken */), maxArgsParameterSymbolNames[maxNonRestArgs] || "rest", 
-                /*questionToken*/ maxNonRestArgs >= minArgumentCount ? ts.factory.createToken(57 /* QuestionToken */) : undefined, anyArrayType, 
+                /*questionToken*/ maxNonRestArgs >= minArgumentCount ? ts.factory.createToken(57 /* QuestionToken */) : undefined, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(154 /* UnknownKeyword */)), 
                 /*initializer*/ undefined);
                 parameters.push(restParameter);
             }
@@ -157629,7 +157725,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) {
@@ -157752,7 +157848,7 @@ var ts;
                     ts.Debug.assert(nodeToCheck.pos <= nodeToCheck.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (1)");
                     // For understanding how skipTrivia functioned:
                     ts.Debug.assert(!ts.positionIsSynthesized(nodeToCheck.pos), "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (2)");
-                    if (!ts.isStatement(nodeToCheck) && !(ts.isExpressionNode(nodeToCheck) && isExtractableExpression(nodeToCheck))) {
+                    if (!ts.isStatement(nodeToCheck) && !(ts.isExpressionNode(nodeToCheck) && isExtractableExpression(nodeToCheck)) && !isStringLiteralJsxAttribute(nodeToCheck)) {
                         return [ts.createDiagnosticForNode(nodeToCheck, Messages.statementOrExpressionExpected)];
                     }
                     if (nodeToCheck.flags & 8388608 /* Ambient */) {
@@ -157932,13 +158028,16 @@ var ts;
                 if (ts.isStatement(node)) {
                     return [node];
                 }
-                else if (ts.isExpressionNode(node)) {
+                if (ts.isExpressionNode(node)) {
                     // If our selection is the expression in an ExpressionStatement, expand
                     // the selection to include the enclosing Statement (this stops us
                     // from trying to care about the return value of the extracted function
                     // and eliminates double semicolon insertion in certain scenarios)
                     return ts.isExpressionStatement(node.parent) ? [node.parent] : node;
                 }
+                if (isStringLiteralJsxAttribute(node)) {
+                    return node;
+                }
                 return undefined;
             }
             function isScope(node) {
@@ -158748,7 +158847,7 @@ var ts;
                 // Unfortunately, this code takes advantage of the knowledge that the generated method
                 // will use the contextual type of an expression as the return type of the extracted
                 // method (and will therefore "use" all the types involved).
-                if (inGenericContext && !isReadonlyArray(targetRange.range)) {
+                if (inGenericContext && !isReadonlyArray(targetRange.range) && !ts.isJsxAttribute(targetRange.range)) {
                     var contextualType = checker.getContextualType(targetRange.range); // TODO: GH#18217
                     recordTypeParameterUsages(contextualType);
                 }
@@ -159073,7 +159172,11 @@ var ts;
                 }
             }
             function isInJSXContent(node) {
-                return (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) && (ts.isJsxElement(node.parent) || ts.isJsxFragment(node.parent));
+                return isStringLiteralJsxAttribute(node) ||
+                    (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) && (ts.isJsxElement(node.parent) || ts.isJsxFragment(node.parent));
+            }
+            function isStringLiteralJsxAttribute(node) {
+                return ts.isStringLiteral(node) && node.parent && ts.isJsxAttribute(node.parent);
             }
         })(extractSymbol = refactor.extractSymbol || (refactor.extractSymbol = {}));
     })(refactor = ts.refactor || (ts.refactor = {}));