typescript 4.5.0-dev.20211027 → 4.5.0-dev.20211031

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.20211027";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211031";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -2745,6 +2745,10 @@ var ts;
             return formatEnum(kind, ts.SyntaxKind, /*isFlags*/ false);
         }
         Debug.formatSyntaxKind = formatSyntaxKind;
+        function formatSnippetKind(kind) {
+            return formatEnum(kind, ts.SnippetKind, /*isFlags*/ false);
+        }
+        Debug.formatSnippetKind = formatSnippetKind;
         function formatNodeFlags(flags) {
             return formatEnum(flags, ts.NodeFlags, /*isFlags*/ true);
         }
@@ -4661,6 +4665,13 @@ var ts;
         ExitStatus[ExitStatus["ProjectReferenceCycle_OutputsSkupped"] = 4] = "ProjectReferenceCycle_OutputsSkupped";
     })(ExitStatus = ts.ExitStatus || (ts.ExitStatus = {}));
     /* @internal */
+    var MemberOverrideStatus;
+    (function (MemberOverrideStatus) {
+        MemberOverrideStatus[MemberOverrideStatus["Ok"] = 0] = "Ok";
+        MemberOverrideStatus[MemberOverrideStatus["NeedsOverride"] = 1] = "NeedsOverride";
+        MemberOverrideStatus[MemberOverrideStatus["HasInvalidOverride"] = 2] = "HasInvalidOverride";
+    })(MemberOverrideStatus = ts.MemberOverrideStatus || (ts.MemberOverrideStatus = {}));
+    /* @internal */
     var UnionReduction;
     (function (UnionReduction) {
         UnionReduction[UnionReduction["None"] = 0] = "None";
@@ -5309,7 +5320,7 @@ var ts;
     (function (ModuleResolutionKind) {
         ModuleResolutionKind[ModuleResolutionKind["Classic"] = 1] = "Classic";
         ModuleResolutionKind[ModuleResolutionKind["NodeJs"] = 2] = "NodeJs";
-        // Starting with node12, node's module resolver has significant departures from tranditional cjs resolution
+        // Starting with node12, node's module resolver has significant departures from traditional cjs resolution
         // to better support ecmascript modules and their use within node - more features are still being added, so
         // we can expect it to change over time, and as such, offer both a `NodeNext` moving resolution target, and a `Node12`
         // version-anchored resolution target
@@ -5642,6 +5653,15 @@ var ts;
         // Masks
         // - Additional bitmasks
     })(TransformFlags = ts.TransformFlags || (ts.TransformFlags = {}));
+    // Reference: https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax
+    /* @internal */
+    var SnippetKind;
+    (function (SnippetKind) {
+        SnippetKind[SnippetKind["TabStop"] = 0] = "TabStop";
+        SnippetKind[SnippetKind["Placeholder"] = 1] = "Placeholder";
+        SnippetKind[SnippetKind["Choice"] = 2] = "Choice";
+        SnippetKind[SnippetKind["Variable"] = 3] = "Variable";
+    })(SnippetKind = ts.SnippetKind || (ts.SnippetKind = {}));
     var EmitFlags;
     (function (EmitFlags) {
         EmitFlags[EmitFlags["None"] = 0] = "None";
@@ -8878,6 +8898,8 @@ var ts;
         Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext: diag(2821, ts.DiagnosticCategory.Error, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_2821", "Import assertions are only supported when the '--module' option is set to 'esnext'."),
         Import_assertions_cannot_be_used_with_type_only_imports_or_exports: diag(2822, ts.DiagnosticCategory.Error, "Import_assertions_cannot_be_used_with_type_only_imports_or_exports_2822", "Import assertions cannot be used with type-only imports or exports."),
         Cannot_find_namespace_0_Did_you_mean_1: diag(2833, ts.DiagnosticCategory.Error, "Cannot_find_namespace_0_Did_you_mean_1_2833", "Cannot find namespace '{0}'. Did you mean '{1}'?"),
+        Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Consider_adding_an_extension_to_the_import_path: diag(2834, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Consider adding an extension to the import path."),
+        Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Did_you_mean_0: diag(2835, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node12' or 'nodenext'. Did you mean '{0}'?"),
         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}'."),
@@ -8984,6 +9006,7 @@ var ts;
         This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class: diag(4121, ts.DiagnosticCategory.Error, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_4121", "This member cannot have a JSDoc comment with an '@override' tag because its containing class '{0}' does not extend another class."),
         This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0: diag(4122, ts.DiagnosticCategory.Error, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4122", "This member cannot have a JSDoc comment with an '@override' tag because it is not declared in the base class '{0}'."),
         This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1: diag(4123, ts.DiagnosticCategory.Error, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4123", "This member cannot have a JSDoc comment with an 'override' tag because it is not declared in the base class '{0}'. Did you mean '{1}'?"),
+        Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(4124, ts.DiagnosticCategory.Error, "Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_w_4124", "Compiler option '{0}' of value '{1}' is unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."),
         The_current_host_does_not_support_the_0_option: diag(5001, ts.DiagnosticCategory.Error, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."),
         Cannot_find_the_common_subdirectory_path_for_the_input_files: diag(5009, ts.DiagnosticCategory.Error, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."),
         File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5010, ts.DiagnosticCategory.Error, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."),
@@ -9537,6 +9560,7 @@ var ts;
         This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead: diag(7059, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead_7059", "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead."),
         This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint: diag(7060, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_cons_7060", "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma or explicit constraint."),
         A_mapped_type_may_not_declare_properties_or_methods: diag(7061, ts.DiagnosticCategory.Error, "A_mapped_type_may_not_declare_properties_or_methods_7061", "A mapped type may not declare properties or methods."),
+        JSON_imports_are_experimental_in_ES_module_mode_imports: diag(7062, ts.DiagnosticCategory.Error, "JSON_imports_are_experimental_in_ES_module_mode_imports_7062", "JSON imports are experimental in ES module mode imports."),
         You_cannot_rename_this_element: diag(8000, ts.DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."),
         You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."),
         import_can_only_be_used_in_TypeScript_files: diag(8002, ts.DiagnosticCategory.Error, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."),
@@ -9640,6 +9664,7 @@ var ts;
         Remove_unused_destructuring_declaration: diag(90039, ts.DiagnosticCategory.Message, "Remove_unused_destructuring_declaration_90039", "Remove unused destructuring declaration"),
         Remove_unused_declarations_for_Colon_0: diag(90041, ts.DiagnosticCategory.Message, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"),
         Declare_a_private_field_named_0: diag(90053, ts.DiagnosticCategory.Message, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."),
+        Includes_imports_of_types_referenced_by_0: diag(90054, ts.DiagnosticCategory.Message, "Includes_imports_of_types_referenced_by_0_90054", "Includes imports of types referenced by '{0}'"),
         Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
         Convert_0_to_1_in_0: diag(95003, ts.DiagnosticCategory.Message, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
         Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
@@ -19833,6 +19858,8 @@ var ts;
             case ts.ModuleKind.ES2020:
             case ts.ModuleKind.ES2022:
             case ts.ModuleKind.ESNext:
+            case ts.ModuleKind.Node12:
+            case ts.ModuleKind.NodeNext:
                 return true;
             default:
                 return false;
@@ -20944,6 +20971,10 @@ var ts;
         return node.kind === 212 /* FunctionExpression */ || node.kind === 213 /* ArrowFunction */;
     }
     ts.isFunctionExpressionOrArrowFunction = isFunctionExpressionOrArrowFunction;
+    function escapeSnippetText(text) {
+        return text.replace(/\$/gm, "\\$");
+    }
+    ts.escapeSnippetText = escapeSnippetText;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -27147,6 +27178,25 @@ var ts;
         }
     }
     ts.moveEmitHelpers = moveEmitHelpers;
+    /**
+     * Gets the SnippetElement of a node.
+     */
+    /* @internal */
+    function getSnippetElement(node) {
+        var _a;
+        return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.snippetElement;
+    }
+    ts.getSnippetElement = getSnippetElement;
+    /**
+     * Sets the SnippetElement of a node.
+     */
+    /* @internal */
+    function setSnippetElement(node, snippet) {
+        var emitNode = getOrCreateEmitNode(node);
+        emitNode.snippetElement = snippet;
+        return node;
+    }
+    ts.setSnippetElement = setSnippetElement;
     /* @internal */
     function ignoreSourceNewlines(node) {
         getOrCreateEmitNode(node).flags |= 134217728 /* IgnoreSourceNewlines */;
@@ -47272,6 +47322,7 @@ var ts;
             isDeclarationVisible: isDeclarationVisible,
             isPropertyAccessible: isPropertyAccessible,
             getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration,
+            getMemberOverrideModifierStatus: getMemberOverrideModifierStatus,
         };
         function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode) {
             var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression);
@@ -47515,6 +47566,21 @@ var ts;
         var enumRelation = new ts.Map();
         var builtinGlobals = ts.createSymbolTable();
         builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
+        // Extensions suggested for path imports when module resolution is node12 or higher.
+        // The first element of each tuple is the extension a file has.
+        // The second element of each tuple is the extension that should be used in a path import.
+        // e.g. if we want to import file `foo.mts`, we should write `import {} from "./foo.mjs".
+        var suggestedExtensions = [
+            [".mts", ".mjs"],
+            [".ts", ".js"],
+            [".cts", ".cjs"],
+            [".mjs", ".mjs"],
+            [".js", ".js"],
+            [".cjs", ".cjs"],
+            [".tsx", compilerOptions.jsx === 1 /* Preserve */ ? ".jsx" : ".js"],
+            [".jsx", ".jsx"],
+            [".json", ".json"],
+        ];
         initializeTypeChecker();
         return checker;
         function getJsxNamespace(location) {
@@ -49018,6 +49084,10 @@ var ts;
         function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) {
             return usageMode === ts.ModuleKind.ESNext && targetMode === ts.ModuleKind.CommonJS;
         }
+        function isOnlyImportedAsDefault(usage) {
+            var usageMode = getUsageModeForExpression(usage);
+            return usageMode === ts.ModuleKind.ESNext && ts.endsWith(usage.text, ".json" /* Json */);
+        }
         function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage) {
             var usageMode = file && getUsageModeForExpression(usage);
             if (file && usageMode !== undefined) {
@@ -49068,8 +49138,9 @@ var ts;
                     exportDefaultSymbol = resolveExportByName(moduleSymbol, "default" /* Default */, node, dontResolveAlias);
                 }
                 var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
+                var hasDefaultOnly = isOnlyImportedAsDefault(node.parent.moduleSpecifier);
                 var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, node.parent.moduleSpecifier);
-                if (!exportDefaultSymbol && !hasSyntheticDefault) {
+                if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) {
                     if (hasExportAssignmentSymbol(moduleSymbol)) {
                         var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop";
                         var exportEqualsSymbol = moduleSymbol.exports.get("export=" /* ExportEquals */);
@@ -49083,7 +49154,7 @@ var ts;
                         reportNonDefaultExport(moduleSymbol, node);
                     }
                 }
-                else if (hasSyntheticDefault) {
+                else if (hasSyntheticDefault || hasDefaultOnly) {
                     // per emit behavior, a synthetic default overrides a "real" .default member if `__esModule` is not present
                     var resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
                     markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, /*overwriteTypeOnly*/ false);
@@ -49208,7 +49279,7 @@ var ts;
                     var symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias);
                     if (symbolFromModule === undefined && name.escapedText === "default" /* Default */) {
                         var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
-                        if (canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
+                        if (isOnlyImportedAsDefault(moduleSpecifier) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) {
                             symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias);
                         }
                     }
@@ -49725,7 +49796,7 @@ var ts;
                 : undefined;
         }
         function resolveExternalModule(location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) {
-            var _a, _b, _c, _d, _e, _f;
+            var _a, _b, _c, _d, _e, _f, _g;
             if (isForAugmentation === void 0) { isForAugmentation = false; }
             if (ts.startsWith(moduleReference, "@types/")) {
                 var diag = ts.Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1;
@@ -49746,7 +49817,7 @@ var ts;
                     ((_e = (ts.isModuleDeclaration(location) ? location : location.parent && ts.isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : undefined)) === null || _e === void 0 ? void 0 : _e.name) ||
                     ((_f = (ts.isLiteralImportTypeNode(location) ? location : undefined)) === null || _f === void 0 ? void 0 : _f.argument.literal);
             var mode = contextSpecifier && ts.isStringLiteralLike(contextSpecifier) ? ts.getModeForUsageLocation(currentSourceFile, contextSpecifier) : currentSourceFile.impliedNodeFormat;
-            var resolvedModule = ts.getResolvedModule(currentSourceFile, moduleReference, mode); // TODO: GH#18217
+            var resolvedModule = ts.getResolvedModule(currentSourceFile, moduleReference, mode);
             var resolutionDiagnostic = resolvedModule && ts.getResolutionDiagnostic(compilerOptions, resolvedModule);
             var sourceFile = resolvedModule && !resolutionDiagnostic && host.getSourceFile(resolvedModule.resolvedFileName);
             if (sourceFile) {
@@ -49759,6 +49830,9 @@ var ts;
                         if (isSyncImport && sourceFile.impliedNodeFormat === ts.ModuleKind.ESNext) {
                             error(errorNode, ts.Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_synchronously_Use_dynamic_import_instead, moduleReference);
                         }
+                        if (mode === ts.ModuleKind.ESNext && compilerOptions.resolveJsonModule && resolvedModule.extension === ".json" /* Json */) {
+                            error(errorNode, ts.Diagnostics.JSON_imports_are_experimental_in_ES_module_mode_imports);
+                        }
                     }
                     // merged symbol is module declaration symbol combined with all augmentations
                     return getMergedSymbol(sourceFile.symbol);
@@ -49809,6 +49883,10 @@ var ts;
                 }
                 else {
                     var tsExtension = ts.tryExtractTSExtension(moduleReference);
+                    var isExtensionlessRelativePathImport = ts.pathIsRelative(moduleReference) && !ts.hasExtension(moduleReference);
+                    var moduleResolutionKind = ts.getEmitModuleResolutionKind(compilerOptions);
+                    var resolutionIsNode12OrNext = moduleResolutionKind === ts.ModuleResolutionKind.Node12 ||
+                        moduleResolutionKind === ts.ModuleResolutionKind.NodeNext;
                     if (tsExtension) {
                         var diag = ts.Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead;
                         var importSourceWithoutExtension = ts.removeExtension(moduleReference, tsExtension);
@@ -49828,6 +49906,19 @@ var ts;
                         ts.hasJsonModuleEmitEnabled(compilerOptions)) {
                         error(errorNode, ts.Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference);
                     }
+                    else if (mode === ts.ModuleKind.ESNext && resolutionIsNode12OrNext && isExtensionlessRelativePathImport) {
+                        var absoluteRef_1 = ts.getNormalizedAbsolutePath(moduleReference, ts.getDirectoryPath(currentSourceFile.path));
+                        var suggestedExt = (_g = suggestedExtensions.find(function (_a) {
+                            var actualExt = _a[0], _importExt = _a[1];
+                            return host.fileExists(absoluteRef_1 + actualExt);
+                        })) === null || _g === void 0 ? void 0 : _g[1];
+                        if (suggestedExt) {
+                            error(errorNode, ts.Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Did_you_mean_0, moduleReference + suggestedExt);
+                        }
+                        else {
+                            error(errorNode, ts.Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node12_or_nodenext_Consider_adding_an_extension_to_the_import_path);
+                        }
+                    }
                     else {
                         error(errorNode, moduleNotFoundError, moduleReference);
                     }
@@ -49897,40 +49988,50 @@ var ts;
                     error(referencingLocation, ts.Diagnostics.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, compilerOptionName);
                     return symbol;
                 }
-                if (ts.getESModuleInterop(compilerOptions)) {
-                    var referenceParent = referencingLocation.parent;
-                    if ((ts.isImportDeclaration(referenceParent) && ts.getNamespaceDeclarationNode(referenceParent)) ||
-                        ts.isImportCall(referenceParent)) {
-                        var type = getTypeOfSymbol(symbol);
+                var referenceParent = referencingLocation.parent;
+                if ((ts.isImportDeclaration(referenceParent) && ts.getNamespaceDeclarationNode(referenceParent)) ||
+                    ts.isImportCall(referenceParent)) {
+                    var reference = ts.isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier;
+                    var type = getTypeOfSymbol(symbol);
+                    var defaultOnlyType = getTypeWithSyntheticDefaultOnly(type, symbol, moduleSymbol, reference);
+                    if (defaultOnlyType) {
+                        return cloneTypeAsModuleType(symbol, defaultOnlyType, referenceParent);
+                    }
+                    if (ts.getESModuleInterop(compilerOptions)) {
                         var sigs = getSignaturesOfStructuredType(type, 0 /* Call */);
                         if (!sigs || !sigs.length) {
                             sigs = getSignaturesOfStructuredType(type, 1 /* Construct */);
                         }
-                        if (sigs && sigs.length) {
-                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, ts.isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier);
-                            // Create a new symbol which has the module's type less the call and construct signatures
-                            var result = createSymbol(symbol.flags, symbol.escapedName);
-                            result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
-                            result.parent = symbol.parent;
-                            result.target = symbol;
-                            result.originatingImport = referenceParent;
-                            if (symbol.valueDeclaration)
-                                result.valueDeclaration = symbol.valueDeclaration;
-                            if (symbol.constEnumOnlyModule)
-                                result.constEnumOnlyModule = true;
-                            if (symbol.members)
-                                result.members = new ts.Map(symbol.members);
-                            if (symbol.exports)
-                                result.exports = new ts.Map(symbol.exports);
-                            var resolvedModuleType = resolveStructuredTypeMembers(moduleType); // Should already be resolved from the signature checks above
-                            result.type = createAnonymousType(result, resolvedModuleType.members, ts.emptyArray, ts.emptyArray, resolvedModuleType.indexInfos);
-                            return result;
+                        if ((sigs && sigs.length) || getPropertyOfType(type, "default" /* Default */)) {
+                            var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, reference);
+                            return cloneTypeAsModuleType(symbol, moduleType, referenceParent);
                         }
                     }
                 }
             }
             return symbol;
         }
+        /**
+         * Create a new symbol which has the module's type less the call and construct signatures
+         */
+        function cloneTypeAsModuleType(symbol, moduleType, referenceParent) {
+            var result = createSymbol(symbol.flags, symbol.escapedName);
+            result.declarations = symbol.declarations ? symbol.declarations.slice() : [];
+            result.parent = symbol.parent;
+            result.target = symbol;
+            result.originatingImport = referenceParent;
+            if (symbol.valueDeclaration)
+                result.valueDeclaration = symbol.valueDeclaration;
+            if (symbol.constEnumOnlyModule)
+                result.constEnumOnlyModule = true;
+            if (symbol.members)
+                result.members = new ts.Map(symbol.members);
+            if (symbol.exports)
+                result.exports = new ts.Map(symbol.exports);
+            var resolvedModuleType = resolveStructuredTypeMembers(moduleType); // Should already be resolved from the signature checks above
+            result.type = createAnonymousType(result, resolvedModuleType.members, ts.emptyArray, ts.emptyArray, resolvedModuleType.indexInfos);
+            return result;
+        }
         function hasExportAssignmentSymbol(moduleSymbol) {
             return moduleSymbol.exports.get("export=" /* ExportEquals */) !== undefined;
         }
@@ -61729,7 +61830,9 @@ var ts;
                     return mapTypeWithAlias(getReducedType(mappedTypeVariable), function (t) {
                         if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
                             if (!type.declaration.nameType) {
-                                if (isArrayType(t)) {
+                                var constraint = void 0;
+                                if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 &&
+                                    (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, ts.or(isArrayType, isTupleType))) {
                                     return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
                                 }
                                 if (isGenericTupleType(t)) {
@@ -67376,8 +67479,11 @@ var ts;
         function getFlowCacheKey(node, declaredType, initialType, flowContainer) {
             switch (node.kind) {
                 case 79 /* Identifier */:
-                    var symbol = getResolvedSymbol(node);
-                    return symbol !== unknownSymbol ? (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType) + "|" + getSymbolId(symbol) : undefined;
+                    if (!ts.isThisInTypeQuery(node)) {
+                        var symbol = getResolvedSymbol(node);
+                        return symbol !== unknownSymbol ? (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType) + "|" + getSymbolId(symbol) : undefined;
+                    }
+                // falls through
                 case 108 /* ThisKeyword */:
                     return "0|" + (flowContainer ? getNodeId(flowContainer) : "-1") + "|" + getTypeId(declaredType) + "|" + getTypeId(initialType);
                 case 229 /* NonNullExpression */:
@@ -75106,11 +75212,33 @@ var ts;
             if (moduleSymbol) {
                 var esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, /*dontRecursivelyResolve*/ true, /*suppressUsageError*/ false);
                 if (esModuleSymbol) {
-                    return createPromiseReturnType(node, getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier));
+                    return createPromiseReturnType(node, getTypeWithSyntheticDefaultOnly(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier) ||
+                        getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier));
                 }
             }
             return createPromiseReturnType(node, anyType);
         }
+        function createDefaultPropertyWrapperForModule(symbol, originalSymbol, anonymousSymbol) {
+            var memberTable = ts.createSymbolTable();
+            var newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
+            newSymbol.parent = originalSymbol;
+            newSymbol.nameType = getStringLiteralType("default");
+            newSymbol.target = resolveSymbol(symbol);
+            memberTable.set("default" /* Default */, newSymbol);
+            return createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, ts.emptyArray);
+        }
+        function getTypeWithSyntheticDefaultOnly(type, symbol, originalSymbol, moduleSpecifier) {
+            var hasDefaultOnly = isOnlyImportedAsDefault(moduleSpecifier);
+            if (hasDefaultOnly && type && !isErrorType(type)) {
+                var synthType = type;
+                if (!synthType.defaultOnlyType) {
+                    var type_4 = createDefaultPropertyWrapperForModule(symbol, originalSymbol);
+                    synthType.defaultOnlyType = type_4;
+                }
+                return synthType.defaultOnlyType;
+            }
+            return undefined;
+        }
         function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol, moduleSpecifier) {
             var _a;
             if (allowSyntheticDefaultImports && type && !isErrorType(type)) {
@@ -75119,14 +75247,8 @@ var ts;
                     var file = (_a = originalSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile);
                     var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, /*dontResolveAlias*/ false, moduleSpecifier);
                     if (hasSyntheticDefault) {
-                        var memberTable = ts.createSymbolTable();
-                        var newSymbol = createSymbol(2097152 /* Alias */, "default" /* Default */);
-                        newSymbol.parent = originalSymbol;
-                        newSymbol.nameType = getStringLiteralType("default");
-                        newSymbol.target = resolveSymbol(symbol);
-                        memberTable.set("default" /* Default */, newSymbol);
                         var anonymousSymbol = createSymbol(2048 /* TypeLiteral */, "__type" /* Type */);
-                        var defaultContainingObject = createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, ts.emptyArray);
+                        var defaultContainingObject = createDefaultPropertyWrapperForModule(symbol, originalSymbol, anonymousSymbol);
                         anonymousSymbol.type = defaultContainingObject;
                         synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, /*objectFlags*/ 0, /*readonly*/ false) : defaultContainingObject;
                     }
@@ -75834,12 +75956,12 @@ var ts;
                 var witnesses = getSwitchClauseTypeOfWitnesses(node, /*retainDefault*/ false);
                 // notEqualFacts states that the type of the switched value is not equal to every type in the switch.
                 var notEqualFacts_1 = getFactsFromTypeofSwitch(0, 0, witnesses, /*hasDefault*/ true);
-                var type_4 = getBaseConstraintOfType(operandType) || operandType;
+                var type_5 = getBaseConstraintOfType(operandType) || operandType;
                 // Take any/unknown as a special condition. Or maybe we could change `type` to a union containing all primitive types.
-                if (type_4.flags & 3 /* AnyOrUnknown */) {
+                if (type_5.flags & 3 /* AnyOrUnknown */) {
                     return (556800 /* AllTypeofNE */ & notEqualFacts_1) === 556800 /* AllTypeofNE */;
                 }
-                return !!(filterType(type_4, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072 /* Never */);
+                return !!(filterType(type_5, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072 /* Never */);
             }
             var type = getTypeOfExpression(node.expression);
             if (!isLiteralType(type)) {
@@ -81809,7 +81931,7 @@ var ts;
                     checkKindsOfPropertyMemberOverrides(type, baseType_1);
                 }
             }
-            checkMembersForMissingOverrideModifier(node, type, typeWithThis, staticType);
+            checkMembersForOverrideModifier(node, type, typeWithThis, staticType);
             var implementedTypeNodes = ts.getEffectiveImplementsTypeNodes(node);
             if (implementedTypeNodes) {
                 for (var _b = 0, implementedTypeNodes_1 = implementedTypeNodes; _b < implementedTypeNodes_1.length; _b++) {
@@ -81844,8 +81966,7 @@ var ts;
                 checkPropertyInitialization(node);
             }
         }
-        function checkMembersForMissingOverrideModifier(node, type, typeWithThis, staticType) {
-            var nodeInAmbientContext = !!(node.flags & 8388608 /* Ambient */);
+        function checkMembersForOverrideModifier(node, type, typeWithThis, staticType) {
             var baseTypeNode = ts.getEffectiveBaseTypeNode(node);
             var baseTypes = baseTypeNode && getBaseTypes(type);
             var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
@@ -81857,46 +81978,71 @@ var ts;
                 if (ts.isConstructorDeclaration(member)) {
                     ts.forEach(member.parameters, function (param) {
                         if (ts.isParameterPropertyDeclaration(param, member)) {
-                            checkClassMember(param, /*memberIsParameterProperty*/ true);
+                            checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, param, 
+                            /* memberIsParameterProperty */ true);
                         }
                     });
                 }
-                checkClassMember(member);
+                checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, 
+                /* memberIsParameterProperty */ false);
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
                 _loop_29(member);
             }
-            function checkClassMember(member, memberIsParameterProperty) {
-                var hasOverride = ts.hasOverrideModifier(member);
-                var hasStatic = ts.isStatic(member);
-                var isJs = ts.isInJSFile(member);
-                if (baseWithThis && (hasOverride || compilerOptions.noImplicitOverride)) {
-                    var declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member);
-                    if (!declaredProp) {
-                        return;
-                    }
-                    var thisType = hasStatic ? staticType : typeWithThis;
-                    var baseType = hasStatic ? baseStaticType : baseWithThis;
-                    var prop = getPropertyOfType(thisType, declaredProp.escapedName);
-                    var baseProp = getPropertyOfType(baseType, declaredProp.escapedName);
-                    var baseClassName = typeToString(baseWithThis);
-                    if (prop && !baseProp && hasOverride) {
-                        var suggestion = getSuggestedSymbolForNonexistentClassMember(ts.symbolName(declaredProp), baseType);
+        }
+        /**
+         * @param member Existing member node to be checked.
+         * Note: `member` cannot be a synthetic node.
+         */
+        function checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, memberIsParameterProperty, reportErrors) {
+            if (reportErrors === void 0) { reportErrors = true; }
+            var declaredProp = member.name
+                && getSymbolAtLocation(member.name)
+                || getSymbolAtLocation(member);
+            if (!declaredProp) {
+                return 0 /* Ok */;
+            }
+            return checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, ts.hasOverrideModifier(member), ts.hasAbstractModifier(member), ts.isStatic(member), memberIsParameterProperty, ts.symbolName(declaredProp), reportErrors ? member : undefined);
+        }
+        /**
+         * Checks a class member declaration for either a missing or an invalid `override` modifier.
+         * Note: this function can be used for speculative checking,
+         * i.e. checking a member that does not yet exist in the program.
+         * An example of that would be to call this function in a completions scenario,
+         * when offering a method declaration as completion.
+         * @param errorNode The node where we should report an error, or undefined if we should not report errors.
+         */
+        function checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, memberHasAbstractModifier, memberIsStatic, memberIsParameterProperty, memberName, errorNode) {
+            var isJs = ts.isInJSFile(node);
+            var nodeInAmbientContext = !!(node.flags & 8388608 /* Ambient */);
+            if (baseWithThis && (memberHasOverrideModifier || compilerOptions.noImplicitOverride)) {
+                var memberEscapedName = ts.escapeLeadingUnderscores(memberName);
+                var thisType = memberIsStatic ? staticType : typeWithThis;
+                var baseType = memberIsStatic ? baseStaticType : baseWithThis;
+                var prop = getPropertyOfType(thisType, memberEscapedName);
+                var baseProp = getPropertyOfType(baseType, memberEscapedName);
+                var baseClassName = typeToString(baseWithThis);
+                if (prop && !baseProp && memberHasOverrideModifier) {
+                    if (errorNode) {
+                        var suggestion = getSuggestedSymbolForNonexistentClassMember(memberName, baseType); // Again, using symbol name: note that's different from `symbol.escapedName`
                         suggestion ?
-                            error(member, isJs ?
+                            error(errorNode, isJs ?
                                 ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 :
                                 ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1, baseClassName, symbolToString(suggestion)) :
-                            error(member, isJs ?
+                            error(errorNode, isJs ?
                                 ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0 :
                                 ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0, baseClassName);
                     }
-                    else if (prop && (baseProp === null || baseProp === void 0 ? void 0 : baseProp.declarations) && compilerOptions.noImplicitOverride && !nodeInAmbientContext) {
-                        var baseHasAbstract = ts.some(baseProp.declarations, ts.hasAbstractModifier);
-                        if (hasOverride) {
-                            return;
-                        }
-                        if (!baseHasAbstract) {
+                    return 2 /* HasInvalidOverride */;
+                }
+                else if (prop && (baseProp === null || baseProp === void 0 ? void 0 : baseProp.declarations) && compilerOptions.noImplicitOverride && !nodeInAmbientContext) {
+                    var baseHasAbstract = ts.some(baseProp.declarations, ts.hasAbstractModifier);
+                    if (memberHasOverrideModifier) {
+                        return 0 /* Ok */;
+                    }
+                    if (!baseHasAbstract) {
+                        if (errorNode) {
                             var diag = memberIsParameterProperty ?
                                 isJs ?
                                     ts.Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 :
@@ -81904,20 +82050,28 @@ var ts;
                                 isJs ?
                                     ts.Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 :
                                     ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0;
-                            error(member, diag, baseClassName);
+                            error(errorNode, diag, baseClassName);
                         }
-                        else if (ts.hasAbstractModifier(member) && baseHasAbstract) {
-                            error(member, ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0, baseClassName);
+                        return 1 /* NeedsOverride */;
+                    }
+                    else if (memberHasAbstractModifier && baseHasAbstract) {
+                        if (errorNode) {
+                            error(errorNode, ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0, baseClassName);
                         }
+                        return 1 /* NeedsOverride */;
                     }
                 }
-                else if (hasOverride) {
+            }
+            else if (memberHasOverrideModifier) {
+                if (errorNode) {
                     var className = typeToString(type);
-                    error(member, isJs ?
+                    error(errorNode, isJs ?
                         ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class :
                         ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class, className);
                 }
+                return 2 /* HasInvalidOverride */;
             }
+            return 0 /* Ok */;
         }
         function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
             // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible
@@ -81960,6 +82114,31 @@ var ts;
                 }
             }
         }
+        /**
+         * Checks a member declaration node to see if has a missing or invalid `override` modifier.
+         * @param node Class-like node where the member is declared.
+         * @param member Member declaration node.
+         * Note: `member` can be a synthetic node without a parent.
+         */
+        function getMemberOverrideModifierStatus(node, member) {
+            if (!member.name) {
+                return 0 /* Ok */;
+            }
+            var symbol = getSymbolOfNode(node);
+            var type = getDeclaredTypeOfSymbol(symbol);
+            var typeWithThis = getTypeWithThisArgument(type);
+            var staticType = getTypeOfSymbol(symbol);
+            var baseTypeNode = ts.getEffectiveBaseTypeNode(node);
+            var baseTypes = baseTypeNode && getBaseTypes(type);
+            var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
+            var baseStaticType = getBaseConstructorTypeOfClass(type);
+            var memberHasOverrideModifier = member.parent
+                ? ts.hasOverrideModifier(member)
+                : ts.hasSyntacticModifier(member, 16384 /* Override */);
+            var memberName = ts.unescapeLeadingUnderscores(ts.getTextOfPropertyName(member.name));
+            return checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, ts.hasAbstractModifier(member), ts.isStatic(member), 
+            /* memberIsParameterProperty */ false, memberName);
+        }
         function getTargetSymbol(s) {
             // if symbol is instantiated its flags are not copied from the 'target'
             // so we'll need to get back original 'target' symbol to work with correct set of flags
@@ -94956,11 +95135,11 @@ var ts;
             currentFileState.filenameDeclaration = declaration;
             return currentFileState.filenameDeclaration.name;
         }
-        function getJsxFactoryCalleePrimitive(childrenLength) {
-            return compilerOptions.jsx === 5 /* ReactJSXDev */ ? "jsxDEV" : childrenLength > 1 ? "jsxs" : "jsx";
+        function getJsxFactoryCalleePrimitive(isStaticChildren) {
+            return compilerOptions.jsx === 5 /* ReactJSXDev */ ? "jsxDEV" : isStaticChildren ? "jsxs" : "jsx";
         }
-        function getJsxFactoryCallee(childrenLength) {
-            var type = getJsxFactoryCalleePrimitive(childrenLength);
+        function getJsxFactoryCallee(isStaticChildren) {
+            var type = getJsxFactoryCalleePrimitive(isStaticChildren);
             return getImplicitImportForName(type);
         }
         function getImplicitJsxFragmentReference() {
@@ -95112,7 +95291,7 @@ var ts;
         }
         function convertJsxChildrenToChildrenPropAssignment(children) {
             var nonWhitespaceChildren = ts.getSemanticJsxChildren(children);
-            if (ts.length(nonWhitespaceChildren) === 1) {
+            if (ts.length(nonWhitespaceChildren) === 1 && !nonWhitespaceChildren[0].dotDotDotToken) {
                 var result_12 = transformJsxChildToExpression(nonWhitespaceChildren[0]);
                 return result_12 && factory.createPropertyAssignment("children", result_12);
             }
@@ -95126,15 +95305,18 @@ var ts;
             var attrs = keyAttr ? ts.filter(node.attributes.properties, function (p) { return p !== keyAttr; }) : node.attributes.properties;
             var objectProperties = ts.length(attrs) ? transformJsxAttributesToObjectProps(attrs, childrenProp) :
                 factory.createObjectLiteralExpression(childrenProp ? [childrenProp] : ts.emptyArray); // When there are no attributes, React wants {}
-            return visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, ts.length(ts.getSemanticJsxChildren(children || ts.emptyArray)), isChild, location);
+            return visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, children || ts.emptyArray, isChild, location);
         }
-        function visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, childrenLength, isChild, location) {
+        function visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, children, isChild, location) {
+            var _a;
+            var nonWhitespaceChildren = ts.getSemanticJsxChildren(children);
+            var isStaticChildren = ts.length(nonWhitespaceChildren) > 1 || !!((_a = nonWhitespaceChildren[0]) === null || _a === void 0 ? void 0 : _a.dotDotDotToken);
             var args = [tagName, objectProperties, !keyAttr ? factory.createVoidZero() : transformJsxAttributeInitializer(keyAttr.initializer)];
             if (compilerOptions.jsx === 5 /* ReactJSXDev */) {
                 var originalFile = ts.getOriginalNode(currentSourceFile);
                 if (originalFile && ts.isSourceFile(originalFile)) {
                     // isStaticChildren development flag
-                    args.push(childrenLength > 1 ? factory.createTrue() : factory.createFalse());
+                    args.push(isStaticChildren ? factory.createTrue() : factory.createFalse());
                     // __source development flag
                     var lineCol = ts.getLineAndCharacterOfPosition(originalFile, location.pos);
                     args.push(factory.createObjectLiteralExpression([
@@ -95146,7 +95328,7 @@ var ts;
                     args.push(factory.createThis());
                 }
             }
-            var element = ts.setTextRange(factory.createCallExpression(getJsxFactoryCallee(childrenLength), /*typeArguments*/ undefined, args), location);
+            var element = ts.setTextRange(factory.createCallExpression(getJsxFactoryCallee(isStaticChildren), /*typeArguments*/ undefined, args), location);
             if (isChild) {
                 ts.startOnNewLine(element);
             }
@@ -95176,7 +95358,7 @@ var ts;
                 }
             }
             return visitJsxOpeningLikeElementOrFragmentJSX(getImplicitJsxFragmentReference(), childrenProps || factory.createObjectLiteralExpression([]), 
-            /*keyAttr*/ undefined, ts.length(ts.getSemanticJsxChildren(children)), isChild, location);
+            /*keyAttr*/ undefined, children, isChild, location);
         }
         function visitJsxOpeningFragmentCreateElement(node, children, isChild, location) {
             var element = ts.createExpressionForJsxFragment(factory, context.getEmitResolver().getJsxFactoryEntity(currentSourceFile), context.getEmitResolver().getJsxFragmentFactoryEntity(currentSourceFile), compilerOptions.reactNamespace, // TODO: GH#18217
@@ -108264,7 +108446,14 @@ var ts;
             // clear the parenthesizer rule as we ascend
             currentParenthesizerRule = undefined;
         }
-        function pipelineEmitWithHintWorker(hint, node) {
+        function pipelineEmitWithHintWorker(hint, node, allowSnippets) {
+            if (allowSnippets === void 0) { allowSnippets = true; }
+            if (allowSnippets) {
+                var snippet = ts.getSnippetElement(node);
+                if (snippet) {
+                    return emitSnippetNode(hint, node, snippet);
+                }
+            }
             if (hint === 0 /* SourceFile */)
                 return emitSourceFile(ts.cast(node, ts.isSourceFile));
             if (hint === 2 /* IdentifierName */)
@@ -108873,6 +109062,28 @@ var ts;
             }
         }
         //
+        // Snippet Elements
+        //
+        function emitSnippetNode(hint, node, snippet) {
+            switch (snippet.kind) {
+                case 1 /* Placeholder */:
+                    emitPlaceholder(hint, node, snippet);
+                    break;
+                case 0 /* TabStop */:
+                    emitTabStop(snippet);
+                    break;
+            }
+        }
+        function emitPlaceholder(hint, node, snippet) {
+            nonEscapingWrite("${" + snippet.order + ":"); // `${2:`
+            pipelineEmitWithHintWorker(hint, node, /*allowSnippets*/ false); // `...`
+            nonEscapingWrite("}"); // `}`
+            // `${2:...}`
+        }
+        function emitTabStop(snippet) {
+            nonEscapingWrite("$" + snippet.order);
+        }
+        //
         // Identifiers
         //
         function emitIdentifier(node) {
@@ -111111,6 +111322,15 @@ var ts;
         function writeProperty(s) {
             writer.writeProperty(s);
         }
+        function nonEscapingWrite(s) {
+            // This should be defined in a snippet-escaping text writer.
+            if (writer.nonEscapingWrite) {
+                writer.nonEscapingWrite(s);
+            }
+            else {
+                writer.write(s);
+            }
+        }
         function writeLine(count) {
             if (count === void 0) { count = 1; }
             for (var i = 0; i < count; i++) {
@@ -114214,8 +114434,8 @@ var ts;
                 var typesReferenceDirectives = ts.map(newSourceFile.typeReferenceDirectives, function (ref) { return ts.toFileNameLowerCase(ref.fileName); });
                 var typeReferenceResolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFile);
                 // ensure that types resolutions are still correct
-                var typeReferenceEesolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, oldSourceFile, ts.typeDirectiveIsEqualTo);
-                if (typeReferenceEesolutionsChanged) {
+                var typeReferenceResolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, oldSourceFile, ts.typeDirectiveIsEqualTo);
+                if (typeReferenceResolutionsChanged) {
                     structureIsReused = 1 /* SafeModules */;
                     newSourceFile.resolvedTypeReferenceDirectiveNames = ts.zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions);
                 }
@@ -115503,6 +115723,21 @@ var ts;
             return resolvedRef;
         }
         function verifyCompilerOptions() {
+            var isNightly = ts.stringContains(ts.version, "-dev");
+            if (!isNightly) {
+                if (ts.getEmitModuleKind(options) === ts.ModuleKind.Node12) {
+                    createOptionValueDiagnostic("module", ts.Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "module", "node12");
+                }
+                else if (ts.getEmitModuleKind(options) === ts.ModuleKind.NodeNext) {
+                    createOptionValueDiagnostic("module", ts.Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "module", "nodenext");
+                }
+                else if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node12) {
+                    createOptionValueDiagnostic("moduleResolution", ts.Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "moduleResolution", "node12");
+                }
+                else if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) {
+                    createOptionValueDiagnostic("moduleResolution", ts.Diagnostics.Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next, "moduleResolution", "nodenext");
+                }
+            }
             if (options.strictPropertyInitialization && !ts.getStrictOptionValue(options, "strictNullChecks")) {
                 createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks");
             }
@@ -115651,7 +115886,9 @@ var ts;
                 }
             }
             if (options.resolveJsonModule) {
-                if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs) {
+                if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs &&
+                    ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node12 &&
+                    ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) {
                     createDiagnosticForOptionName(ts.Diagnostics.Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy, "resolveJsonModule");
                 }
                 // Any emit other than common js, amd, es2015 or esnext is error
@@ -115979,8 +116216,8 @@ var ts;
         function createDiagnosticForOptionName(message, option1, option2, option3) {
             createDiagnosticForOption(/*onKey*/ true, option1, option2, message, option1, option2, option3);
         }
-        function createOptionValueDiagnostic(option1, message, arg0) {
-            createDiagnosticForOption(/*onKey*/ false, option1, /*option2*/ undefined, message, arg0);
+        function createOptionValueDiagnostic(option1, message, arg0, arg1) {
+            createDiagnosticForOption(/*onKey*/ false, option1, /*option2*/ undefined, message, arg0, arg1);
         }
         function createDiagnosticForReference(sourceFile, index, message, arg0, arg1) {
             var referencesSyntax = ts.firstDefined(ts.getTsConfigPropArray(sourceFile || options.configFile, "references"), function (property) { return ts.isArrayLiteralExpression(property.initializer) ? property.initializer : undefined; });
@@ -118224,6 +118461,9 @@ var ts;
                     else {
                         resolution = loader(name, containingFile, compilerOptions, ((_c = resolutionHost.getCompilerHost) === null || _c === void 0 ? void 0 : _c.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile);
                         perDirectoryResolution.set(name, mode, resolution);
+                        if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) {
+                            resolutionHost.onDiscoveredSymlink();
+                        }
                     }
                     resolutionsInFile.set(name, mode, resolution);
                     watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName);
@@ -118692,6 +118932,11 @@ var ts;
         }
     }
     ts.createResolutionCache = createResolutionCache;
+    function resolutionIsSymlink(resolution) {
+        var _a, _b;
+        return !!(((_a = resolution.resolvedModule) === null || _a === void 0 ? void 0 : _a.originalPath) ||
+            ((_b = resolution.resolvedTypeReferenceDirective) === null || _b === void 0 ? void 0 : _b.originalPath));
+    }
 })(ts || (ts = {}));
 // Used by importFixes, getEditsForFileRename, and declaration emit to synthesize import module specifiers.
 /* @internal */
@@ -126134,6 +126379,16 @@ var ts;
         return decisionFromFile !== null && decisionFromFile !== void 0 ? decisionFromFile : program.usesUriStyleNodeCoreModules;
     }
     ts.shouldUseUriStyleNodeCoreModules = shouldUseUriStyleNodeCoreModules;
+    function getNewLineKind(newLineCharacter) {
+        return newLineCharacter === "\n" ? 1 /* LineFeed */ : 0 /* CarriageReturnLineFeed */;
+    }
+    ts.getNewLineKind = getNewLineKind;
+    function diagnosticToString(diag) {
+        return ts.isArray(diag)
+            ? ts.formatStringFromArgs(ts.getLocaleSpecificMessage(diag[0]), diag.slice(1))
+            : ts.getLocaleSpecificMessage(diag);
+    }
+    ts.diagnosticToString = diagnosticToString;
     // #endregion
 })(ts || (ts = {}));
 /*@internal*/
@@ -127731,7 +127986,7 @@ var ts;
     (function (Completions) {
         var StringCompletions;
         (function (StringCompletions) {
-            function getStringLiteralCompletions(sourceFile, position, contextToken, checker, options, host, log, preferences) {
+            function getStringLiteralCompletions(sourceFile, position, contextToken, options, host, program, log, preferences) {
                 if (ts.isInReferenceComment(sourceFile, position)) {
                     var entries = getTripleSlashReferenceCompletion(sourceFile, position, options, host);
                     return entries && convertPathCompletions(entries);
@@ -127739,12 +127994,12 @@ var ts;
                 if (ts.isInString(sourceFile, position, contextToken)) {
                     if (!contextToken || !ts.isStringLiteralLike(contextToken))
                         return undefined;
-                    var entries = getStringLiteralCompletionEntries(sourceFile, contextToken, position, checker, options, host, preferences);
-                    return convertStringLiteralCompletions(entries, contextToken, sourceFile, checker, log, options, preferences);
+                    var entries = getStringLiteralCompletionEntries(sourceFile, contextToken, position, program.getTypeChecker(), options, host, preferences);
+                    return convertStringLiteralCompletions(entries, contextToken, sourceFile, host, program, log, options, preferences);
                 }
             }
             StringCompletions.getStringLiteralCompletions = getStringLiteralCompletions;
-            function convertStringLiteralCompletions(completion, contextToken, sourceFile, checker, log, options, preferences) {
+            function convertStringLiteralCompletions(completion, contextToken, sourceFile, host, program, log, options, preferences) {
                 if (completion === undefined) {
                     return undefined;
                 }
@@ -127754,7 +128009,7 @@ var ts;
                         return convertPathCompletions(completion.paths);
                     case 1 /* Properties */: {
                         var entries = [];
-                        Completions.getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, contextToken, sourceFile, sourceFile, checker, 99 /* ESNext */, log, 4 /* String */, preferences, options); // Target will not be used, so arbitrary
+                        Completions.getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, contextToken, sourceFile, sourceFile, host, program, 99 /* ESNext */, log, 4 /* String */, preferences, options); // Target will not be used, so arbitrary
                         return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, optionalReplacementSpan: optionalReplacementSpan, entries: entries };
                     }
                     case 2 /* Types */: {
@@ -128480,6 +128735,8 @@ var ts;
         (function (CompletionSource) {
             /** Completions that require `this.` insertion text */
             CompletionSource["ThisProperty"] = "ThisProperty/";
+            /** Auto-import that comes attached to a class member snippet */
+            CompletionSource["ClassMemberSnippet"] = "ClassMemberSnippet/";
         })(CompletionSource = Completions.CompletionSource || (Completions.CompletionSource = {}));
         var SymbolOriginInfoKind;
         (function (SymbolOriginInfoKind) {
@@ -128588,7 +128845,6 @@ var ts;
             }
             // If the request is a continuation of an earlier `isIncomplete` response,
             // we can continue it from the cached previous response.
-            var typeChecker = program.getTypeChecker();
             var compilerOptions = program.getCompilerOptions();
             var incompleteCompletionsCache = preferences.allowIncompleteCompletions ? (_a = host.getIncompleteCompletionsCache) === null || _a === void 0 ? void 0 : _a.call(host) : undefined;
             if (incompleteCompletionsCache && completionKind === 3 /* TriggerForIncompleteCompletions */ && previousToken && ts.isIdentifier(previousToken)) {
@@ -128600,7 +128856,7 @@ var ts;
             else {
                 incompleteCompletionsCache === null || incompleteCompletionsCache === void 0 ? void 0 : incompleteCompletionsCache.clear();
             }
-            var stringCompletions = Completions.StringCompletions.getStringLiteralCompletions(sourceFile, position, previousToken, typeChecker, compilerOptions, host, log, preferences);
+            var stringCompletions = Completions.StringCompletions.getStringLiteralCompletions(sourceFile, position, previousToken, compilerOptions, host, program, log, preferences);
             if (stringCompletions) {
                 return stringCompletions;
             }
@@ -128614,7 +128870,7 @@ var ts;
             }
             switch (completionData.kind) {
                 case 0 /* Data */:
-                    var response = completionInfoFromData(sourceFile, typeChecker, compilerOptions, log, completionData, preferences);
+                    var response = completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences);
                     if (response === null || response === void 0 ? void 0 : response.isIncomplete) {
                         incompleteCompletionsCache === null || incompleteCompletionsCache === void 0 ? void 0 : incompleteCompletionsCache.set(response);
                     }
@@ -128711,7 +128967,7 @@ var ts;
             // StringLiteralLike locations are handled separately in stringCompletions.ts
             return (location === null || location === void 0 ? void 0 : location.kind) === 79 /* Identifier */ ? ts.createTextSpanFromNode(location) : undefined;
         }
-        function completionInfoFromData(sourceFile, typeChecker, compilerOptions, log, completionData, preferences) {
+        function completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences) {
             var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, importCompletionNode = completionData.importCompletionNode, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextIdMap = completionData.symbolToSortTextIdMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports;
             // Verify if the file is JSX language variant
             if (ts.getLanguageVariant(sourceFile.scriptKind) === 1 /* JSX */) {
@@ -128723,7 +128979,7 @@ var ts;
             var entries = [];
             if (isUncheckedFile(sourceFile, compilerOptions)) {
                 var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, typeChecker, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
                 getJSCompletionEntries(sourceFile, location.pos, uniqueNames, ts.getEmitScriptTarget(compilerOptions), entries); // TODO: GH#18217
             }
             else {
@@ -128731,7 +128987,7 @@ var ts;
                     return undefined;
                 }
                 getCompletionEntriesFromSymbols(symbols, entries, 
-                /*replacementToken*/ undefined, contextToken, location, sourceFile, typeChecker, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
+                /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap);
             }
             if (keywordFilters !== 0 /* None */) {
                 var entryNames = new ts.Set(entries.map(function (e) { return e.name; }));
@@ -128837,14 +129093,16 @@ var ts;
         function createCompletionEntryForLiteral(sourceFile, preferences, literal) {
             return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* string */, kindModifiers: "" /* none */, sortText: SortText.LocationPriority };
         }
-        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences) {
-            var _a;
+        function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, options, preferences, completionKind) {
+            var _a, _b;
             var insertText;
             var replacementSpan = ts.getReplacementSpanForContextToken(replacementToken);
             var data;
             var isSnippet;
+            var source = getSourceFromOrigin(origin);
             var sourceDisplay;
             var hasAction;
+            var typeChecker = program.getTypeChecker();
             var insertQuestionDot = origin && originIsNullableMember(origin);
             var useBraces = origin && originIsSymbolMember(origin) || needsConvertPropertyAccess;
             if (origin && originIsThisType(origin)) {
@@ -128895,12 +129153,16 @@ var ts;
                     isSnippet = preferences.includeCompletionsWithSnippetText ? true : undefined;
                 }
             }
-            if (insertText !== undefined && !preferences.includeCompletionsWithInsertText) {
-                return undefined;
-            }
-            if (originIsExport(origin) || originIsResolvedExport(origin)) {
-                data = originToCompletionEntryData(origin);
-                hasAction = !importCompletionNode;
+            if (preferences.includeCompletionsWithClassMemberSnippets &&
+                preferences.includeCompletionsWithInsertText &&
+                completionKind === 3 /* MemberLike */ &&
+                isClassLikeMemberCompletion(symbol, location)) {
+                var importAdder = void 0;
+                (_b = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken), insertText = _b.insertText, isSnippet = _b.isSnippet, importAdder = _b.importAdder);
+                if (importAdder === null || importAdder === void 0 ? void 0 : importAdder.hasFixes()) {
+                    hasAction = true;
+                    source = CompletionSource.ClassMemberSnippet;
+                }
             }
             var kind = ts.SymbolDisplay.getSymbolKind(typeChecker, symbol, location);
             if (kind === "JSX attribute" /* jsxAttribute */ && preferences.includeCompletionsWithSnippetText && preferences.jsxAttributeCompletionStyle && preferences.jsxAttributeCompletionStyle !== "none") {
@@ -128912,7 +129174,7 @@ var ts;
                     && !(type.flags & 1048576 /* Union */ && ts.find(type.types, function (type) { return !!(type.flags & 528 /* BooleanLike */); }))) {
                     if (type.flags & 402653316 /* StringLike */ || (type.flags & 1048576 /* Union */ && ts.every(type.types, function (type) { return !!(type.flags & (402653316 /* StringLike */ | 32768 /* Undefined */)); }))) {
                         // If is string like or undefined use quotes
-                        insertText = escapeSnippetText(name) + "=" + ts.quote(sourceFile, preferences, "$1");
+                        insertText = ts.escapeSnippetText(name) + "=" + ts.quote(sourceFile, preferences, "$1");
                         isSnippet = true;
                     }
                     else {
@@ -128921,13 +129183,20 @@ var ts;
                     }
                 }
                 if (useBraces_1) {
-                    insertText = escapeSnippetText(name) + "={$1}";
+                    insertText = ts.escapeSnippetText(name) + "={$1}";
                     isSnippet = true;
                 }
                 if (isSnippet) {
                     replacementSpan = ts.createTextSpanFromNode(location, sourceFile);
                 }
             }
+            if (insertText !== undefined && !preferences.includeCompletionsWithInsertText) {
+                return undefined;
+            }
+            if (originIsExport(origin) || originIsResolvedExport(origin)) {
+                data = originToCompletionEntryData(origin);
+                hasAction = !importCompletionNode;
+            }
             // TODO(drosen): Right now we just permit *all* semantic meanings when calling
             // 'getSymbolKind' which is permissible given that it is backwards compatible; but
             // really we should consider passing the meaning for the node so that we don't report
@@ -128940,7 +129209,7 @@ var ts;
                 kind: kind,
                 kindModifiers: ts.SymbolDisplay.getSymbolModifiers(typeChecker, symbol),
                 sortText: sortText,
-                source: getSourceFromOrigin(origin),
+                source: source,
                 hasAction: hasAction ? true : undefined,
                 isRecommended: isRecommendedCompletionMatch(symbol, recommendedCompletion, typeChecker) || undefined,
                 insertText: insertText,
@@ -128952,8 +129221,172 @@ var ts;
                 data: data,
             };
         }
-        function escapeSnippetText(text) {
-            return text.replace(/\$/gm, "\\$");
+        function isClassLikeMemberCompletion(symbol, location) {
+            // TODO: support JS files.
+            if (ts.isInJSFile(location)) {
+                return false;
+            }
+            // Completion symbol must be for a class member.
+            var memberFlags = 106500 /* ClassMember */
+                & 900095 /* EnumMemberExcludes */;
+            /* In
+            `class C {
+                |
+            }`
+            `location` is a class-like declaration.
+            In
+            `class C {
+                m|
+            }`
+            `location` is an identifier,
+            `location.parent` is a class element declaration,
+            and `location.parent.parent` is a class-like declaration.
+            In
+            `abstract class C {
+                abstract
+                abstract m|
+            }`
+            `location` is a syntax list (with modifiers as children),
+            and `location.parent` is a class-like declaration.
+            */
+            return !!(symbol.flags & memberFlags) &&
+                (ts.isClassLike(location) ||
+                    (location.parent &&
+                        location.parent.parent &&
+                        ts.isClassElement(location.parent) &&
+                        location === location.parent.name &&
+                        ts.isClassLike(location.parent.parent)) ||
+                    (location.parent &&
+                        ts.isSyntaxList(location) &&
+                        ts.isClassLike(location.parent)));
+        }
+        function getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken) {
+            var classLikeDeclaration = ts.findAncestor(location, ts.isClassLike);
+            if (!classLikeDeclaration) {
+                return { insertText: name };
+            }
+            var isSnippet;
+            var insertText = name;
+            var checker = program.getTypeChecker();
+            var sourceFile = location.getSourceFile();
+            var printer = createSnippetPrinter({
+                removeComments: true,
+                module: options.module,
+                target: options.target,
+                omitTrailingSemicolon: true,
+                newLine: ts.getNewLineKind(ts.getNewLineCharacter(options, ts.maybeBind(host, host.getNewLine))),
+            });
+            var importAdder = ts.codefix.createImportAdder(sourceFile, program, preferences, host);
+            var body;
+            if (preferences.includeCompletionsWithSnippetText) {
+                isSnippet = true;
+                // We are adding a tabstop (i.e. `$0`) in the body of the suggested member,
+                // if it has one, so that the cursor ends up in the body once the completion is inserted.
+                // Note: this assumes we won't have more than one body in the completion nodes, which should be the case.
+                var emptyStatement = ts.factory.createExpressionStatement(ts.factory.createIdentifier(""));
+                ts.setSnippetElement(emptyStatement, { kind: 0 /* TabStop */, order: 0 });
+                body = ts.factory.createBlock([emptyStatement], /* multiline */ true);
+            }
+            else {
+                body = ts.factory.createBlock([], /* multiline */ true);
+            }
+            var modifiers = 0 /* None */;
+            // Whether the suggested member should be abstract.
+            // e.g. in `abstract class C { abstract | }`, we should offer abstract method signatures at position `|`.
+            // Note: We are relying on checking if the context token is `abstract`,
+            // since other visibility modifiers (e.g. `protected`) should come *before* `abstract`.
+            // However, that is not true for the e.g. `override` modifier, so this check has its limitations.
+            var isAbstract = contextToken && isModifierLike(contextToken) === 126 /* AbstractKeyword */;
+            var completionNodes = [];
+            ts.codefix.addNewNodeForMemberSymbol(symbol, classLikeDeclaration, sourceFile, { program: program, host: host }, preferences, importAdder, 
+            // `addNewNodeForMemberSymbol` calls this callback function for each new member node
+            // it adds for the given member symbol.
+            // We store these member nodes in the `completionNodes` array.
+            // Note: there might be:
+            //  - No nodes if `addNewNodeForMemberSymbol` cannot figure out a node for the member;
+            //  - One node;
+            //  - More than one node if the member is overloaded (e.g. a method with overload signatures).
+            function (node) {
+                var requiredModifiers = 0 /* None */;
+                if (isAbstract) {
+                    requiredModifiers |= 128 /* Abstract */;
+                }
+                if (ts.isClassElement(node)
+                    && checker.getMemberOverrideModifierStatus(classLikeDeclaration, node) === 1 /* NeedsOverride */) {
+                    requiredModifiers |= 16384 /* Override */;
+                }
+                var presentModifiers = 0 /* None */;
+                if (!completionNodes.length) {
+                    // Omit already present modifiers from the first completion node/signature.
+                    if (contextToken) {
+                        presentModifiers = getPresentModifiers(contextToken);
+                    }
+                    // Keep track of added missing required modifiers and modifiers already present.
+                    // This is needed when we have overloaded signatures,
+                    // so this callback will be called for multiple nodes/signatures,
+                    // and we need to make sure the modifiers are uniform for all nodes/signatures.
+                    modifiers = node.modifierFlagsCache | requiredModifiers | presentModifiers;
+                }
+                node = ts.factory.updateModifiers(node, modifiers & (~presentModifiers));
+                completionNodes.push(node);
+            }, body, isAbstract);
+            if (completionNodes.length) {
+                insertText = printer.printSnippetList(1 /* MultiLine */, ts.factory.createNodeArray(completionNodes), sourceFile);
+            }
+            return { insertText: insertText, isSnippet: isSnippet, importAdder: importAdder };
+        }
+        function getPresentModifiers(contextToken) {
+            var modifiers = 0 /* None */;
+            var contextMod;
+            /*
+            Cases supported:
+            In
+            `class C {
+                public abstract |
+            }`
+            `contextToken` is ``abstract`` (as an identifier),
+            `contextToken.parent` is property declaration,
+            `location` is class declaration ``class C { ... }``.
+            In
+            `class C {
+                protected override m|
+            }`
+                `contextToken` is ``override`` (as a keyword),
+            `contextToken.parent` is property declaration,
+            `location` is identifier ``m``,
+            `location.parent` is property declaration ``protected override m``,
+            `location.parent.parent` is class declaration ``class C { ... }``.
+            */
+            if (contextMod = isModifierLike(contextToken)) {
+                modifiers |= ts.modifierToFlag(contextMod);
+            }
+            if (ts.isPropertyDeclaration(contextToken.parent)) {
+                modifiers |= ts.modifiersToFlags(contextToken.parent.modifiers);
+            }
+            return modifiers;
+        }
+        function isModifierLike(node) {
+            if (ts.isModifier(node)) {
+                return node.kind;
+            }
+            if (ts.isIdentifier(node) && node.originalKeywordKind && ts.isModifierKind(node.originalKeywordKind)) {
+                return node.originalKeywordKind;
+            }
+            return undefined;
+        }
+        function createSnippetPrinter(printerOptions) {
+            var printer = ts.createPrinter(printerOptions);
+            var baseWriter = ts.createTextWriter(ts.getNewLineCharacter(printerOptions));
+            var writer = __assign(__assign({}, baseWriter), { write: function (s) { return baseWriter.write(ts.escapeSnippetText(s)); }, nonEscapingWrite: baseWriter.write, writeLiteral: function (s) { return baseWriter.writeLiteral(ts.escapeSnippetText(s)); }, writeStringLiteral: function (s) { return baseWriter.writeStringLiteral(ts.escapeSnippetText(s)); }, writeSymbol: function (s, symbol) { return baseWriter.writeSymbol(ts.escapeSnippetText(s), symbol); }, writeParameter: function (s) { return baseWriter.writeParameter(ts.escapeSnippetText(s)); }, writeComment: function (s) { return baseWriter.writeComment(ts.escapeSnippetText(s)); }, writeProperty: function (s) { return baseWriter.writeProperty(ts.escapeSnippetText(s)); } });
+            return {
+                printSnippetList: printSnippetList,
+            };
+            /* Snippet-escaping version of `printer.printList`. */
+            function printSnippetList(format, list, sourceFile) {
+                writer.clear();
+                printer.writeList(format, list, sourceFile, writer);
+                return writer.getText();
+            }
         }
         function originToCompletionEntryData(origin) {
             var ambientModuleName = origin.fileName ? undefined : ts.stripQuotes(origin.moduleSymbol.name);
@@ -129021,10 +129454,10 @@ var ts;
             var importSpecifierTypeOnlyText = isImportSpecifierTypeOnly ? ts.tokenToString(151 /* TypeKeyword */) + " " : "";
             var suffix = useSemicolons ? ";" : "";
             switch (importKind) {
-                case 3 /* CommonJS */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + escapeSnippetText(name) + tabStop + " = require(" + quotedModuleSpecifier + ")" + suffix };
-                case 1 /* Default */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + escapeSnippetText(name) + tabStop + " from " + quotedModuleSpecifier + suffix };
-                case 2 /* Namespace */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "* as " + escapeSnippetText(name) + " from " + quotedModuleSpecifier + suffix };
-                case 0 /* Named */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "{ " + importSpecifierTypeOnlyText + escapeSnippetText(name) + tabStop + " } from " + quotedModuleSpecifier + suffix };
+                case 3 /* CommonJS */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + ts.escapeSnippetText(name) + tabStop + " = require(" + quotedModuleSpecifier + ")" + suffix };
+                case 1 /* Default */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + ts.escapeSnippetText(name) + tabStop + " from " + quotedModuleSpecifier + suffix };
+                case 2 /* Namespace */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "* as " + ts.escapeSnippetText(name) + " from " + quotedModuleSpecifier + suffix };
+                case 0 /* Named */: return { replacementSpan: replacementSpan, insertText: "import" + topLevelTypeOnlyText + "{ " + importSpecifierTypeOnlyText + ts.escapeSnippetText(name) + tabStop + " } from " + quotedModuleSpecifier + suffix };
             }
         }
         function quotePropertyName(sourceFile, preferences, name) {
@@ -129048,11 +129481,12 @@ var ts;
                 return CompletionSource.ThisProperty;
             }
         }
-        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, typeChecker, target, log, kind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap) {
+        function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importCompletionNode, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextIdMap) {
             var _a;
             var start = ts.timestamp();
             var variableDeclaration = getVariableDeclaration(location);
             var useSemicolons = ts.probablyUsesSemicolons(sourceFile);
+            var typeChecker = program.getTypeChecker();
             // Tracks unique names.
             // Value is set to false for global variables or completions from external module exports, because we can have multiple of those;
             // true otherwise. Based on the order we add things we will always see locals first, then globals, then module exports.
@@ -129068,7 +129502,7 @@ var ts;
                 var name = info.name, needsConvertPropertyAccess = info.needsConvertPropertyAccess;
                 var sortTextId = (_a = symbolToSortTextIdMap === null || symbolToSortTextIdMap === void 0 ? void 0 : symbolToSortTextIdMap[ts.getSymbolId(symbol)]) !== null && _a !== void 0 ? _a : 11 /* LocationPriority */;
                 var sortText = (isDeprecated(symbol, typeChecker) ? 8 /* DeprecatedOffset */ + sortTextId : sortTextId).toString();
-                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, typeChecker, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences);
+                var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importCompletionNode, useSemicolons, compilerOptions, preferences, kind);
                 if (!entry) {
                     continue;
                 }
@@ -129161,11 +129595,13 @@ var ts;
             if (entryId.data) {
                 var autoImport = getAutoImportSymbolFromCompletionEntryData(entryId.name, entryId.data, program, host);
                 if (autoImport) {
+                    var _a = getRelevantTokens(position, sourceFile), contextToken_1 = _a.contextToken, previousToken_1 = _a.previousToken;
                     return {
                         type: "symbol",
                         symbol: autoImport.symbol,
                         location: ts.getTouchingPropertyName(sourceFile, position),
-                        previousToken: ts.findPrecedingToken(position, sourceFile, /*startNode*/ undefined),
+                        previousToken: previousToken_1,
+                        contextToken: contextToken_1,
                         isJsxInitializer: false,
                         isTypeOnlyLocation: false,
                         origin: autoImport.origin,
@@ -129180,7 +129616,7 @@ var ts;
             if (completionData.kind !== 0 /* Data */) {
                 return { type: "request", request: completionData };
             }
-            var symbols = completionData.symbols, literals = completionData.literals, location = completionData.location, completionKind = completionData.completionKind, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, previousToken = completionData.previousToken, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation;
+            var symbols = completionData.symbols, literals = completionData.literals, location = completionData.location, completionKind = completionData.completionKind, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, contextToken = completionData.contextToken, previousToken = completionData.previousToken, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation;
             var literal = ts.find(literals, function (l) { return completionNameForLiteral(sourceFile, preferences, l) === entryId.name; });
             if (literal !== undefined)
                 return { type: "literal", literal: literal };
@@ -129191,15 +129627,15 @@ var ts;
             return ts.firstDefined(symbols, function (symbol, index) {
                 var origin = symbolToOriginInfoMap[index];
                 var info = getCompletionEntryDisplayNameForSymbol(symbol, ts.getEmitScriptTarget(compilerOptions), origin, completionKind, completionData.isJsxIdentifierExpected);
-                return info && info.name === entryId.name && getSourceFromOrigin(origin) === entryId.source
-                    ? { type: "symbol", symbol: symbol, location: location, origin: origin, previousToken: previousToken, isJsxInitializer: isJsxInitializer, isTypeOnlyLocation: isTypeOnlyLocation }
+                return info && info.name === entryId.name && (entryId.source === CompletionSource.ClassMemberSnippet && symbol.flags & 106500 /* ClassMember */ || getSourceFromOrigin(origin) === entryId.source)
+                    ? { type: "symbol", symbol: symbol, location: location, origin: origin, contextToken: contextToken, previousToken: previousToken, isJsxInitializer: isJsxInitializer, isTypeOnlyLocation: isTypeOnlyLocation }
                     : undefined;
             }) || { type: "none" };
         }
         function getCompletionEntryDetails(program, log, sourceFile, position, entryId, host, formatContext, preferences, cancellationToken) {
             var typeChecker = program.getTypeChecker();
             var compilerOptions = program.getCompilerOptions();
-            var name = entryId.name;
+            var name = entryId.name, source = entryId.source, data = entryId.data;
             var contextToken = ts.findPrecedingToken(position, sourceFile);
             if (ts.isInString(sourceFile, position, contextToken)) {
                 return Completions.StringCompletions.getStringLiteralCompletionDetails(name, sourceFile, position, contextToken, typeChecker, compilerOptions, host, cancellationToken, preferences);
@@ -129223,8 +129659,8 @@ var ts;
                     }
                 }
                 case "symbol": {
-                    var symbol = symbolCompletion.symbol, location = symbolCompletion.location, origin = symbolCompletion.origin, previousToken = symbolCompletion.previousToken;
-                    var _a = getCompletionEntryCodeActionsAndSourceDisplay(origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, entryId.data), codeActions = _a.codeActions, sourceDisplay = _a.sourceDisplay;
+                    var symbol = symbolCompletion.symbol, location = symbolCompletion.location, contextToken_2 = symbolCompletion.contextToken, origin = symbolCompletion.origin, previousToken = symbolCompletion.previousToken;
+                    var _a = getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken_2, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source), codeActions = _a.codeActions, sourceDisplay = _a.sourceDisplay;
                     return createCompletionDetailsForSymbol(symbol, typeChecker, sourceFile, location, cancellationToken, codeActions, sourceDisplay); // TODO: GH#18217
                 }
                 case "literal": {
@@ -129253,14 +129689,27 @@ var ts;
             return { name: name, kindModifiers: kindModifiers, kind: kind, displayParts: displayParts, documentation: documentation, tags: tags, codeActions: codeActions, source: source, sourceDisplay: source };
         }
         Completions.createCompletionDetails = createCompletionDetails;
-        function getCompletionEntryCodeActionsAndSourceDisplay(origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data) {
+        function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source) {
             if (data === null || data === void 0 ? void 0 : data.moduleSpecifier) {
-                var _a = getRelevantTokens(position, sourceFile), contextToken = _a.contextToken, previousToken_1 = _a.previousToken;
-                if (previousToken_1 && getImportStatementCompletionInfo(contextToken || previousToken_1).replacementNode) {
+                var _a = getRelevantTokens(position, sourceFile), contextToken_3 = _a.contextToken, previousToken_2 = _a.previousToken;
+                if (previousToken_2 && getImportStatementCompletionInfo(contextToken_3 || previousToken_2).replacementNode) {
                     // Import statement completion: 'import c|'
                     return { codeActions: undefined, sourceDisplay: [ts.textPart(data.moduleSpecifier)] };
                 }
             }
+            if (source === CompletionSource.ClassMemberSnippet) {
+                var importAdder = getEntryForMemberCompletion(host, program, compilerOptions, preferences, name, symbol, location, contextToken).importAdder;
+                if (importAdder) {
+                    var changes = ts.textChanges.ChangeTracker.with({ host: host, formatContext: formatContext, preferences: preferences }, importAdder.writeFixes);
+                    return {
+                        sourceDisplay: undefined,
+                        codeActions: [{
+                                changes: changes,
+                                description: ts.diagnosticToString([ts.Diagnostics.Includes_imports_of_types_referenced_by_0, name]),
+                            }],
+                    };
+                }
+            }
             if (!origin || !(originIsExport(origin) || originIsResolvedExport(origin))) {
                 return { codeActions: undefined, sourceDisplay: undefined };
             }
@@ -145101,7 +145550,7 @@ var ts;
             /** Note: output node may be mutated input node. */
             function getNonformattedText(node, sourceFile, newLineCharacter) {
                 var writer = createWriter(newLineCharacter);
-                var newLine = newLineCharacter === "\n" ? 1 /* LineFeed */ : 0 /* CarriageReturnLineFeed */;
+                var newLine = ts.getNewLineKind(newLineCharacter);
                 ts.createPrinter({
                     newLine: newLine,
                     neverAsciiEscape: true,
@@ -145566,21 +146015,16 @@ var ts;
     (function (codefix) {
         var errorCodeToFixes = ts.createMultiMap();
         var fixIdToRegistration = new ts.Map();
-        function diagnosticToString(diag) {
-            return ts.isArray(diag)
-                ? ts.formatStringFromArgs(ts.getLocaleSpecificMessage(diag[0]), diag.slice(1))
-                : ts.getLocaleSpecificMessage(diag);
-        }
         function createCodeFixActionWithoutFixAll(fixName, changes, description) {
-            return createCodeFixActionWorker(fixName, diagnosticToString(description), changes, /*fixId*/ undefined, /*fixAllDescription*/ undefined);
+            return createCodeFixActionWorker(fixName, ts.diagnosticToString(description), changes, /*fixId*/ undefined, /*fixAllDescription*/ undefined);
         }
         codefix.createCodeFixActionWithoutFixAll = createCodeFixActionWithoutFixAll;
         function createCodeFixAction(fixName, changes, description, fixId, fixAllDescription, command) {
-            return createCodeFixActionWorker(fixName, diagnosticToString(description), changes, fixId, diagnosticToString(fixAllDescription), command);
+            return createCodeFixActionWorker(fixName, ts.diagnosticToString(description), changes, fixId, ts.diagnosticToString(fixAllDescription), command);
         }
         codefix.createCodeFixAction = createCodeFixAction;
         function createCodeFixActionMaybeFixAll(fixName, changes, description, fixId, fixAllDescription, command) {
-            return createCodeFixActionWorker(fixName, diagnosticToString(description), changes, fixId, fixAllDescription && diagnosticToString(fixAllDescription), command);
+            return createCodeFixActionWorker(fixName, ts.diagnosticToString(description), changes, fixId, fixAllDescription && ts.diagnosticToString(fixAllDescription), command);
         }
         codefix.createCodeFixActionMaybeFixAll = createCodeFixActionMaybeFixAll;
         function createCodeFixActionWorker(fixName, description, changes, fixId, fixAllDescription, command) {
@@ -148341,7 +148785,7 @@ var ts;
             var addToExisting = new ts.Map();
             /** Use `getNewImportEntry` for access */
             var newImports = new ts.Map();
-            return { addImportFromDiagnostic: addImportFromDiagnostic, addImportFromExportedSymbol: addImportFromExportedSymbol, writeFixes: writeFixes };
+            return { addImportFromDiagnostic: addImportFromDiagnostic, addImportFromExportedSymbol: addImportFromExportedSymbol, writeFixes: writeFixes, hasFixes: hasFixes };
             function addImportFromDiagnostic(diagnostic, context) {
                 var info = getFixesInfo(context, diagnostic.code, diagnostic.start, useAutoImportProvider);
                 if (!info || !info.fixes.length)
@@ -148492,6 +148936,9 @@ var ts;
                     ts.insertImports(changeTracker, sourceFile, newDeclarations, /*blankLineBetween*/ true);
                 }
             }
+            function hasFixes() {
+                return addToNamespace.length > 0 || importType.length > 0 || addToExisting.size > 0 || newImports.size > 0;
+            }
         }
         // Sorted with the preferred fix coming first.
         var ImportFixKind;
@@ -152702,7 +153149,7 @@ var ts;
             for (var _i = 0, possiblyMissingSymbols_1 = possiblyMissingSymbols; _i < possiblyMissingSymbols_1.length; _i++) {
                 var symbol = possiblyMissingSymbols_1[_i];
                 if (!classMembers.has(symbol.escapedName)) {
-                    addNewNodeForMemberSymbol(symbol, classDeclaration, sourceFile, context, preferences, importAdder, addClassElement);
+                    addNewNodeForMemberSymbol(symbol, classDeclaration, sourceFile, context, preferences, importAdder, addClassElement, /* body */ undefined);
                 }
             }
         }
@@ -152715,9 +153162,11 @@ var ts;
         }
         codefix.getNoopSymbolTrackerWithResolver = getNoopSymbolTrackerWithResolver;
         /**
-         * @returns Empty string iff there we can't figure out a representation for `symbol` in `enclosingDeclaration`.
+         * `addClassElement` will not be called if we can't figure out a representation for `symbol` in `enclosingDeclaration`.
+         * @param body If defined, this will be the body of the member node passed to `addClassElement`. Otherwise, the body will default to a stub.
          */
-        function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement) {
+        function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, isAmbient) {
+            if (isAmbient === void 0) { isAmbient = false; }
             var declarations = symbol.getDeclarations();
             if (!(declarations && declarations.length)) {
                 return undefined;
@@ -152730,7 +153179,7 @@ var ts;
             var modifiers = visibilityModifier ? ts.factory.createNodeArray([visibilityModifier]) : undefined;
             var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
             var optional = !!(symbol.flags & 16777216 /* Optional */);
-            var ambient = !!(enclosingDeclaration.flags & 8388608 /* Ambient */);
+            var ambient = !!(enclosingDeclaration.flags & 8388608 /* Ambient */) || isAmbient;
             var quotePreference = ts.getQuotePreference(sourceFile, preferences);
             switch (declaration.kind) {
                 case 165 /* PropertySignature */:
@@ -152766,14 +153215,14 @@ var ts;
                         var accessor = orderedAccessors_1[_i];
                         if (ts.isGetAccessorDeclaration(accessor)) {
                             addClassElement(ts.factory.createGetAccessorDeclaration(
-                            /*decorators*/ undefined, modifiers, name, ts.emptyArray, typeNode_1, ambient ? undefined : createStubbedMethodBody(quotePreference)));
+                            /*decorators*/ undefined, modifiers, name, ts.emptyArray, typeNode_1, ambient ? undefined : body || createStubbedMethodBody(quotePreference)));
                         }
                         else {
                             ts.Debug.assertNode(accessor, ts.isSetAccessorDeclaration, "The counterpart to a getter should be a setter");
                             var parameter = ts.getSetAccessorValueParameter(accessor);
                             var parameterName = parameter && ts.isIdentifier(parameter.name) ? ts.idText(parameter.name) : undefined;
                             addClassElement(ts.factory.createSetAccessorDeclaration(
-                            /*decorators*/ undefined, modifiers, name, createDummyParameters(1, [parameterName], [typeNode_1], 1, /*inJs*/ false), ambient ? undefined : createStubbedMethodBody(quotePreference)));
+                            /*decorators*/ undefined, modifiers, name, createDummyParameters(1, [parameterName], [typeNode_1], 1, /*inJs*/ false), ambient ? undefined : body || createStubbedMethodBody(quotePreference)));
                         }
                     }
                     break;
@@ -152794,7 +153243,7 @@ var ts;
                     if (declarations.length === 1) {
                         ts.Debug.assert(signatures.length === 1, "One declaration implies one signature");
                         var signature = signatures[0];
-                        outputMethod(quotePreference, signature, modifiers, name, ambient ? undefined : createStubbedMethodBody(quotePreference));
+                        outputMethod(quotePreference, signature, modifiers, name, ambient ? undefined : body || createStubbedMethodBody(quotePreference));
                         break;
                     }
                     for (var _a = 0, signatures_1 = signatures; _a < signatures_1.length; _a++) {
@@ -152805,11 +153254,11 @@ var ts;
                     if (!ambient) {
                         if (declarations.length > signatures.length) {
                             var signature = checker.getSignatureFromDeclaration(declarations[declarations.length - 1]);
-                            outputMethod(quotePreference, signature, modifiers, name, createStubbedMethodBody(quotePreference));
+                            outputMethod(quotePreference, signature, modifiers, name, body || createStubbedMethodBody(quotePreference));
                         }
                         else {
                             ts.Debug.assert(declarations.length === signatures.length, "Declarations and signatures should match count");
-                            addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference));
+                            addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference, body));
                         }
                     }
                     break;
@@ -152820,6 +153269,7 @@ var ts;
                     addClassElement(method);
             }
         }
+        codefix.addNewNodeForMemberSymbol = addNewNodeForMemberSymbol;
         function createSignatureDeclarationFromSignature(kind, context, quotePreference, signature, body, name, modifiers, optional, enclosingDeclaration, importAdder) {
             var program = context.program;
             var checker = program.getTypeChecker();
@@ -152957,7 +153407,7 @@ var ts;
             }
             return parameters;
         }
-        function createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference) {
+        function createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference, body) {
             /** This is *a* signature with the maximal number of arguments,
              * such that if there is a "maximal" signature without rest arguments,
              * this is one of them.
@@ -152988,7 +153438,7 @@ var ts;
                 parameters.push(restParameter);
             }
             return createStubbedMethod(modifiers, name, optional, 
-            /*typeParameters*/ undefined, parameters, getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration), quotePreference);
+            /*typeParameters*/ undefined, parameters, getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration), quotePreference, body);
         }
         function getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration) {
             if (ts.length(signatures)) {
@@ -152996,10 +153446,10 @@ var ts;
                 return checker.typeToTypeNode(type, enclosingDeclaration, /*flags*/ undefined, getNoopSymbolTrackerWithResolver(context));
             }
         }
-        function createStubbedMethod(modifiers, name, optional, typeParameters, parameters, returnType, quotePreference) {
+        function createStubbedMethod(modifiers, name, optional, typeParameters, parameters, returnType, quotePreference, body) {
             return ts.factory.createMethodDeclaration(
             /*decorators*/ undefined, modifiers, 
-            /*asteriskToken*/ undefined, name, optional ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeParameters, parameters, returnType, createStubbedMethodBody(quotePreference));
+            /*asteriskToken*/ undefined, name, optional ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeParameters, parameters, returnType, body || createStubbedMethodBody(quotePreference));
         }
         function createStubbedMethodBody(quotePreference) {
             return createStubbedBody(ts.Diagnostics.Method_not_implemented.message, quotePreference);
@@ -164647,6 +165097,10 @@ var ts;
                     this.hasAddedOrRemovedSymlinks = true;
                 }
             };
+            /* @internal */
+            Project.prototype.onDiscoveredSymlink = function () {
+                this.hasAddedOrRemovedSymlinks = true;
+            };
             /**
              * Updates set of files that contribute to this project
              * @returns: true if set of files in the project stays the same and false - otherwise.