typescript 4.8.0-dev.20220614 → 4.8.0-dev.20220617

package/lib/tsserverlibrary.js

@@ -91,6 +91,15 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 /* @internal */
 var ts;
 (function (ts) {
@@ -294,7 +303,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.20220614";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220617";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -8668,9 +8677,11 @@ var ts;
         Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true),
         The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."),
         The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."),
-        This_type_parameter_probably_needs_an_extends_object_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_probably_needs_an_extends_object_constraint_2208", "This type parameter probably needs an `extends object` constraint."),
+        This_type_parameter_might_need_an_extends_0_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
         The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."),
+        Add_extends_constraint: diag(2211, ts.DiagnosticCategory.Message, "Add_extends_constraint_2211", "Add `extends` constraint."),
+        Add_extends_constraint_to_all_type_parameters: diag(2212, ts.DiagnosticCategory.Message, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"),
         Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."),
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."),
         Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."),
@@ -9156,6 +9167,8 @@ var ts;
         This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: diag(2839, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."),
         An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes: diag(2840, ts.DiagnosticCategory.Error, "An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_clas_2840", "An interface cannot extend a primitive type like '{0}'; an interface can only extend named types and classes"),
         The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_feature_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(2841, ts.DiagnosticCategory.Error, "The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_2841", "The type of this expression cannot be named without a 'resolution-mode' assertion, which is an unstable feature. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
+        _0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation: diag(2842, ts.DiagnosticCategory.Error, "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842", "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?"),
+        We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here: diag(2843, ts.DiagnosticCategory.Error, "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843", "We can only write a type for '{0}' by adding a type for the entire parameter here."),
         Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -9853,6 +9866,8 @@ var ts;
         Qualified_name_0_is_not_allowed_without_a_leading_param_object_1: diag(8032, ts.DiagnosticCategory.Error, "Qualified_name_0_is_not_allowed_without_a_leading_param_object_1_8032", "Qualified name '{0}' is not allowed without a leading '@param {object} {1}'."),
         A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags: diag(8033, ts.DiagnosticCategory.Error, "A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags_8033", "A JSDoc '@typedef' comment may not contain multiple '@type' tags."),
         The_tag_was_first_specified_here: diag(8034, ts.DiagnosticCategory.Error, "The_tag_was_first_specified_here_8034", "The tag was first specified here."),
+        You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder: diag(8035, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder_8035", "You cannot rename elements that are defined in a 'node_modules' folder."),
+        You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder: diag(8036, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder_8036", "You cannot rename elements that are defined in another 'node_modules' folder."),
         Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9005, ts.DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_9005", "Declaration emit for this file requires using private name '{0}'. An explicit type annotation may unblock declaration emit."),
         Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, ts.DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."),
         JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17000, ts.DiagnosticCategory.Error, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."),
@@ -35970,10 +35985,11 @@ var ts;
             }
             nextToken();
             var typeArguments = parseDelimitedList(20 /* TypeArguments */, parseType);
-            if (!parseExpected(31 /* GreaterThanToken */)) {
+            if (reScanGreaterToken() !== 31 /* GreaterThanToken */) {
                 // If it doesn't have the closing `>` then it's definitely not an type argument list.
                 return undefined;
             }
+            nextToken();
             // 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
@@ -49090,9 +49106,9 @@ var ts;
                 return moduleSpecifier && resolveExternalModuleName(moduleSpecifier, moduleSpecifier, /*ignoreErrors*/ true);
             },
             resolveExternalModuleSymbol: resolveExternalModuleSymbol,
-            tryGetThisTypeAt: function (nodeIn, includeGlobalThis) {
+            tryGetThisTypeAt: function (nodeIn, includeGlobalThis, container) {
                 var node = ts.getParseTreeNode(nodeIn);
-                return node && tryGetThisTypeAt(node, includeGlobalThis);
+                return node && tryGetThisTypeAt(node, includeGlobalThis, container);
             },
             getTypeArgumentConstraint: function (nodeIn) {
                 var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode);
@@ -49387,6 +49403,7 @@ var ts;
         var potentialNewTargetCollisions = [];
         var potentialWeakMapSetCollisions = [];
         var potentialReflectCollisions = [];
+        var potentialUnusedRenamedBindingElementsInTypes = [];
         var awaitedTypeStack = [];
         var diagnostics = ts.createDiagnosticCollection();
         var suggestionDiagnostics = ts.createDiagnosticCollection();
@@ -52722,6 +52739,9 @@ var ts;
             if (symbol && symbol.flags & 262144 /* TypeParameter */ && meaning & 788968 /* Type */) {
                 return { accessibility: 0 /* Accessible */ };
             }
+            if (!symbol && ts.isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(ts.getThisContainer(firstIdentifier, /*includeArrowFunctions*/ false)), firstIdentifier, meaning, /*computeAliases*/ false).accessibility === 0 /* Accessible */) {
+                return { accessibility: 0 /* Accessible */ };
+            }
             // Verify if the symbol is accessible
             return (symbol && hasVisibleDeclarations(symbol, /*shouldComputeAliasToMakeVisible*/ true)) || {
                 accessibility: 1 /* NotAccessible */,
@@ -53894,15 +53914,22 @@ var ts;
                 context.approximateLength += ts.symbolName(parameterSymbol).length + 3;
                 return parameterNode;
                 function cloneBindingName(node) {
-                    return elideInitializerAndSetEmitFlags(node);
-                    function elideInitializerAndSetEmitFlags(node) {
+                    return elideInitializerAndPropertyRenamingAndSetEmitFlags(node);
+                    function elideInitializerAndPropertyRenamingAndSetEmitFlags(node) {
                         if (context.tracker.trackSymbol && ts.isComputedPropertyName(node) && isLateBindableName(node)) {
                             trackComputedName(node.expression, context.enclosingDeclaration, context);
                         }
-                        var visited = ts.visitEachChild(node, elideInitializerAndSetEmitFlags, ts.nullTransformationContext, /*nodesVisitor*/ undefined, elideInitializerAndSetEmitFlags);
+                        var visited = ts.visitEachChild(node, elideInitializerAndPropertyRenamingAndSetEmitFlags, ts.nullTransformationContext, /*nodesVisitor*/ undefined, elideInitializerAndPropertyRenamingAndSetEmitFlags);
                         if (ts.isBindingElement(visited)) {
-                            visited = ts.factory.updateBindingElement(visited, visited.dotDotDotToken, visited.propertyName, visited.name, 
-                            /*initializer*/ undefined);
+                            if (visited.propertyName && ts.isIdentifier(visited.propertyName) && ts.isIdentifier(visited.name)) {
+                                visited = ts.factory.updateBindingElement(visited, visited.dotDotDotToken, 
+                                /* propertyName*/ undefined, visited.propertyName, 
+                                /*initializer*/ undefined);
+                            }
+                            else {
+                                visited = ts.factory.updateBindingElement(visited, visited.dotDotDotToken, visited.propertyName, visited.name, 
+                                /*initializer*/ undefined);
+                            }
                         }
                         if (!ts.nodeIsSynthesized(visited)) {
                             visited = ts.factory.cloneNode(visited);
@@ -59529,7 +59556,7 @@ var ts;
                 }
                 if (t.flags & 268435456 /* StringMapping */) {
                     var constraint = getBaseConstraint(t.type);
-                    return constraint ? getStringMappingType(t.symbol, constraint) : stringType;
+                    return constraint && constraint !== t.type ? getStringMappingType(t.symbol, constraint) : stringType;
                 }
                 if (t.flags & 8388608 /* IndexedAccess */) {
                     if (isMappedTypeGenericIndexedAccess(t)) {
@@ -62499,9 +62526,12 @@ var ts;
         }
         function getStringMappingType(symbol, type) {
             return type.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapType(type, function (t) { return getStringMappingType(symbol, t); }) :
-                isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) :
-                    type.flags & 128 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) :
-                        type;
+                // Mapping<Mapping<T>> === Mapping<T>
+                type.flags & 268435456 /* StringMapping */ && symbol === type.symbol ? type :
+                    isGenericIndexType(type) || isPatternLiteralPlaceholderType(type) ? getStringMappingTypeForGenericType(symbol, isPatternLiteralPlaceholderType(type) && !(type.flags & 268435456 /* StringMapping */) ? getTemplateLiteralType(["", ""], [type]) : type) :
+                        type.flags & 128 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) :
+                            type.flags & 134217728 /* TemplateLiteral */ ? getTemplateLiteralType.apply(void 0, applyTemplateStringMapping(symbol, type.texts, type.types)) :
+                                type;
         }
         function applyStringMapping(symbol, str) {
             switch (intrinsicTypeKinds.get(symbol.escapedName)) {
@@ -62512,6 +62542,15 @@ var ts;
             }
             return str;
         }
+        function applyTemplateStringMapping(symbol, texts, types) {
+            switch (intrinsicTypeKinds.get(symbol.escapedName)) {
+                case 0 /* Uppercase */: return [texts.map(function (t) { return t.toUpperCase(); }), types.map(function (t) { return getStringMappingType(symbol, t); })];
+                case 1 /* Lowercase */: return [texts.map(function (t) { return t.toLowerCase(); }), types.map(function (t) { return getStringMappingType(symbol, t); })];
+                case 2 /* Capitalize */: return [texts[0] === "" ? texts : __spreadArray([texts[0].charAt(0).toUpperCase() + texts[0].slice(1)], texts.slice(1), true), texts[0] === "" ? __spreadArray([getStringMappingType(symbol, types[0])], types.slice(1), true) : types];
+                case 3 /* Uncapitalize */: return [texts[0] === "" ? texts : __spreadArray([texts[0].charAt(0).toLowerCase() + texts[0].slice(1)], texts.slice(1), true), texts[0] === "" ? __spreadArray([getStringMappingType(symbol, types[0])], types.slice(1), true) : types];
+            }
+            return [texts, types];
+        }
         function getStringMappingTypeForGenericType(symbol, type) {
             var id = getSymbolId(symbol) + "," + getTypeId(type);
             var result = stringMappingTypes.get(id);
@@ -62753,7 +62792,7 @@ var ts;
                         accessNode;
         }
         function isPatternLiteralPlaceholderType(type) {
-            return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */));
+            return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) || !!(type.flags & 268435456 /* StringMapping */ && isPatternLiteralPlaceholderType(type.type));
         }
         function isPatternLiteralType(type) {
             return !!(type.flags & 134217728 /* TemplateLiteral */) && ts.every(type.types, isPatternLiteralPlaceholderType);
@@ -65675,8 +65714,13 @@ var ts;
                     return;
                 }
                 reportRelationError(headMessage, source, target);
-                if (strictNullChecks && source.flags & 8650752 /* TypeVariable */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source) && isRelatedTo(emptyObjectType, extractTypesOfKind(target, ~67108864 /* NonPrimitive */))) {
-                    associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_probably_needs_an_extends_object_constraint));
+                if (source.flags & 262144 /* TypeParameter */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source)) {
+                    var syntheticParam = cloneTypeParameter(source);
+                    syntheticParam.constraint = instantiateType(target, makeUnaryTypeMapper(source, syntheticParam));
+                    if (hasNonCircularBaseConstraint(syntheticParam)) {
+                        var targetConstraintString = typeToString(target, source.symbol.declarations[0]);
+                        associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString));
+                    }
                 }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
@@ -66460,6 +66504,13 @@ var ts;
                         return -1 /* True */;
                     }
                 }
+                else if (target.flags & 268435456 /* StringMapping */) {
+                    if (!(source.flags & 268435456 /* StringMapping */)) {
+                        if (isMemberOfStringMapping(source, target)) {
+                            return -1 /* True */;
+                        }
+                    }
+                }
                 if (sourceFlags & 8650752 /* TypeVariable */) {
                     // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch
                     if (!(sourceFlags & 8388608 /* IndexedAccess */ && targetFlags & 8388608 /* IndexedAccess */)) {
@@ -66503,7 +66554,10 @@ var ts;
                     }
                 }
                 else if (sourceFlags & 268435456 /* StringMapping */) {
-                    if (targetFlags & 268435456 /* StringMapping */ && source.symbol === target.symbol) {
+                    if (targetFlags & 268435456 /* StringMapping */) {
+                        if (source.symbol !== target.symbol) {
+                            return 0 /* False */;
+                        }
                         if (result = isRelatedTo(source.type, target.type, 3 /* Both */, reportErrors)) {
                             resetErrorInfo(saveErrorInfo);
                             return result;
@@ -67428,7 +67482,7 @@ var ts;
                     return typeCouldHaveTopLevelSingletonTypes(constraint);
                 }
             }
-            return isUnitType(type) || !!(type.flags & 134217728 /* TemplateLiteral */);
+            return isUnitType(type) || !!(type.flags & 134217728 /* TemplateLiteral */) || !!(type.flags & 268435456 /* StringMapping */);
         }
         function getExactOptionalUnassignableProperties(source, target) {
             if (isTupleType(source) && isTupleType(target))
@@ -68226,12 +68280,13 @@ var ts;
          * with no call or construct signatures.
          */
         function isObjectTypeWithInferableIndex(type) {
+            var objectFlags = ts.getObjectFlags(type);
             return type.flags & 2097152 /* Intersection */
                 ? ts.every(type.types, isObjectTypeWithInferableIndex)
                 : !!(type.symbol
                     && (type.symbol.flags & (4096 /* ObjectLiteral */ | 2048 /* TypeLiteral */ | 384 /* Enum */ | 512 /* ValueModule */)) !== 0
                     && !(type.symbol.flags & 32 /* Class */)
-                    && !typeHasCallOrConstructSignatures(type)) || !!(ts.getObjectFlags(type) & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
+                    && !typeHasCallOrConstructSignatures(type)) || !!(objectFlags & 4194304 /* ObjectRestType */) || !!(objectFlags & 1024 /* ReverseMapped */ && isObjectTypeWithInferableIndex(type.source));
         }
         function createSymbolWithType(source, type) {
             var symbol = createSymbol(source.flags, source.escapedName, ts.getCheckFlags(source) & 8 /* Readonly */);
@@ -68898,6 +68953,31 @@ var ts;
             return success && result === 9 /* BigIntLiteral */ && scanner.getTextPos() === (s.length + 1) && !(flags & 512 /* ContainsSeparator */)
                 && (!roundTripOnly || s === ts.pseudoBigIntToString({ negative: negative, base10Value: ts.parsePseudoBigInt(scanner.getTokenValue()) }));
         }
+        function isMemberOfStringMapping(source, target) {
+            if (target.flags & (4 /* String */ | 3 /* AnyOrUnknown */)) {
+                return true;
+            }
+            if (target.flags & 134217728 /* TemplateLiteral */) {
+                return isTypeAssignableTo(source, target);
+            }
+            if (target.flags & 268435456 /* StringMapping */) {
+                // We need to see whether applying the same mappings of the target
+                // onto the source would produce an identical type *and* that
+                // it's compatible with the inner-most non-string-mapped type.
+                //
+                // The intuition here is that if same mappings don't affect the source at all,
+                // and the source is compatible with the unmapped target, then they must
+                // still reside in the same domain.
+                var mappingStack = [];
+                while (target.flags & 268435456 /* StringMapping */) {
+                    mappingStack.unshift(target.symbol);
+                    target = target.type;
+                }
+                var mappedSource = ts.reduceLeft(mappingStack, function (memo, value) { return getStringMappingType(value, memo); }, source);
+                return mappedSource === source && isMemberOfStringMapping(source, target);
+            }
+            return false;
+        }
         function isValidTypeForTemplateLiteralPlaceholder(source, target) {
             if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
                 return true;
@@ -68906,7 +68986,8 @@ var ts;
                 var value = source.value;
                 return !!(target.flags & 8 /* Number */ && isValidNumberString(value, /*roundTripOnly*/ false) ||
                     target.flags & 64 /* BigInt */ && isValidBigIntString(value, /*roundTripOnly*/ false) ||
-                    target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName);
+                    target.flags & (512 /* BooleanLiteral */ | 98304 /* Nullable */) && value === target.intrinsicName ||
+                    target.flags & 268435456 /* StringMapping */ && isMemberOfStringMapping(getStringLiteralType(value), target));
             }
             if (source.flags & 134217728 /* TemplateLiteral */) {
                 var texts = source.texts;
@@ -82830,6 +82911,22 @@ var ts;
                 }
             });
         }
+        function checkPotentialUncheckedRenamedBindingElementsInTypes() {
+            var _a;
+            for (var _i = 0, potentialUnusedRenamedBindingElementsInTypes_1 = potentialUnusedRenamedBindingElementsInTypes; _i < potentialUnusedRenamedBindingElementsInTypes_1.length; _i++) {
+                var node = potentialUnusedRenamedBindingElementsInTypes_1[_i];
+                if (!((_a = getSymbolOfNode(node)) === null || _a === void 0 ? void 0 : _a.isReferenced)) {
+                    var wrappingDeclaration = ts.walkUpBindingElementsAndPatterns(node);
+                    ts.Debug.assert(ts.isParameterDeclaration(wrappingDeclaration), "Only parameter declaration should be checked here");
+                    var diagnostic = ts.createDiagnosticForNode(node.name, ts.Diagnostics._0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation, ts.declarationNameToString(node.name), ts.declarationNameToString(node.propertyName));
+                    if (!wrappingDeclaration.type) {
+                        // entire parameter does not have type annotation, suggest adding an annotation
+                        ts.addRelatedInfo(diagnostic, ts.createFileDiagnostic(ts.getSourceFileOfNode(wrappingDeclaration), wrappingDeclaration.end, 1, ts.Diagnostics.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here, ts.declarationNameToString(node.propertyName)));
+                    }
+                    diagnostics.add(diagnostic);
+                }
+            }
+        }
         function bindingNameText(name) {
             switch (name.kind) {
                 case 79 /* Identifier */:
@@ -83131,6 +83228,17 @@ var ts;
                 }
             }
             if (ts.isBindingElement(node)) {
+                if (node.propertyName &&
+                    ts.isIdentifier(node.name) &&
+                    ts.isParameterDeclaration(node) &&
+                    ts.nodeIsMissing(ts.getContainingFunction(node).body)) {
+                    // type F = ({a: string}) => void;
+                    //               ^^^^^^
+                    // variable renaming in function type notation is confusing,
+                    // so we forbid it even if noUnusedLocals is not enabled
+                    potentialUnusedRenamedBindingElementsInTypes.push(node);
+                    return;
+                }
                 if (ts.isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ES2018 */) {
                     checkExternalEmitHelpers(node, 4 /* Rest */);
                 }
@@ -86594,6 +86702,7 @@ var ts;
                 ts.clear(potentialNewTargetCollisions);
                 ts.clear(potentialWeakMapSetCollisions);
                 ts.clear(potentialReflectCollisions);
+                ts.clear(potentialUnusedRenamedBindingElementsInTypes);
                 ts.forEach(node.statements, checkSourceElement);
                 checkSourceElement(node.endOfFileToken);
                 checkDeferredNodes(node);
@@ -86609,6 +86718,9 @@ var ts;
                             }
                         });
                     }
+                    if (!node.isDeclarationFile) {
+                        checkPotentialUncheckedRenamedBindingElementsInTypes();
+                    }
                 });
                 if (compilerOptions.importsNotUsedAsValues === 2 /* Error */ &&
                     !node.isDeclarationFile &&
@@ -109350,7 +109462,7 @@ var ts;
             });
             return ret;
         }
-        function filterBindingPatternInitializers(name) {
+        function filterBindingPatternInitializersAndRenamings(name) {
             if (name.kind === 79 /* Identifier */) {
                 return name;
             }
@@ -109366,7 +109478,12 @@ var ts;
                 if (elem.kind === 227 /* OmittedExpression */) {
                     return elem;
                 }
-                return factory.updateBindingElement(elem, elem.dotDotDotToken, elem.propertyName, filterBindingPatternInitializers(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined);
+                if (elem.propertyName && ts.isIdentifier(elem.propertyName) && ts.isIdentifier(elem.name) && !elem.symbol.isReferenced) {
+                    // Unnecessary property renaming is forbidden in types, so remove renaming
+                    return factory.updateBindingElement(elem, elem.dotDotDotToken, 
+                    /* propertyName */ undefined, elem.propertyName, shouldPrintWithInitializer(elem) ? elem.initializer : undefined);
+                }
+                return factory.updateBindingElement(elem, elem.dotDotDotToken, elem.propertyName, filterBindingPatternInitializersAndRenamings(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined);
             }
         }
         function ensureParameter(p, modifierMask, type) {
@@ -109375,7 +109492,7 @@ var ts;
                 oldDiag = getSymbolAccessibilityDiagnostic;
                 getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(p);
             }
-            var newParam = factory.updateParameterDeclaration(p, maskModifiers(p, modifierMask), p.dotDotDotToken, filterBindingPatternInitializers(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || factory.createToken(57 /* QuestionToken */)) : undefined, ensureType(p, type || p.type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param
+            var newParam = factory.updateParameterDeclaration(p, maskModifiers(p, modifierMask), p.dotDotDotToken, filterBindingPatternInitializersAndRenamings(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || factory.createToken(57 /* QuestionToken */)) : undefined, ensureType(p, type || p.type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param
             ensureNoInitializer(p));
             if (!suppressNewDiagnosticContexts) {
                 getSymbolAccessibilityDiagnostic = oldDiag;
@@ -117518,6 +117635,7 @@ var ts;
         ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations.code,
         ts.Diagnostics.Class_constructor_may_not_be_a_generator.code,
         ts.Diagnostics.Class_constructor_may_not_be_an_accessor.code,
+        ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
     ]);
     /**
      * Determine if source file needs to be re-created even if its text hasn't changed
@@ -135327,7 +135445,7 @@ var ts;
                 }
                 // Need to insert 'this.' before properties of `this` type, so only do that if `includeInsertTextCompletions`
                 if (preferences.includeCompletionsWithInsertText && scopeNode.kind !== 305 /* SourceFile */) {
-                    var thisType = typeChecker.tryGetThisTypeAt(scopeNode, /*includeGlobalThis*/ false);
+                    var thisType = typeChecker.tryGetThisTypeAt(scopeNode, /*includeGlobalThis*/ false, ts.isClassLike(scopeNode.parent) ? scopeNode : undefined);
                     if (thisType && !isProbablyGlobalType(thisType, sourceFile, typeChecker)) {
                         for (var _i = 0, _a = getPropertiesForCompletion(thisType, typeChecker); _i < _a.length; _i++) {
                             var symbol = _a[_i];
@@ -144665,10 +144783,10 @@ var ts;
 (function (ts) {
     var Rename;
     (function (Rename) {
-        function getRenameInfo(program, sourceFile, position, options) {
+        function getRenameInfo(program, sourceFile, position, preferences) {
             var node = ts.getAdjustedRenameLocation(ts.getTouchingPropertyName(sourceFile, position));
             if (nodeIsEligibleForRename(node)) {
-                var renameInfo = getRenameInfoForNode(node, program.getTypeChecker(), sourceFile, program, options);
+                var renameInfo = getRenameInfoForNode(node, program.getTypeChecker(), sourceFile, program, preferences);
                 if (renameInfo) {
                     return renameInfo;
                 }
@@ -144676,7 +144794,7 @@ var ts;
             return getRenameInfoError(ts.Diagnostics.You_cannot_rename_this_element);
         }
         Rename.getRenameInfo = getRenameInfo;
-        function getRenameInfoForNode(node, typeChecker, sourceFile, program, options) {
+        function getRenameInfoForNode(node, typeChecker, sourceFile, program, preferences) {
             var symbol = typeChecker.getSymbolAtLocation(node);
             if (!symbol) {
                 if (ts.isStringLiteralLike(node)) {
@@ -144704,7 +144822,12 @@ var ts;
                 return undefined;
             }
             if (ts.isStringLiteralLike(node) && ts.tryGetImportFromModuleSpecifier(node)) {
-                return options && options.allowRenameOfImportPath ? getRenameInfoForModule(node, sourceFile, symbol) : undefined;
+                return preferences.allowRenameOfImportPath ? getRenameInfoForModule(node, sourceFile, symbol) : undefined;
+            }
+            // Disallow rename for elements that would rename across `*/node_modules/*` packages.
+            var wouldRenameNodeModules = wouldRenameInOtherNodeModules(sourceFile, symbol, typeChecker, preferences);
+            if (wouldRenameNodeModules) {
+                return getRenameInfoError(wouldRenameNodeModules);
             }
             var kind = ts.SymbolDisplay.getSymbolKind(typeChecker, symbol, node);
             var specifierName = (ts.isImportOrExportSpecifierName(node) || ts.isStringOrNumericLiteralLike(node) && node.parent.kind === 162 /* ComputedPropertyName */)
@@ -144718,6 +144841,49 @@ var ts;
             var sourceFile = declaration.getSourceFile();
             return program.isSourceFileDefaultLibrary(sourceFile) && ts.fileExtensionIs(sourceFile.fileName, ".d.ts" /* Dts */);
         }
+        function wouldRenameInOtherNodeModules(originalFile, symbol, checker, preferences) {
+            if (!preferences.providePrefixAndSuffixTextForRename && symbol.flags & 2097152 /* Alias */) {
+                var importSpecifier = symbol.declarations && ts.find(symbol.declarations, function (decl) { return ts.isImportSpecifier(decl); });
+                if (importSpecifier && !importSpecifier.propertyName) {
+                    symbol = checker.getAliasedSymbol(symbol);
+                }
+            }
+            var declarations = symbol.declarations;
+            if (!declarations) {
+                return undefined;
+            }
+            var originalPackage = getPackagePathComponents(originalFile.path);
+            if (originalPackage === undefined) { // original source file is not in node_modules
+                if (ts.some(declarations, function (declaration) { return ts.isInsideNodeModules(declaration.getSourceFile().path); })) {
+                    return ts.Diagnostics.You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder;
+                }
+                else {
+                    return undefined;
+                }
+            }
+            // original source file is in node_modules
+            for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) {
+                var declaration = declarations_4[_i];
+                var declPackage = getPackagePathComponents(declaration.getSourceFile().path);
+                if (declPackage) {
+                    var length_2 = Math.min(originalPackage.length, declPackage.length);
+                    for (var i = 0; i <= length_2; i++) {
+                        if (ts.compareStringsCaseSensitive(originalPackage[i], declPackage[i]) !== 0 /* EqualTo */) {
+                            return ts.Diagnostics.You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder;
+                        }
+                    }
+                }
+            }
+            return undefined;
+        }
+        function getPackagePathComponents(filePath) {
+            var components = ts.getPathComponents(filePath);
+            var nodeModulesIdx = components.lastIndexOf("node_modules");
+            if (nodeModulesIdx === -1) {
+                return undefined;
+            }
+            return components.slice(0, nodeModulesIdx + 2);
+        }
         function getRenameInfoForModule(node, sourceFile, moduleSymbol) {
             if (!ts.isExternalModuleNameRelative(node.text)) {
                 return getRenameInfoError(ts.Diagnostics.You_cannot_rename_a_module_via_a_global_import);
@@ -145772,7 +145938,7 @@ var ts;
                 return type.symbol && (type.symbol.flags & 1536 /* Module */);
             }
             function visitVariableLikeDeclaration(decl) {
-                if (!decl.initializer || ts.isBindingPattern(decl.name)) {
+                if (!decl.initializer || ts.isBindingPattern(decl.name) || ts.isVariableDeclaration(decl) && !isHintableDeclaration(decl)) {
                     return;
                 }
                 var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(decl);
@@ -145900,6 +146066,9 @@ var ts;
                 }
                 for (var i = 0; i < node.parameters.length && i < signature.parameters.length; ++i) {
                     var param = node.parameters[i];
+                    if (!isHintableDeclaration(param)) {
+                        continue;
+                    }
                     var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(param);
                     if (effectiveTypeAnnotation) {
                         continue;
@@ -145941,6 +146110,13 @@ var ts;
             function isUndefined(name) {
                 return name === "undefined";
             }
+            function isHintableDeclaration(node) {
+                if ((ts.isParameterDeclaration(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) && node.initializer) {
+                    var initializer = ts.skipParentheses(node.initializer);
+                    return !(isHintableLiteral(initializer) || ts.isNewExpression(initializer) || ts.isObjectLiteralExpression(initializer) || ts.isAssertionExpression(initializer));
+                }
+                return true;
+            }
         }
         InlayHints.provideInlayHints = provideInlayHints;
     })(InlayHints = ts.InlayHints || (ts.InlayHints = {}));
@@ -155379,6 +155555,77 @@ var ts;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
+(function (ts) {
+    var codefix;
+    (function (codefix) {
+        var fixId = "addMissingConstraint";
+        var errorCodes = [
+            // We want errors this could be attached to:
+            // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint
+            ts.Diagnostics.Type_0_is_not_comparable_to_type_1.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code,
+            ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code,
+            ts.Diagnostics.Property_0_is_incompatible_with_index_signature.code,
+            ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_type_2.code,
+            ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code,
+        ];
+        codefix.registerCodeFix({
+            errorCodes: errorCodes,
+            getCodeActions: function (context) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program;
+                var related = getDiagnosticRelatedInfo(program, sourceFile, span);
+                if (!related) {
+                    return;
+                }
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, related); });
+                return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_extends_constraint, fixId, ts.Diagnostics.Add_extends_constraint_to_all_type_parameters)];
+            },
+            fixIds: [fixId],
+            getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) {
+                var info = getDiagnosticRelatedInfo(context.program, context.sourceFile, diag);
+                if (!info)
+                    return;
+                return addMissingConstraint(changes, info);
+            }); },
+        });
+        function getDiagnosticRelatedInfo(program, sourceFile, span) {
+            var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; });
+            if (!diag || !diag.relatedInformation)
+                return;
+            var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; });
+            if (!related)
+                return;
+            return related;
+        }
+        function addMissingConstraint(changes, related) {
+            var decl = findAncestorMatchingSpan(related.file, related);
+            if (!decl)
+                return;
+            if (ts.isIdentifier(decl) && ts.isTypeParameterDeclaration(decl.parent)) {
+                decl = decl.parent;
+            }
+            if (!ts.isTypeParameterDeclaration(decl) || ts.isMappedTypeNode(decl.parent))
+                return; // should only issue fix on type parameters written using `extends`
+            var newConstraint = ts.flattenDiagnosticMessageText(related.messageText, "\n", 0).match(/`extends (.*)`/);
+            if (!newConstraint)
+                return;
+            var newConstraintText = newConstraint[1];
+            changes.insertText(related.file, related.start + related.length, " extends " + newConstraintText);
+        }
+        function findAncestorMatchingSpan(sourceFile, span) {
+            var token = ts.getTokenAtPosition(sourceFile, span.start);
+            var end = ts.textSpanEnd(span);
+            while (token.end < end) {
+                token = token.parent;
+            }
+            return token;
+        }
+    })(codefix = ts.codefix || (ts.codefix = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
 (function (ts) {
     var codefix;
     (function (codefix) {
@@ -161676,11 +161923,11 @@ var ts;
                         }
                     }
                     else if (ts.isVariableStatement(node) || ts.isVariableDeclarationList(node)) {
-                        var declarations_5 = ts.isVariableStatement(node) ? node.declarationList.declarations : node.declarations;
+                        var declarations_6 = ts.isVariableStatement(node) ? node.declarationList.declarations : node.declarations;
                         var numInitializers = 0;
                         var lastInitializer = void 0;
-                        for (var _i = 0, declarations_4 = declarations_5; _i < declarations_4.length; _i++) {
-                            var declaration = declarations_4[_i];
+                        for (var _i = 0, declarations_5 = declarations_6; _i < declarations_5.length; _i++) {
+                            var declaration = declarations_5[_i];
                             if (declaration.initializer) {
                                 numInitializers++;
                                 lastInitializer = declaration.initializer;
@@ -165817,8 +166064,8 @@ var ts;
                     tags = __spreadArray(__spreadArray([], inheritedTags, true), tags, true);
                 }
             };
-            for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) {
-                var declaration = declarations_6[_i];
+            for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
+                var declaration = declarations_7[_i];
                 _loop_21(declaration);
             }
         }
@@ -165844,8 +166091,8 @@ var ts;
                 if (inheritedDocs)
                     doc = doc.length === 0 ? inheritedDocs.slice() : inheritedDocs.concat(ts.lineBreakPart(), doc);
             };
-            for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) {
-                var declaration = declarations_7[_i];
+            for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) {
+                var declaration = declarations_8[_i];
                 _loop_22(declaration);
             }
         }
@@ -167422,9 +167669,9 @@ var ts;
                 return ts.stringContains(path, "/node_modules/");
             }
         }
-        function getRenameInfo(fileName, position, options) {
+        function getRenameInfo(fileName, position, preferences) {
             synchronizeHostData();
-            return ts.Rename.getRenameInfo(program, getValidSourceFile(fileName), position, options);
+            return ts.Rename.getRenameInfo(program, getValidSourceFile(fileName), position, preferences || {});
         }
         function getRefactorContext(file, positionOrRange, preferences, formatOptions, triggerReason, kind) {
             var _a = typeof positionOrRange === "number" ? [positionOrRange, undefined] : [positionOrRange.pos, positionOrRange.end], startPosition = _a[0], endPosition = _a[1];
@@ -168790,9 +169037,9 @@ var ts;
             var _this = this;
             return this.forwardJSONCall("getImplementationAtPosition('" + fileName + "', " + position + ")", function () { return _this.languageService.getImplementationAtPosition(fileName, position); });
         };
-        LanguageServiceShimObject.prototype.getRenameInfo = function (fileName, position, options) {
+        LanguageServiceShimObject.prototype.getRenameInfo = function (fileName, position, preferences) {
             var _this = this;
-            return this.forwardJSONCall("getRenameInfo('" + fileName + "', " + position + ")", function () { return _this.languageService.getRenameInfo(fileName, position, options); });
+            return this.forwardJSONCall("getRenameInfo('" + fileName + "', " + position + ")", function () { return _this.languageService.getRenameInfo(fileName, position, preferences); });
         };
         LanguageServiceShimObject.prototype.getSmartSelectionRange = function (fileName, position) {
             var _this = this;
@@ -170590,6 +170837,38 @@ var ts;
                 }
                 return result.module;
             };
+            /*@internal*/
+            Project.importServicePluginAsync = function (moduleName, initialDir, host, log, logErrors) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var resolvedPath, result, e_1, err;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                ts.Debug.assertIsDefined(host.importServicePlugin);
+                                resolvedPath = ts.combinePaths(initialDir, "node_modules");
+                                log("Dynamically importing " + moduleName + " from " + initialDir + " (resolved to " + resolvedPath + ")");
+                                _a.label = 1;
+                            case 1:
+                                _a.trys.push([1, 3, , 4]);
+                                return [4 /*yield*/, host.importServicePlugin(resolvedPath, moduleName)];
+                            case 2:
+                                result = _a.sent();
+                                return [3 /*break*/, 4];
+                            case 3:
+                                e_1 = _a.sent();
+                                result = { module: undefined, error: e_1 };
+                                return [3 /*break*/, 4];
+                            case 4:
+                                if (result.error) {
+                                    err = result.error.stack || result.error.message || JSON.stringify(result.error);
+                                    (logErrors || log)("Failed to dynamically import module '" + moduleName + "' from " + resolvedPath + ": " + err);
+                                    return [2 /*return*/, undefined];
+                                }
+                                return [2 /*return*/, result.module];
+                        }
+                    });
+                });
+            };
             Project.prototype.isKnownTypesPackageName = function (name) {
                 return this.typingsCache.isKnownTypesPackageName(name);
             };
@@ -171650,7 +171929,7 @@ var ts;
             };
             Project.prototype.enableGlobalPlugins = function (options, pluginConfigOverrides) {
                 var host = this.projectService.host;
-                if (!host.require) {
+                if (!host.require && !host.importServicePlugin) {
                     this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
                     return;
                 }
@@ -171679,21 +171958,66 @@ var ts;
                     }
                 }
             };
-            Project.prototype.enablePlugin = function (pluginConfigEntry, searchPaths, pluginConfigOverrides) {
+            /**
+             * Performs the initial steps of enabling a plugin by finding and instantiating the module for a plugin synchronously using 'require'.
+             */
+            /*@internal*/
+            Project.prototype.beginEnablePluginSync = function (pluginConfigEntry, searchPaths, pluginConfigOverrides) {
                 var _this = this;
-                this.projectService.logger.info("Enabling plugin " + pluginConfigEntry.name + " from candidate paths: " + searchPaths.join(","));
-                if (!pluginConfigEntry.name || ts.parsePackageName(pluginConfigEntry.name).rest) {
-                    this.projectService.logger.info("Skipped loading plugin " + (pluginConfigEntry.name || JSON.stringify(pluginConfigEntry)) + " because only package name is allowed plugin name");
-                    return;
-                }
-                var log = function (message) { return _this.projectService.logger.info(message); };
+                ts.Debug.assertIsDefined(this.projectService.host.require);
                 var errorLogs;
+                var log = function (message) { return _this.projectService.logger.info(message); };
                 var logError = function (message) {
-                    (errorLogs || (errorLogs = [])).push(message);
+                    (errorLogs !== null && errorLogs !== void 0 ? errorLogs : (errorLogs = [])).push(message);
                 };
                 var resolvedModule = ts.firstDefined(searchPaths, function (searchPath) {
                     return Project.resolveModule(pluginConfigEntry.name, searchPath, _this.projectService.host, log, logError);
                 });
+                return { pluginConfigEntry: pluginConfigEntry, pluginConfigOverrides: pluginConfigOverrides, resolvedModule: resolvedModule, errorLogs: errorLogs };
+            };
+            /**
+             * Performs the initial steps of enabling a plugin by finding and instantiating the module for a plugin asynchronously using dynamic `import`.
+             */
+            /*@internal*/
+            Project.prototype.beginEnablePluginAsync = function (pluginConfigEntry, searchPaths, pluginConfigOverrides) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var errorLogs, log, logError, resolvedModule, _i, searchPaths_1, searchPath;
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                ts.Debug.assertIsDefined(this.projectService.host.importServicePlugin);
+                                log = function (message) { return _this.projectService.logger.info(message); };
+                                logError = function (message) {
+                                    (errorLogs !== null && errorLogs !== void 0 ? errorLogs : (errorLogs = [])).push(message);
+                                };
+                                _i = 0, searchPaths_1 = searchPaths;
+                                _a.label = 1;
+                            case 1:
+                                if (!(_i < searchPaths_1.length)) return [3 /*break*/, 4];
+                                searchPath = searchPaths_1[_i];
+                                return [4 /*yield*/, Project.importServicePluginAsync(pluginConfigEntry.name, searchPath, this.projectService.host, log, logError)];
+                            case 2:
+                                resolvedModule = (_a.sent());
+                                if (resolvedModule !== undefined) {
+                                    return [3 /*break*/, 4];
+                                }
+                                _a.label = 3;
+                            case 3:
+                                _i++;
+                                return [3 /*break*/, 1];
+                            case 4: return [2 /*return*/, { pluginConfigEntry: pluginConfigEntry, pluginConfigOverrides: pluginConfigOverrides, resolvedModule: resolvedModule, errorLogs: errorLogs }];
+                        }
+                    });
+                });
+            };
+            /**
+             * Performs the remaining steps of enabling a plugin after its module has been instantiated.
+             */
+            /*@internal*/
+            Project.prototype.endEnablePlugin = function (_a) {
+                var _this = this;
+                var pluginConfigEntry = _a.pluginConfigEntry, pluginConfigOverrides = _a.pluginConfigOverrides, resolvedModule = _a.resolvedModule, errorLogs = _a.errorLogs;
                 if (resolvedModule) {
                     var configurationOverride = pluginConfigOverrides && pluginConfigOverrides.get(pluginConfigEntry.name);
                     if (configurationOverride) {
@@ -171705,10 +172029,13 @@ var ts;
                     this.enableProxy(resolvedModule, pluginConfigEntry);
                 }
                 else {
-                    ts.forEach(errorLogs, log);
+                    ts.forEach(errorLogs, function (message) { return _this.projectService.logger.info(message); });
                     this.projectService.logger.info("Couldn't find " + pluginConfigEntry.name);
                 }
             };
+            Project.prototype.enablePlugin = function (pluginConfigEntry, searchPaths, pluginConfigOverrides) {
+                this.projectService.requestEnablePlugin(this, pluginConfigEntry, searchPaths, pluginConfigOverrides);
+            };
             Project.prototype.enableProxy = function (pluginModuleFactory, configEntry) {
                 try {
                     if (typeof pluginModuleFactory !== "function") {
@@ -172360,7 +172687,7 @@ var ts;
             /*@internal*/
             ConfiguredProject.prototype.enablePluginsWithOptions = function (options, pluginConfigOverrides) {
                 var host = this.projectService.host;
-                if (!host.require) {
+                if (!host.require && !host.importServicePlugin) {
                     this.projectService.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
                     return;
                 }
@@ -172379,7 +172706,7 @@ var ts;
                         this.enablePlugin(pluginConfigEntry, searchPaths, pluginConfigOverrides);
                     }
                 }
-                this.enableGlobalPlugins(options, pluginConfigOverrides);
+                return this.enableGlobalPlugins(options, pluginConfigOverrides);
             };
             /**
              * Get the errors that dont have any file name associated
@@ -175801,6 +176128,147 @@ var ts;
                 }
                 return false;
             };
+            /*@internal*/
+            ProjectService.prototype.requestEnablePlugin = function (project, pluginConfigEntry, searchPaths, pluginConfigOverrides) {
+                var _a;
+                if (!this.host.importServicePlugin && !this.host.require) {
+                    this.logger.info("Plugins were requested but not running in environment that supports 'require'. Nothing will be loaded");
+                    return;
+                }
+                this.logger.info("Enabling plugin " + pluginConfigEntry.name + " from candidate paths: " + searchPaths.join(","));
+                if (!pluginConfigEntry.name || ts.parsePackageName(pluginConfigEntry.name).rest) {
+                    this.logger.info("Skipped loading plugin " + (pluginConfigEntry.name || JSON.stringify(pluginConfigEntry)) + " because only package name is allowed plugin name");
+                    return;
+                }
+                // If the host supports dynamic import, begin enabling the plugin asynchronously.
+                if (this.host.importServicePlugin) {
+                    var importPromise = project.beginEnablePluginAsync(pluginConfigEntry, searchPaths, pluginConfigOverrides);
+                    (_a = this.pendingPluginEnablements) !== null && _a !== void 0 ? _a : (this.pendingPluginEnablements = new ts.Map());
+                    var promises = this.pendingPluginEnablements.get(project);
+                    if (!promises)
+                        this.pendingPluginEnablements.set(project, promises = []);
+                    promises.push(importPromise);
+                    return;
+                }
+                // Otherwise, load the plugin using `require`
+                project.endEnablePlugin(project.beginEnablePluginSync(pluginConfigEntry, searchPaths, pluginConfigOverrides));
+            };
+            /* @internal */
+            ProjectService.prototype.hasNewPluginEnablementRequests = function () {
+                return !!this.pendingPluginEnablements;
+            };
+            /* @internal */
+            ProjectService.prototype.hasPendingPluginEnablements = function () {
+                return !!this.currentPluginEnablementPromise;
+            };
+            /**
+             * Waits for any ongoing plugin enablement requests to complete.
+             */
+            /* @internal */
+            ProjectService.prototype.waitForPendingPlugins = function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!this.currentPluginEnablementPromise) return [3 /*break*/, 2];
+                                return [4 /*yield*/, this.currentPluginEnablementPromise];
+                            case 1:
+                                _a.sent();
+                                return [3 /*break*/, 0];
+                            case 2: return [2 /*return*/];
+                        }
+                    });
+                });
+            };
+            /**
+             * Starts enabling any requested plugins without waiting for the result.
+             */
+            /* @internal */
+            ProjectService.prototype.enableRequestedPlugins = function () {
+                if (this.pendingPluginEnablements) {
+                    void this.enableRequestedPluginsAsync();
+                }
+            };
+            ProjectService.prototype.enableRequestedPluginsAsync = function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var entries;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                if (!this.currentPluginEnablementPromise) return [3 /*break*/, 2];
+                                // If we're already enabling plugins, wait for any existing operations to complete
+                                return [4 /*yield*/, this.waitForPendingPlugins()];
+                            case 1:
+                                // If we're already enabling plugins, wait for any existing operations to complete
+                                _a.sent();
+                                _a.label = 2;
+                            case 2:
+                                // Skip if there are no new plugin enablement requests
+                                if (!this.pendingPluginEnablements) {
+                                    return [2 /*return*/];
+                                }
+                                entries = ts.arrayFrom(this.pendingPluginEnablements.entries());
+                                this.pendingPluginEnablements = undefined;
+                                // Start processing the requests, keeping track of the promise for the operation so that
+                                // project consumers can potentially wait for the plugins to load.
+                                this.currentPluginEnablementPromise = this.enableRequestedPluginsWorker(entries);
+                                return [4 /*yield*/, this.currentPluginEnablementPromise];
+                            case 3:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            };
+            ProjectService.prototype.enableRequestedPluginsWorker = function (pendingPlugins) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                // This should only be called from `enableRequestedPluginsAsync`, which ensures this precondition is met.
+                                ts.Debug.assert(this.currentPluginEnablementPromise === undefined);
+                                // Process all pending plugins, partitioned by project. This way a project with few plugins doesn't need to wait
+                                // on a project with many plugins.
+                                return [4 /*yield*/, Promise.all(ts.map(pendingPlugins, function (_a) {
+                                        var project = _a[0], promises = _a[1];
+                                        return _this.enableRequestedPluginsForProjectAsync(project, promises);
+                                    }))];
+                            case 1:
+                                // Process all pending plugins, partitioned by project. This way a project with few plugins doesn't need to wait
+                                // on a project with many plugins.
+                                _a.sent();
+                                // Clear the pending operation and notify the client that projects have been updated.
+                                this.currentPluginEnablementPromise = undefined;
+                                this.sendProjectsUpdatedInBackgroundEvent();
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            };
+            ProjectService.prototype.enableRequestedPluginsForProjectAsync = function (project, promises) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var results, _i, results_1, result;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, Promise.all(promises)];
+                            case 1:
+                                results = _a.sent();
+                                if (project.isClosed()) {
+                                    // project is not alive, so don't enable plugins.
+                                    return [2 /*return*/];
+                                }
+                                for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
+                                    result = results_1[_i];
+                                    project.endEnablePlugin(result);
+                                }
+                                // Plugins may have modified external files, so mark the project as dirty.
+                                this.delayUpdateProjectGraph(project);
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            };
             ProjectService.prototype.configurePlugin = function (args) {
                 // For any projects that already have the plugin loaded, configure the plugin
                 this.forEachEnabledProject(function (project) { return project.onPluginConfigurationChanged(args.pluginName, args.configuration); });
@@ -176322,7 +176790,7 @@ var ts;
             return info && !info.isLocal ? { fileName: info.fileName, pos: info.textSpan.start } : undefined;
         }
         function getReferencesWorker(projects, defaultProject, initialLocation, logger) {
-            var _a;
+            var _a, _b;
             var perProjectResults = getPerProjectReferences(projects, defaultProject, initialLocation, 
             /*isForRename*/ false, function (project, position) {
                 logger.info("Finding references to " + position.fileName + " position " + position.pos + " in project " + project.getProjectName());
@@ -176342,7 +176810,7 @@ var ts;
             // have started the other project searches from related symbols.  Propagate the
             // correct results to all other projects.
             var defaultProjectResults = perProjectResults.get(defaultProject);
-            if (((_a = defaultProjectResults === null || defaultProjectResults === void 0 ? void 0 : defaultProjectResults[0].references[0]) === null || _a === void 0 ? void 0 : _a.isDefinition) === undefined) {
+            if (((_b = (_a = defaultProjectResults === null || defaultProjectResults === void 0 ? void 0 : defaultProjectResults[0]) === null || _a === void 0 ? void 0 : _a.references[0]) === null || _b === void 0 ? void 0 : _b.isDefinition) === undefined) {
                 // Clear all isDefinition properties
                 perProjectResults.forEach(function (projectResults) {
                     for (var _i = 0, projectResults_2 = projectResults; _i < projectResults_2.length; _i++) {
@@ -176359,8 +176827,8 @@ var ts;
                 var knownSymbolSpans_1 = createDocumentSpanSet();
                 for (var _i = 0, defaultProjectResults_1 = defaultProjectResults; _i < defaultProjectResults_1.length; _i++) {
                     var referencedSymbol = defaultProjectResults_1[_i];
-                    for (var _b = 0, _c = referencedSymbol.references; _b < _c.length; _b++) {
-                        var ref = _c[_b];
+                    for (var _c = 0, _d = referencedSymbol.references; _c < _d.length; _c++) {
+                        var ref = _d[_c];
                         if (ref.isDefinition) {
                             knownSymbolSpans_1.add(ref);
                             // One is enough - updateIsDefinitionOfReferencedSymbols will fill out the set based on symbols
@@ -176479,23 +176947,30 @@ var ts;
             var getSourceDefinition = ts.memoize(function () { return defaultProject.isSourceOfProjectReferenceRedirect(defaultDefinition.fileName) ?
                 defaultDefinition :
                 defaultProject.getLanguageService().getSourceMapper().tryGetSourcePosition(defaultDefinition); });
-            // Track which projects we have already searched so that we don't repeat searches.
-            // We store the project key, rather than the project, because that's what `loadAncestorProjectTree` wants.
-            // (For that same reason, we don't use `resultsMap` for this check.)
-            var searchedProjects = new ts.Set();
+            // The keys of resultsMap allow us to check which projects have already been searched, but we also
+            // maintain a set of strings because that's what `loadAncestorProjectTree` wants.
+            var searchedProjectKeys = new ts.Set();
             onCancellation: while (queue.length) {
                 while (queue.length) {
                     if (cancellationToken.isCancellationRequested())
                         break onCancellation;
+                    var skipCount = 0;
+                    for (; skipCount < queue.length && resultsMap.has(queue[skipCount].project); skipCount++)
+                        ;
+                    if (skipCount === queue.length) {
+                        queue.length = 0;
+                        break;
+                    }
+                    if (skipCount > 0) {
+                        queue.splice(0, skipCount);
+                    }
+                    // NB: we may still skip if it's a project reference redirect
                     var _a = queue.shift(), project = _a.project, location = _a.location;
                     if (isLocationProjectReferenceRedirect(project, location))
                         continue;
-                    if (!ts.tryAddToSet(searchedProjects, getProjectKey(project)))
-                        continue;
                     var projectResults = searchPosition(project, location);
-                    if (projectResults) {
-                        resultsMap.set(project, projectResults);
-                    }
+                    resultsMap.set(project, projectResults !== null && projectResults !== void 0 ? projectResults : server.emptyArray);
+                    searchedProjectKeys.add(getProjectKey(project));
                 }
                 // At this point, we know about all projects passed in as arguments and any projects in which
                 // `getResultsForPosition` has returned results.  We expand that set to include any projects
@@ -176503,11 +176978,11 @@ var ts;
                 // containing `initialLocation`.
                 if (defaultDefinition) {
                     // This seems to mean "load all projects downstream from any member of `seenProjects`".
-                    projectService.loadAncestorProjectTree(searchedProjects);
+                    projectService.loadAncestorProjectTree(searchedProjectKeys);
                     projectService.forEachEnabledProject(function (project) {
                         if (cancellationToken.isCancellationRequested())
                             return; // There's no mechanism for skipping the remaining projects
-                        if (searchedProjects.has(getProjectKey(project)))
+                        if (resultsMap.has(project))
                             return; // Can loop forever without this (enqueue here, dequeue above, repeat)
                         var location = mapDefinitionInProject(defaultDefinition, project, getGeneratedDefinition, getSourceDefinition);
                         if (location) {
@@ -176518,9 +176993,10 @@ var ts;
             }
             // In the common case where there's only one project, return a simpler result to make
             // it easier for the caller to skip post-processing.
-            if (searchedProjects.size === 1) {
+            if (resultsMap.size === 1) {
                 var it = resultsMap.values().next();
-                return it.done ? server.emptyArray : it.value; // There may not be any results at all
+                ts.Debug.assert(!it.done);
+                return it.value;
             }
             return resultsMap;
             function searchPosition(project, location) {
@@ -176537,7 +177013,7 @@ var ts;
                         var originalScriptInfo = projectService.getScriptInfo(originalLocation.fileName);
                         for (var _i = 0, _a = originalScriptInfo.containingProjects; _i < _a.length; _i++) {
                             var project_1 = _a[_i];
-                            if (!project_1.isOrphan()) {
+                            if (!project_1.isOrphan() && !resultsMap.has(project_1)) { // Optimization: don't enqueue if will be discarded
                                 queue.push({ project: project_1, location: originalLocation });
                             }
                         }
@@ -176546,7 +177022,7 @@ var ts;
                             symlinkedProjectsMap.forEach(function (symlinkedProjects, symlinkedPath) {
                                 for (var _i = 0, symlinkedProjects_2 = symlinkedProjects; _i < symlinkedProjects_2.length; _i++) {
                                     var symlinkedProject = symlinkedProjects_2[_i];
-                                    if (!symlinkedProject.isOrphan()) {
+                                    if (!symlinkedProject.isOrphan() && !resultsMap.has(symlinkedProject)) { // Optimization: don't enqueue if will be discarded
                                         queue.push({ project: symlinkedProject, location: { fileName: symlinkedPath, pos: originalLocation.pos } });
                                     }
                                 }
@@ -176629,7 +177105,6 @@ var ts;
             server.CommandNames.OrganizeImportsFull,
             server.CommandNames.GetEditsForFileRename,
             server.CommandNames.GetEditsForFileRenameFull,
-            server.CommandNames.ConfigurePlugin,
             server.CommandNames.PrepareCallHierarchy,
             server.CommandNames.ProvideCallHierarchyIncomingCalls,
             server.CommandNames.ProvideCallHierarchyOutgoingCalls,
@@ -177840,7 +178315,8 @@ var ts;
             Session.prototype.getRenameInfo = function (args) {
                 var _a = this.getFileAndProject(args), file = _a.file, project = _a.project;
                 var position = this.getPositionInFile(args, file);
-                return project.getLanguageService().getRenameInfo(file, position, { allowRenameOfImportPath: this.getPreferences(file).allowRenameOfImportPath });
+                var preferences = this.getPreferences(file);
+                return project.getLanguageService().getRenameInfo(file, position, preferences);
             };
             Session.prototype.getProjects = function (args, getScriptInfoEnsuringProjectsUptoDate, ignoreNoProjectError) {
                 var _a;
@@ -177891,10 +178367,11 @@ var ts;
                 var position = this.getPositionInFile(args, file);
                 var projects = this.getProjects(args);
                 var defaultProject = this.getDefaultProject(args);
-                var renameInfo = this.mapRenameInfo(defaultProject.getLanguageService().getRenameInfo(file, position, { allowRenameOfImportPath: this.getPreferences(file).allowRenameOfImportPath }), ts.Debug.checkDefined(this.projectService.getScriptInfo(file)));
+                var preferences = this.getPreferences(file);
+                var renameInfo = this.mapRenameInfo(defaultProject.getLanguageService().getRenameInfo(file, position, preferences), ts.Debug.checkDefined(this.projectService.getScriptInfo(file)));
                 if (!renameInfo.canRename)
                     return simplifiedResult ? { info: renameInfo, locs: [] } : [];
-                var locations = getRenameLocationsWorker(projects, defaultProject, { fileName: args.file, pos: position }, !!args.findInStrings, !!args.findInComments, this.getPreferences(file));
+                var locations = getRenameLocationsWorker(projects, defaultProject, { fileName: args.file, pos: position }, !!args.findInStrings, !!args.findInComments, preferences);
                 if (!simplifiedResult)
                     return locations;
                 return { info: renameInfo, locs: this.toSpanGroups(locations) };
@@ -178897,7 +179374,9 @@ var ts;
             Session.prototype.executeCommand = function (request) {
                 var handler = this.handlers.get(request.command);
                 if (handler) {
-                    return this.executeWithRequestId(request.seq, function () { return handler(request); });
+                    var response = this.executeWithRequestId(request.seq, function () { return handler(request); });
+                    this.projectService.enableRequestedPlugins();
+                    return response;
                 }
                 else {
                     this.logger.msg("Unrecognized JSON command:" + server.stringifyIndented(request), server.Msg.Err);