typescript 4.2.0-dev.20210208 → 4.2.2

package/lib/tsserver.js

@@ -96,7 +96,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.20210208";
+    ts.version = "4.2.2";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -3463,39 +3463,41 @@ var ts;
     /** Performance logger that will generate ETW events if possible - check for `logEvent` member, as `etwModule` will be `{}` when browserified */
     ts.perfLogger = etwModule && etwModule.logEvent ? etwModule : nullLogger;
 })(ts || (ts = {}));
+/* Tracing events for the compiler. */
 /*@internal*/
-/** Tracing events for the compiler. */
 var ts;
 (function (ts) {
-    var tracing;
-    (function (tracing) {
+    // enable the above using startTracing()
+})(ts || (ts = {}));
+// `tracingEnabled` should never be used directly, only through the above
+/* @internal */
+(function (ts) {
+    var tracingEnabled;
+    (function (tracingEnabled) {
         var Mode;
         (function (Mode) {
             Mode[Mode["Project"] = 0] = "Project";
             Mode[Mode["Build"] = 1] = "Build";
             Mode[Mode["Server"] = 2] = "Server";
-        })(Mode = tracing.Mode || (tracing.Mode = {}));
+        })(Mode = tracingEnabled.Mode || (tracingEnabled.Mode = {}));
         var fs;
         var traceCount = 0;
-        var traceFd;
+        var traceFd = 0;
         var mode;
         var legendPath;
         var legend = [];
         ;
-        /** Starts tracing for the given project (unless the `fs` module is unavailable). */
+        /** Starts tracing for the given project. */
         function startTracing(tracingMode, traceDir, configFilePath) {
-            ts.Debug.assert(!traceFd, "Tracing already started");
+            ts.Debug.assert(!ts.tracing, "Tracing already started");
             if (fs === undefined) {
                 try {
                     fs = require("fs");
                 }
-                catch (_a) {
-                    fs = false;
+                catch (e) {
+                    throw new Error("tracing requires having fs\n(original error: " + (e.message || e) + ")");
                 }
             }
-            if (!fs) {
-                return;
-            }
             mode = tracingMode;
             if (legendPath === undefined) {
                 legendPath = ts.combinePaths(traceDir, "legend.json");
@@ -3504,9 +3506,9 @@ var ts;
             if (!fs.existsSync(traceDir)) {
                 fs.mkdirSync(traceDir, { recursive: true });
             }
-            var countPart = mode === 1 /* Build */ ? "." + process.pid + "-" + ++traceCount :
-                mode === 2 /* Server */ ? "." + process.pid :
-                    "";
+            var countPart = mode === 1 /* Build */ ? "." + process.pid + "-" + ++traceCount
+                : mode === 2 /* Server */ ? "." + process.pid
+                    : "";
             var tracePath = ts.combinePaths(traceDir, "trace" + countPart + ".json");
             var typesPath = ts.combinePaths(traceDir, "types" + countPart + ".json");
             legend.push({
@@ -3515,24 +3517,21 @@ var ts;
                 typesPath: typesPath,
             });
             traceFd = fs.openSync(tracePath, "w");
+            ts.tracing = tracingEnabled; // only when traceFd is properly set
             // Start with a prefix that contains some metadata that the devtools profiler expects (also avoids a warning on import)
             var meta = { cat: "__metadata", ph: "M", ts: 1000 * ts.timestamp(), pid: 1, tid: 1 };
             fs.writeSync(traceFd, "[\n"
                 + [__assign({ name: "process_name", args: { name: "tsc" } }, meta), __assign({ name: "thread_name", args: { name: "Main" } }, meta), __assign(__assign({ name: "TracingStartedInBrowser" }, meta), { cat: "disabled-by-default-devtools.timeline" })]
                     .map(function (v) { return JSON.stringify(v); }).join(",\n"));
         }
-        tracing.startTracing = startTracing;
-        /** Stops tracing for the in-progress project and dumps the type catalog (unless the `fs` module is unavailable). */
+        tracingEnabled.startTracing = startTracing;
+        /** Stops tracing for the in-progress project and dumps the type catalog. */
         function stopTracing(typeCatalog) {
-            if (!traceFd) {
-                ts.Debug.assert(!fs, "Tracing is not in progress");
-                return;
-            }
-            ts.Debug.assert(fs);
+            ts.Debug.assert(ts.tracing, "Tracing is not in progress");
             ts.Debug.assert(!!typeCatalog === (mode !== 2 /* Server */)); // Have a type catalog iff not in server mode
             fs.writeSync(traceFd, "\n]\n");
             fs.closeSync(traceFd);
-            traceFd = undefined;
+            ts.tracing = undefined;
             if (typeCatalog) {
                 dumpTypes(typeCatalog);
             }
@@ -3542,11 +3541,7 @@ var ts;
                 legend[legend.length - 1].typesPath = undefined;
             }
         }
-        tracing.stopTracing = stopTracing;
-        function isTracing() {
-            return !!traceFd;
-        }
-        tracing.isTracing = isTracing;
+        tracingEnabled.stopTracing = stopTracing;
         var Phase;
         (function (Phase) {
             Phase["Parse"] = "parse";
@@ -3556,13 +3551,11 @@ var ts;
             Phase["CheckTypes"] = "checkTypes";
             Phase["Emit"] = "emit";
             Phase["Session"] = "session";
-        })(Phase = tracing.Phase || (tracing.Phase = {}));
+        })(Phase = tracingEnabled.Phase || (tracingEnabled.Phase = {}));
         function instant(phase, name, args) {
-            if (!traceFd)
-                return;
             writeEvent("I", phase, name, args, "\"s\":\"g\"");
         }
-        tracing.instant = instant;
+        tracingEnabled.instant = instant;
         var eventStack = [];
         /**
          * @param separateBeginAndEnd - used for special cases where we need the trace point even if the event
@@ -3572,45 +3565,40 @@ var ts;
          */
         function push(phase, name, args, separateBeginAndEnd) {
             if (separateBeginAndEnd === void 0) { separateBeginAndEnd = false; }
-            if (!traceFd)
-                return;
             if (separateBeginAndEnd) {
                 writeEvent("B", phase, name, args);
             }
             eventStack.push({ phase: phase, name: name, args: args, time: 1000 * ts.timestamp(), separateBeginAndEnd: separateBeginAndEnd });
         }
-        tracing.push = push;
+        tracingEnabled.push = push;
         function pop() {
-            if (!traceFd)
-                return;
             ts.Debug.assert(eventStack.length > 0);
             writeStackEvent(eventStack.length - 1, 1000 * ts.timestamp());
             eventStack.length--;
         }
-        tracing.pop = pop;
+        tracingEnabled.pop = pop;
         function popAll() {
-            if (!traceFd)
-                return;
             var endTime = 1000 * ts.timestamp();
             for (var i = eventStack.length - 1; i >= 0; i--) {
                 writeStackEvent(i, endTime);
             }
             eventStack.length = 0;
         }
-        tracing.popAll = popAll;
+        tracingEnabled.popAll = popAll;
+        // sample every 10ms
+        var sampleInterval = 1000 * 10;
         function writeStackEvent(index, endTime) {
             var _a = eventStack[index], phase = _a.phase, name = _a.name, args = _a.args, time = _a.time, separateBeginAndEnd = _a.separateBeginAndEnd;
             if (separateBeginAndEnd) {
                 writeEvent("E", phase, name, args, /*extras*/ undefined, endTime);
             }
-            else {
+            // test if [time,endTime) straddles a sampling point
+            else if (sampleInterval - (time % sampleInterval) <= endTime - time) {
                 writeEvent("X", phase, name, args, "\"dur\":" + (endTime - time), time);
             }
         }
         function writeEvent(eventType, phase, name, args, extras, time) {
             if (time === void 0) { time = 1000 * ts.timestamp(); }
-            ts.Debug.assert(traceFd);
-            ts.Debug.assert(fs);
             // In server mode, there's no easy way to dump type information, so we drop events that would require it.
             if (mode === 2 /* Server */ && phase === "checkTypes" /* CheckTypes */)
                 return;
@@ -3632,7 +3620,6 @@ var ts;
         }
         function dumpTypes(types) {
             var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-            ts.Debug.assert(fs);
             ts.performance.mark("beginDumpTypes");
             var typesPath = legend[legend.length - 1].typesPath;
             var typesFd = fs.openSync(typesPath, "w");
@@ -3712,11 +3699,15 @@ var ts;
             if (!legendPath) {
                 return;
             }
-            ts.Debug.assert(fs);
             fs.writeFileSync(legendPath, JSON.stringify(legend));
         }
-        tracing.dumpLegend = dumpLegend;
-    })(tracing = ts.tracing || (ts.tracing = {}));
+        tracingEnabled.dumpLegend = dumpLegend;
+    })(tracingEnabled = ts.tracingEnabled || (ts.tracingEnabled = {}));
+})(ts || (ts = {}));
+/*@internal*/
+(function (ts) {
+    // define after tracingEnabled is initialized
+    ts.startTracing = ts.tracingEnabled.startTracing;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
@@ -18606,7 +18597,7 @@ var ts;
     }
     function Type(checker, flags) {
         this.flags = flags;
-        if (ts.Debug.isDebugging || ts.tracing.isTracing()) {
+        if (ts.Debug.isDebugging || ts.tracing) {
             this.checker = checker;
         }
     }
@@ -28589,7 +28580,7 @@ var ts;
     }
     function createSourceFile(fileName, sourceText, languageVersion, setParentNodes, scriptKind) {
         if (setParentNodes === void 0) { setParentNodes = false; }
-        ts.tracing.push("parse" /* Parse */, "createSourceFile", { path: fileName }, /*separateBeginAndEnd*/ true);
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("parse" /* Parse */, "createSourceFile", { path: fileName }, /*separateBeginAndEnd*/ true);
         ts.performance.mark("beforeParse");
         var result;
         ts.perfLogger.logStartParseSourceFile(fileName);
@@ -28602,7 +28593,7 @@ var ts;
         ts.perfLogger.logStopParseSourceFile();
         ts.performance.mark("afterParse");
         ts.performance.measure("Parse", "beforeParse", "afterParse");
-        ts.tracing.pop();
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         return result;
     }
     ts.createSourceFile = createSourceFile;
@@ -40269,14 +40260,14 @@ var ts;
     }
     var binder = createBinder();
     function bindSourceFile(file, options) {
-        ts.tracing.push("bind" /* Bind */, "bindSourceFile", { path: file.path }, /*separateBeginAndEnd*/ true);
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("bind" /* Bind */, "bindSourceFile", { path: file.path }, /*separateBeginAndEnd*/ true);
         ts.performance.mark("beforeBind");
         ts.perfLogger.logStartBindFile("" + file.fileName);
         binder(file, options);
         ts.perfLogger.logStopBindFile();
         ts.performance.mark("afterBind");
         ts.performance.measure("Bind", "beforeBind", "afterBind");
-        ts.tracing.pop();
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
     }
     ts.bindSourceFile = bindSourceFile;
     function createBinder() {
@@ -55668,7 +55659,7 @@ var ts;
                                 // caps union types at 1000 unique object types.
                                 var estimatedCount = (count / (len - i)) * len;
                                 if (estimatedCount > 1000000) {
-                                    ts.tracing.instant("checkTypes" /* CheckTypes */, "removeSubtypes_DepthLimit", { typeIds: types.map(function (t) { return t.id; }) });
+                                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "removeSubtypes_DepthLimit", { typeIds: types.map(function (t) { return t.id; }) });
                                     error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
                                     return false;
                                 }
@@ -55686,7 +55677,7 @@ var ts;
             }
             return true;
         }
-        function removeRedundantLiteralTypes(types, includes) {
+        function removeRedundantLiteralTypes(types, includes, reduceVoidUndefined) {
             var i = types.length;
             while (i > 0) {
                 i--;
@@ -55696,7 +55687,7 @@ var ts;
                     flags & 256 /* NumberLiteral */ && includes & 8 /* Number */ ||
                     flags & 2048 /* BigIntLiteral */ && includes & 64 /* BigInt */ ||
                     flags & 8192 /* UniqueESSymbol */ && includes & 4096 /* ESSymbol */ ||
-                    flags & 32768 /* Undefined */ && includes & 16384 /* Void */ ||
+                    reduceVoidUndefined && flags & 32768 /* Undefined */ && includes & 16384 /* Void */ ||
                     isFreshLiteralType(t) && containsType(types, t.regularType);
                 if (remove) {
                     ts.orderedRemoveItemAt(types, i);
@@ -55764,7 +55755,7 @@ var ts;
                 }
                 if (unionReduction & (1 /* Literal */ | 2 /* Subtype */)) {
                     if (includes & (2944 /* Literal */ | 8192 /* UniqueESSymbol */) || includes & 16384 /* Void */ && includes & 32768 /* Undefined */) {
-                        removeRedundantLiteralTypes(typeSet, includes);
+                        removeRedundantLiteralTypes(typeSet, includes, !!(unionReduction & 2 /* Subtype */));
                     }
                     if (includes & 128 /* StringLiteral */ && includes & 134217728 /* TemplateLiteral */) {
                         removeStringLiteralsMatchedByTemplateLiterals(typeSet);
@@ -56138,7 +56129,7 @@ var ts;
         function checkCrossProductUnion(types) {
             var size = getCrossProductUnionSize(types);
             if (size >= 100000) {
-                ts.tracing.instant("checkTypes" /* CheckTypes */, "checkCrossProductUnion_DepthLimit", { typeIds: types.map(function (t) { return t.id; }), size: size });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "checkCrossProductUnion_DepthLimit", { typeIds: types.map(function (t) { return t.id; }), size: size });
                 error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent);
                 return false;
             }
@@ -57910,7 +57901,7 @@ var ts;
                 // We have reached 50 recursive type instantiations and there is a very high likelyhood we're dealing
                 // with a combination of infinite generic types that perpetually generate new type identities. We stop
                 // the recursion here by yielding the error type.
-                ts.tracing.instant("checkTypes" /* CheckTypes */, "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth: instantiationDepth, instantiationCount: instantiationCount });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth: instantiationDepth, instantiationCount: instantiationCount });
                 error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
                 return errorType;
             }
@@ -58946,7 +58937,7 @@ var ts;
                 reportIncompatibleStack();
             }
             if (overflow) {
-                ts.tracing.instant("checkTypes" /* CheckTypes */, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: depth });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: depth });
                 var diag = error(errorNode || currentNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target));
                 if (errorOutputContainer) {
                     (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag);
@@ -59397,7 +59388,7 @@ var ts;
                 }
             }
             function traceUnionsOrIntersectionsTooLarge(source, target) {
-                if (!ts.tracing.isTracing()) {
+                if (!ts.tracing) {
                     return;
                 }
                 if ((source.flags & 3145728 /* UnionOrIntersection */) && (target.flags & 3145728 /* UnionOrIntersection */)) {
@@ -59754,7 +59745,7 @@ var ts;
                     };
                 }
                 if (expandingFlags === 3 /* Both */) {
-                    ts.tracing.instant("checkTypes" /* CheckTypes */, "recursiveTypeRelatedTo_DepthLimit", {
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "recursiveTypeRelatedTo_DepthLimit", {
                         sourceId: source.id,
                         sourceIdStack: sourceStack.map(function (t) { return t.id; }),
                         targetId: target.id,
@@ -59789,9 +59780,9 @@ var ts;
                 return result;
             }
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
-                ts.tracing.push("checkTypes" /* CheckTypes */, "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* CheckTypes */, "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id });
                 var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState);
-                ts.tracing.pop();
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
                 return result;
             }
             function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState) {
@@ -60303,7 +60294,7 @@ var ts;
                     numCombinations *= countTypes(getTypeOfSymbol(sourceProperty));
                     if (numCombinations > 25) {
                         // We've reached the complexity limit.
-                        ts.tracing.instant("checkTypes" /* CheckTypes */, "typeRelatedToDiscriminatedType_DepthLimit", { sourceId: source.id, targetId: target.id, numCombinations: numCombinations });
+                        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "typeRelatedToDiscriminatedType_DepthLimit", { sourceId: source.id, targetId: target.id, numCombinations: numCombinations });
                         return 0 /* False */;
                     }
                 }
@@ -61058,7 +61049,7 @@ var ts;
             if (typeParameters === void 0) { typeParameters = ts.emptyArray; }
             var variances = cache.variances;
             if (!variances) {
-                ts.tracing.push("checkTypes" /* CheckTypes */, "getVariancesWorker", { arity: typeParameters.length, id: (_c = (_a = cache.id) !== null && _a !== void 0 ? _a : (_b = cache.declaredType) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : -1 });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* CheckTypes */, "getVariancesWorker", { arity: typeParameters.length, id: (_c = (_a = cache.id) !== null && _a !== void 0 ? _a : (_b = cache.declaredType) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : -1 });
                 // The emptyArray singleton is used to signal a recursive invocation.
                 cache.variances = ts.emptyArray;
                 variances = [];
@@ -61097,7 +61088,7 @@ var ts;
                     _loop_19(tp);
                 }
                 cache.variances = variances;
-                ts.tracing.pop();
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             }
             return variances;
         }
@@ -63785,7 +63776,16 @@ var ts;
                         var type = getTypeOfDottedName(node.expression, diagnostic);
                         if (type) {
                             var name = node.name;
-                            var prop = getPropertyOfType(type, ts.isPrivateIdentifier(name) ? ts.getSymbolNameForPrivateIdentifier(type.symbol, name.escapedText) : name.escapedText);
+                            var prop = void 0;
+                            if (ts.isPrivateIdentifier(name)) {
+                                if (!type.symbol) {
+                                    return undefined;
+                                }
+                                prop = getPropertyOfType(type, ts.getSymbolNameForPrivateIdentifier(type.symbol, name.escapedText));
+                            }
+                            else {
+                                prop = getPropertyOfType(type, name.escapedText);
+                            }
                             return prop && getExplicitTypeOfSymbol(prop, diagnostic);
                         }
                         return undefined;
@@ -63998,7 +63998,7 @@ var ts;
                 if (flowDepth === 2000) {
                     // We have made 2000 recursive invocations. To avoid overflowing the call stack we report an error
                     // and disable further control flow analysis in the containing function or module body.
-                    ts.tracing.instant("checkTypes" /* CheckTypes */, "getTypeAtFlowNode_DepthLimit", { flowId: flow.id });
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* CheckTypes */, "getTypeAtFlowNode_DepthLimit", { flowId: flow.id });
                     flowAnalysisDisabled = true;
                     reportFlowControlError(reference);
                     return errorType;
@@ -64851,10 +64851,15 @@ var ts;
                         return assignableType;
                     }
                 }
-                // If the candidate type is a subtype of the target type, narrow to the candidate type,
-                // if the target type is a subtype of the candidate type, narrow to the target type,
-                // otherwise, narrow to an intersection of the two types.
-                return isTypeSubtypeOf(candidate, type) ? candidate : isTypeSubtypeOf(type, candidate) ? type : getIntersectionType([type, candidate]);
+                // If the candidate type is a subtype of the target type, narrow to the candidate type.
+                // Otherwise, if the target type is assignable to the candidate type, keep the target type.
+                // Otherwise, if the candidate type is assignable to the target type, narrow to the candidate
+                // type. Otherwise, the types are completely unrelated, so narrow to an intersection of the
+                // two types.
+                return isTypeSubtypeOf(candidate, type) ? candidate :
+                    isTypeAssignableTo(type, candidate) ? type :
+                        isTypeAssignableTo(candidate, type) ? candidate :
+                            getIntersectionType([type, candidate]);
             }
             function narrowTypeByCallExpression(type, callExpression, assumeTrue) {
                 if (hasMatchingArgument(callExpression, reference)) {
@@ -72625,7 +72630,7 @@ var ts;
             }
         }
         function checkExpression(node, checkMode, forceTuple) {
-            ts.tracing.push("check" /* Check */, "checkExpression", { kind: node.kind, pos: node.pos, end: node.end });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* Check */, "checkExpression", { kind: node.kind, pos: node.pos, end: node.end });
             var saveCurrentNode = currentNode;
             currentNode = node;
             instantiationCount = 0;
@@ -72635,7 +72640,7 @@ var ts;
                 checkConstEnumAccess(node, type);
             }
             currentNode = saveCurrentNode;
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             return type;
         }
         function checkConstEnumAccess(node, type) {
@@ -75157,10 +75162,10 @@ var ts;
             return ts.getSelectedEffectiveModifierFlags(left, interestingFlags) === ts.getSelectedEffectiveModifierFlags(right, interestingFlags);
         }
         function checkVariableDeclaration(node) {
-            ts.tracing.push("check" /* Check */, "checkVariableDeclaration", { kind: node.kind, pos: node.pos, end: node.end });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* Check */, "checkVariableDeclaration", { kind: node.kind, pos: node.pos, end: node.end });
             checkGrammarVariableDeclaration(node);
             checkVariableLikeDeclaration(node);
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }
         function checkBindingElement(node) {
             checkGrammarBindingElement(node);
@@ -75197,7 +75202,9 @@ var ts;
                 : ts.isPropertyAccessExpression(location) ? location.name
                     : ts.isBinaryExpression(location) && ts.isIdentifier(location.right) ? location.right
                         : undefined;
-            if (!testedNode) {
+            var isPropertyExpressionCast = ts.isPropertyAccessExpression(location)
+                && ts.isAssertionExpression(ts.skipParentheses(location.expression));
+            if (!testedNode || isPropertyExpressionCast) {
                 return;
             }
             var possiblyFalsy = getFalsyFlags(type);
@@ -77967,7 +77974,7 @@ var ts;
             }
         }
         function checkDeferredNode(node) {
-            ts.tracing.push("check" /* Check */, "checkDeferredNode", { kind: node.kind, pos: node.pos, end: node.end });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* Check */, "checkDeferredNode", { kind: node.kind, pos: node.pos, end: node.end });
             var saveCurrentNode = currentNode;
             currentNode = node;
             instantiationCount = 0;
@@ -78003,15 +78010,15 @@ var ts;
                     break;
             }
             currentNode = saveCurrentNode;
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }
         function checkSourceFile(node) {
-            ts.tracing.push("check" /* Check */, "checkSourceFile", { path: node.path }, /*separateBeginAndEnd*/ true);
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* Check */, "checkSourceFile", { path: node.path }, /*separateBeginAndEnd*/ true);
             ts.performance.mark("beforeCheck");
             checkSourceFileWorker(node);
             ts.performance.mark("afterCheck");
             ts.performance.measure("Check", "beforeCheck", "afterCheck");
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }
         function unusedIsError(kind, isAmbient) {
             if (isAmbient) {
@@ -99988,9 +99995,9 @@ var ts;
         var transformed = [];
         for (var _a = 0, nodes_3 = nodes; _a < nodes_3.length; _a++) {
             var node = nodes_3[_a];
-            ts.tracing.push("emit" /* Emit */, "transformNodes", node.kind === 297 /* SourceFile */ ? { path: node.path } : { kind: node.kind, pos: node.pos, end: node.end });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "transformNodes", node.kind === 297 /* SourceFile */ ? { path: node.path } : { kind: node.kind, pos: node.pos, end: node.end });
             transformed.push((allowDtsFiles ? transformation : transformRoot)(node));
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }
         // prevent modification of the lexical environment.
         state = 2 /* Completed */;
@@ -100586,15 +100593,15 @@ var ts;
                     sourceFiles: sourceFileOrBundle.sourceFiles.map(function (file) { return relativeToBuildInfo(ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory())); })
                 };
             }
-            ts.tracing.push("emit" /* Emit */, "emitJsFileOrBundle", { jsFilePath: jsFilePath });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emitJsFileOrBundle", { jsFilePath: jsFilePath });
             emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo);
-            ts.tracing.pop();
-            ts.tracing.push("emit" /* Emit */, "emitDeclarationFileOrBundle", { declarationFilePath: declarationFilePath });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emitDeclarationFileOrBundle", { declarationFilePath: declarationFilePath });
             emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo);
-            ts.tracing.pop();
-            ts.tracing.push("emit" /* Emit */, "emitBuildInfo", { buildInfoPath: buildInfoPath });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emitBuildInfo", { buildInfoPath: buildInfoPath });
             emitBuildInfo(bundleBuildInfo, buildInfoPath);
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             if (!emitSkipped && emittedFilesList) {
                 if (!emitOnlyDtsFiles) {
                     if (jsFilePath) {
@@ -106331,7 +106338,7 @@ var ts;
         var modulesWithElidedImports = new ts.Map();
         // Track source files that are source files found by searching under node_modules, as these shouldn't be compiled.
         var sourceFilesFoundSearchingNodeModules = new ts.Map();
-        ts.tracing.push("program" /* Program */, "createProgram", { configFilePath: options.configFilePath, rootDir: options.rootDir }, /*separateBeginAndEnd*/ true);
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "createProgram", { configFilePath: options.configFilePath, rootDir: options.rootDir }, /*separateBeginAndEnd*/ true);
         ts.performance.mark("beforeProgram");
         var host = createProgramOptions.host || createCompilerHost(options);
         var configParsingHost = parseConfigHostFromCompilerHostLike(host);
@@ -106407,15 +106414,15 @@ var ts;
             getSourceOfProjectReferenceRedirect: getSourceOfProjectReferenceRedirect,
             forEachResolvedProjectReference: forEachResolvedProjectReference
         }), onProgramCreateComplete = _d.onProgramCreateComplete, fileExists = _d.fileExists, directoryExists = _d.directoryExists;
-        ts.tracing.push("program" /* Program */, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram });
         var shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options);
-        ts.tracing.pop();
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         // We set `structuralIsReused` to `undefined` because `tryReuseStructureFromOldProgram` calls `tryReuseStructureFromOldProgram` which checks
         // `structuralIsReused`, which would be a TDZ violation if it was not set in advance to `undefined`.
         var structureIsReused;
-        ts.tracing.push("program" /* Program */, "tryReuseStructureFromOldProgram", {});
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "tryReuseStructureFromOldProgram", {});
         structureIsReused = tryReuseStructureFromOldProgram(); // eslint-disable-line prefer-const
-        ts.tracing.pop();
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         if (structureIsReused !== 2 /* Completely */) {
             processingDefaultLibFiles = [];
             processingOtherFiles = [];
@@ -106453,13 +106460,13 @@ var ts;
                     });
                 }
             }
-            ts.tracing.push("program" /* Program */, "processRootFiles", { count: rootNames.length });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processRootFiles", { count: rootNames.length });
             ts.forEach(rootNames, function (name, index) { return processRootFile(name, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.RootFile, index: index }); });
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             // load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders
             var typeReferences = rootNames.length ? ts.getAutomaticTypeDirectiveNames(options, host) : ts.emptyArray;
             if (typeReferences.length) {
-                ts.tracing.push("program" /* Program */, "processTypeReferences", { count: typeReferences.length });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferences", { count: typeReferences.length });
                 // This containingFilename needs to match with the one used in managed-side
                 var containingDirectory = options.configFilePath ? ts.getDirectoryPath(options.configFilePath) : host.getCurrentDirectory();
                 var containingFilename = ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile);
@@ -106467,7 +106474,7 @@ var ts;
                 for (var i = 0; i < typeReferences.length; i++) {
                     processTypeReferenceDirective(typeReferences[i], resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: (_b = resolutions[i]) === null || _b === void 0 ? void 0 : _b.packageId });
                 }
-                ts.tracing.pop();
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             }
             // Do not process the default library if:
             //  - The '--noLib' flag is used.
@@ -106590,19 +106597,19 @@ var ts;
         verifyCompilerOptions();
         ts.performance.mark("afterProgram");
         ts.performance.measure("Program", "beforeProgram", "afterProgram");
-        ts.tracing.pop();
+        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         return program;
         function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) {
             if (!moduleNames.length)
                 return ts.emptyArray;
             var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory);
             var redirectedReference = getRedirectReferenceForResolution(containingFile);
-            ts.tracing.push("program" /* Program */, "resolveModuleNamesWorker", { containingFileName: containingFileName });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "resolveModuleNamesWorker", { containingFileName: containingFileName });
             ts.performance.mark("beforeResolveModule");
             var result = actualResolveModuleNamesWorker(moduleNames, containingFileName, reusedNames, redirectedReference);
             ts.performance.mark("afterResolveModule");
             ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule");
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             return result;
         }
         function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile) {
@@ -106610,12 +106617,12 @@ var ts;
                 return [];
             var containingFileName = !ts.isString(containingFile) ? ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile;
             var redirectedReference = !ts.isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : undefined;
-            ts.tracing.push("program" /* Program */, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: containingFileName });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: containingFileName });
             ts.performance.mark("beforeResolveTypeReference");
             var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference);
             ts.performance.mark("afterResolveTypeReference");
             ts.performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference");
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             return result;
         }
         function getRedirectReferenceForResolution(file) {
@@ -107087,7 +107094,7 @@ var ts;
         }
         function emitBuildInfo(writeFileCallback) {
             ts.Debug.assert(!ts.outFile(options));
-            ts.tracing.push("emit" /* Emit */, "emitBuildInfo", {}, /*separateBeginAndEnd*/ true);
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emitBuildInfo", {}, /*separateBeginAndEnd*/ true);
             ts.performance.mark("beforeEmit");
             var emitResult = ts.emitFiles(ts.notImplementedResolver, getEmitHost(writeFileCallback), 
             /*targetSourceFile*/ undefined, 
@@ -107096,7 +107103,7 @@ var ts;
             /*onlyBuildInfo*/ true);
             ts.performance.mark("afterEmit");
             ts.performance.measure("Emit", "beforeEmit", "afterEmit");
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             return emitResult;
         }
         function getResolvedProjectReferences() {
@@ -107142,9 +107149,9 @@ var ts;
             return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = ts.createTypeChecker(program, /*produceDiagnostics:*/ false));
         }
         function emit(sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit) {
-            ts.tracing.push("emit" /* Emit */, "emit", { path: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.path }, /*separateBeginAndEnd*/ true);
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* Emit */, "emit", { path: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.path }, /*separateBeginAndEnd*/ true);
             var result = runWithCancellationToken(function () { return emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit); });
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             return result;
         }
         function isEmitBlocked(emitFileName) {
@@ -107805,13 +107812,13 @@ var ts;
         }
         // Get source file from normalized fileName
         function findSourceFile(fileName, path, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
-            ts.tracing.push("program" /* Program */, "findSourceFile", {
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "findSourceFile", {
                 fileName: fileName,
                 isDefaultLib: isDefaultLib || undefined,
                 fileIncludeKind: ts.FileIncludeKind[reason.kind],
             });
             var result = findSourceFileWorker(fileName, path, isDefaultLib, ignoreNoDefaultLib, reason, packageId);
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
             return result;
         }
         function findSourceFileWorker(fileName, path, isDefaultLib, ignoreNoDefaultLib, reason, packageId) {
@@ -108070,9 +108077,9 @@ var ts;
             }
         }
         function processTypeReferenceDirective(typeReferenceDirective, resolvedTypeReferenceDirective, reason) {
-            ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolveModuleNamesReusingOldState, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined });
             processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, reason);
-            ts.tracing.pop();
+            ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
         }
         function processTypeReferenceDirectiveWorker(typeReferenceDirective, resolvedTypeReferenceDirective, reason) {
             // If we already found this library as a primary reference - nothing to do
@@ -146970,13 +146977,13 @@ var ts;
                 return { edits: [] }; // TODO: GH#30113
             }
             function doChange(sourceFile, program, host, changes, functionDeclaration, groupedReferences) {
-                var newParamDeclaration = ts.map(createNewParameters(functionDeclaration, program, host), function (param) { return ts.getSynthesizedDeepClone(param); });
-                changes.replaceNodeRangeWithNodes(sourceFile, ts.first(functionDeclaration.parameters), ts.last(functionDeclaration.parameters), newParamDeclaration, { joiner: ", ",
-                    // indentation is set to 0 because otherwise the object parameter will be indented if there is a `this` parameter
-                    indentation: 0,
-                    leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll,
-                    trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include
-                });
+                var signature = groupedReferences.signature;
+                var newFunctionDeclarationParams = ts.map(createNewParameters(functionDeclaration, program, host), function (param) { return ts.getSynthesizedDeepClone(param); });
+                if (signature) {
+                    var newSignatureParams = ts.map(createNewParameters(signature, program, host), function (param) { return ts.getSynthesizedDeepClone(param); });
+                    replaceParameters(signature, newSignatureParams);
+                }
+                replaceParameters(functionDeclaration, newFunctionDeclarationParams);
                 var functionCalls = ts.sortAndDeduplicate(groupedReferences.functionCalls, /*comparer*/ function (a, b) { return ts.compareValues(a.pos, b.pos); });
                 for (var _i = 0, functionCalls_1 = functionCalls; _i < functionCalls_1.length; _i++) {
                     var call = functionCalls_1[_i];
@@ -146985,6 +146992,15 @@ var ts;
                         changes.replaceNodeRange(ts.getSourceFileOfNode(call), ts.first(call.arguments), ts.last(call.arguments), newArgument, { leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll, trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include });
                     }
                 }
+                function replaceParameters(declarationOrSignature, parameterDeclarations) {
+                    changes.replaceNodeRangeWithNodes(sourceFile, ts.first(declarationOrSignature.parameters), ts.last(declarationOrSignature.parameters), parameterDeclarations, {
+                        joiner: ", ",
+                        // indentation is set to 0 because otherwise the object parameter will be indented if there is a `this` parameter
+                        indentation: 0,
+                        leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll,
+                        trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include
+                    });
+                }
             }
             function getGroupedReferences(functionDeclaration, program, cancellationToken) {
                 var functionNames = getFunctionNames(functionDeclaration);
@@ -147003,12 +147019,38 @@ var ts;
                     var functionSymbols = ts.map(functionNames, getSymbolTargetAtLocation);
                     var classSymbols = ts.map(classNames, getSymbolTargetAtLocation);
                     var isConstructor = ts.isConstructorDeclaration(functionDeclaration);
+                    var contextualSymbols = ts.map(functionNames, function (name) { return getSymbolForContextualType(name, checker); });
                     for (var _i = 0, referenceEntries_1 = referenceEntries; _i < referenceEntries_1.length; _i++) {
                         var entry = referenceEntries_1[_i];
-                        if (entry.kind !== 1 /* Node */) {
+                        if (entry.kind === 0 /* Span */) {
                             groupedReferences.valid = false;
                             continue;
                         }
+                        /* Declarations in object literals may be implementations of method signatures which have a different symbol from the declaration
+                        For example:
+                            interface IFoo { m(a: number): void }
+                            const foo: IFoo = { m(a: number): void {} }
+                        In these cases we get the symbol for the signature from the contextual type.
+                        */
+                        if (ts.contains(contextualSymbols, getSymbolTargetAtLocation(entry.node))) {
+                            if (isValidMethodSignature(entry.node.parent)) {
+                                groupedReferences.signature = entry.node.parent;
+                                continue;
+                            }
+                            var call = entryToFunctionCall(entry);
+                            if (call) {
+                                groupedReferences.functionCalls.push(call);
+                                continue;
+                            }
+                        }
+                        var contextualSymbol = getSymbolForContextualType(entry.node, checker);
+                        if (contextualSymbol && ts.contains(contextualSymbols, contextualSymbol)) {
+                            var decl = entryToDeclaration(entry);
+                            if (decl) {
+                                groupedReferences.declarations.push(decl);
+                                continue;
+                            }
+                        }
                         /* We compare symbols because in some cases find all references wil return a reference that may or may not be to the refactored function.
                         Example from the refactorConvertParamsToDestructuredObject_methodCallUnion.ts test:
                             class A { foo(a: number, b: number) { return a + b; } }
@@ -147071,6 +147113,19 @@ var ts;
                     return symbol && ts.getSymbolTarget(symbol, checker);
                 }
             }
+            /**
+             * Gets the symbol for the contextual type of the node if it is not a union or intersection.
+             */
+            function getSymbolForContextualType(node, checker) {
+                var element = ts.getContainingObjectLiteralElement(node);
+                if (element) {
+                    var contextualType = checker.getContextualTypeForObjectLiteralElement(element);
+                    var symbol = contextualType === null || contextualType === void 0 ? void 0 : contextualType.getSymbol();
+                    if (symbol && !(ts.getCheckFlags(symbol) & 6 /* Synthetic */)) {
+                        return symbol;
+                    }
+                }
+            }
             function entryToImportOrExport(entry) {
                 var node = entry.node;
                 if (ts.isImportSpecifier(node.parent)
@@ -147178,6 +147233,9 @@ var ts;
                 }
                 return false;
             }
+            function isValidMethodSignature(node) {
+                return ts.isMethodSignature(node) && (ts.isInterfaceDeclaration(node.parent) || ts.isTypeLiteralNode(node.parent));
+            }
             function isValidFunctionDeclaration(functionDeclaration, checker) {
                 if (!isValidParameterNodeArray(functionDeclaration.parameters, checker))
                     return false;
@@ -147185,6 +147243,11 @@ var ts;
                     case 251 /* FunctionDeclaration */:
                         return hasNameOrDefault(functionDeclaration) && isSingleImplementation(functionDeclaration, checker);
                     case 165 /* MethodDeclaration */:
+                        if (ts.isObjectLiteralExpression(functionDeclaration.parent)) {
+                            var contextualSymbol = getSymbolForContextualType(functionDeclaration.name, checker);
+                            // don't offer the refactor when there are multiple signatures since we won't know which ones the user wants to change
+                            return (contextualSymbol === null || contextualSymbol === void 0 ? void 0 : contextualSymbol.declarations.length) === 1 && isSingleImplementation(functionDeclaration, checker);
+                        }
                         return isSingleImplementation(functionDeclaration, checker);
                     case 166 /* Constructor */:
                         if (ts.isClassDeclaration(functionDeclaration.parent)) {
@@ -148807,7 +148870,7 @@ var ts;
         };
         CancellationTokenObject.prototype.throwIfCancellationRequested = function () {
             if (this.isCancellationRequested()) {
-                ts.tracing.instant("session" /* Session */, "cancellationThrown", { kind: "CancellationTokenObject" });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "cancellationThrown", { kind: "CancellationTokenObject" });
                 throw new ts.OperationCanceledException();
             }
         };
@@ -148837,7 +148900,7 @@ var ts;
         };
         ThrottledCancellationToken.prototype.throwIfCancellationRequested = function () {
             if (this.isCancellationRequested()) {
-                ts.tracing.instant("session" /* Session */, "cancellationThrown", { kind: "ThrottledCancellationToken" });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "cancellationThrown", { kind: "ThrottledCancellationToken" });
                 throw new ts.OperationCanceledException();
             }
         };
@@ -154424,6 +154487,10 @@ var ts;
             Project.prototype.enablePlugin = function (pluginConfigEntry, searchPaths, pluginConfigOverrides) {
                 var _this = this;
                 this.projectService.logger.info("Enabling plugin " + pluginConfigEntry.name + " from candidate paths: " + searchPaths.join(","));
+                if (!pluginConfigEntry.name || ts.parsePackageName(pluginConfigEntry.name).rest) {
+                    this.projectService.logger.info("Skipped loading plugin " + (pluginConfigEntry.name || JSON.stringify(pluginConfigEntry)) + " because only package name is allowed plugin name");
+                    return;
+                }
                 var log = function (message) { return _this.projectService.logger.info(message); };
                 var errorLogs;
                 var logError = function (message) { (errorLogs || (errorLogs = [])).push(message); };
@@ -158561,24 +158628,24 @@ var ts;
                 try {
                     if (this.operationHost.isCancellationRequested()) {
                         stop = true;
-                        ts.tracing.instant("session" /* Session */, "stepCanceled", { seq: this.requestId, early: true });
+                        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "stepCanceled", { seq: this.requestId, early: true });
                     }
                     else {
-                        ts.tracing.push("session" /* Session */, "stepAction", { seq: this.requestId });
+                        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("session" /* Session */, "stepAction", { seq: this.requestId });
                         action(this);
-                        ts.tracing.pop();
+                        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
                     }
                 }
                 catch (e) {
                     // Cancellation or an error may have left incomplete events on the tracing stack.
-                    ts.tracing.popAll();
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.popAll();
                     stop = true;
                     // ignore cancellation request
                     if (e instanceof ts.OperationCanceledException) {
-                        ts.tracing.instant("session" /* Session */, "stepCanceled", { seq: this.requestId });
+                        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "stepCanceled", { seq: this.requestId });
                     }
                     else {
-                        ts.tracing.instant("session" /* Session */, "stepError", { seq: this.requestId, message: e.message });
+                        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "stepError", { seq: this.requestId, message: e.message });
                         this.operationHost.logError(e, "delayed processing of request " + this.requestId);
                     }
                 }
@@ -159508,7 +159575,7 @@ var ts;
                 this.host.write(msgText);
             };
             Session.prototype.event = function (body, eventName) {
-                ts.tracing.instant("session" /* Session */, "event", { eventName: eventName });
+                ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "event", { eventName: eventName });
                 this.send(toEvent(eventName, body));
             };
             // For backwards-compatibility only.
@@ -160881,11 +160948,11 @@ var ts;
                 try {
                     request = this.parseMessage(message);
                     relevantFile = request.arguments && request.arguments.file ? request.arguments : undefined;
-                    ts.tracing.instant("session" /* Session */, "request", { seq: request.seq, command: request.command });
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "request", { seq: request.seq, command: request.command });
                     ts.perfLogger.logStartCommand("" + request.command, this.toStringMessage(message).substring(0, 100));
-                    ts.tracing.push("session" /* Session */, "executeCommand", { seq: request.seq, command: request.command }, /*separateBeginAndEnd*/ true);
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("session" /* Session */, "executeCommand", { seq: request.seq, command: request.command }, /*separateBeginAndEnd*/ true);
                     var _a = this.executeCommand(request), response = _a.response, responseRequired = _a.responseRequired;
-                    ts.tracing.pop();
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop();
                     if (this.logger.hasLevel(server.LogLevel.requestTime)) {
                         var elapsedTime = hrTimeToMilliseconds(this.hrtime(start)).toFixed(4);
                         if (responseRequired) {
@@ -160897,7 +160964,7 @@ var ts;
                     }
                     // Note: Log before writing the response, else the editor can complete its activity before the server does
                     ts.perfLogger.logStopCommand("" + request.command, "Success");
-                    ts.tracing.instant("session" /* Session */, "response", { seq: request.seq, command: request.command, success: !!response });
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "response", { seq: request.seq, command: request.command, success: !!response });
                     if (response) {
                         this.doOutput(response, request.command, request.seq, /*success*/ true);
                     }
@@ -160907,17 +160974,17 @@ var ts;
                 }
                 catch (err) {
                     // Cancellation or an error may have left incomplete events on the tracing stack.
-                    ts.tracing.popAll();
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.popAll();
                     if (err instanceof ts.OperationCanceledException) {
                         // Handle cancellation exceptions
                         ts.perfLogger.logStopCommand("" + (request && request.command), "Canceled: " + err);
-                        ts.tracing.instant("session" /* Session */, "commandCanceled", { seq: request === null || request === void 0 ? void 0 : request.seq, command: request === null || request === void 0 ? void 0 : request.command });
+                        ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "commandCanceled", { seq: request === null || request === void 0 ? void 0 : request.seq, command: request === null || request === void 0 ? void 0 : request.command });
                         this.doOutput({ canceled: true }, request.command, request.seq, /*success*/ true);
                         return;
                     }
                     this.logErrorWorker(err, this.toStringMessage(message), relevantFile);
                     ts.perfLogger.logStopCommand("" + (request && request.command), "Error: " + err);
-                    ts.tracing.instant("session" /* Session */, "commandError", { seq: request === null || request === void 0 ? void 0 : request.seq, command: request === null || request === void 0 ? void 0 : request.command, message: err.message });
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* Session */, "commandError", { seq: request === null || request === void 0 ? void 0 : request.seq, command: request === null || request === void 0 ? void 0 : request.command, message: err.message });
                     this.doOutput(
                     /*info*/ undefined, request ? request.command : server.CommandNames.Unknown, request ? request.seq : 0, 
                     /*success*/ false, "Error processing request. " + err.message + "\n" + err.stack);
@@ -163538,9 +163605,7 @@ var ts;
                 IOSession.prototype.exit = function () {
                     this.logger.info("Exiting...");
                     this.projectService.closeLog();
-                    if (traceDir) {
-                        ts.tracing.stopTracing(ts.emptyArray);
-                    }
+                    ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.stopTracing(ts.emptyArray);
                     process.exit(0);
                 };
                 IOSession.prototype.listen = function () {
@@ -163567,7 +163632,7 @@ var ts;
                 ? ts.stripQuotes(commandLineTraceDir)
                 : process.env.TSS_TRACE;
             if (traceDir) {
-                ts.tracing.startTracing(2 /* Server */, traceDir);
+                ts.startTracing(2 /* Server */, traceDir);
             }
             var ioSession = new IOSession();
             process.on("uncaughtException", function (err) {