@typescript-deploys/pr-build 5.5.0-pr-55267-86 → 5.5.0-pr-57421-17

package/lib/tsc.js

@@ -15,10 +15,39 @@ and limitations under the License.
 
 
 "use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-insiders.20240302`;
+var version = `${versionMajorMinor}.0-insiders.20240305`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -1215,7 +1244,7 @@ function skipWhile(array, predicate) {
   }
 }
 function isNodeLikeSystem() {
-  return typeof process !== "undefined" && !!process.nextTick && !process.browser && typeof module === "object";
+  return typeof process !== "undefined" && !!process.nextTick && !process.browser && typeof require !== "undefined";
 }
 
 // src/compiler/debug.ts
@@ -4834,7 +4863,7 @@ var sys = (() => {
     }
     let activeSession;
     let profilePath = "./profile.cpuprofile";
-    const Buffer = require("buffer").Buffer;
+    const Buffer2 = require("buffer").Buffer;
     const isMacOs = process.platform === "darwin";
     const isLinuxOrMacOs = process.platform === "linux" || isMacOs;
     const platform = _os.platform();
@@ -5044,7 +5073,7 @@ var sys = (() => {
       }
     }
     function bufferFrom(input, encoding) {
-      return Buffer.from && Buffer.from !== Int8Array.from ? Buffer.from(input, encoding) : new Buffer(input, encoding);
+      return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding);
     }
     function isFileSystemCaseSensitive() {
       if (platform === "win32" || platform === "win64") {
@@ -14622,15 +14651,34 @@ function getSemanticJsxChildren(children) {
 }
 function createDiagnosticCollection() {
   let nonFileDiagnostics = [];
-  const filesWithDiagnostics = [];
-  const fileDiagnostics = /* @__PURE__ */ new Map();
+  let filesWithDiagnostics = [];
+  let fileDiagnostics = /* @__PURE__ */ new Map();
   let hasReadNonFileDiagnostics = false;
   return {
     add,
     lookup,
     getGlobalDiagnostics,
-    getDiagnostics
+    getDiagnostics,
+    checkpoint,
+    revert
   };
+  function checkpoint() {
+    const c = {
+      nonFileDiagnostics: nonFileDiagnostics.slice(),
+      filesWithDiagnostics: filesWithDiagnostics.slice(),
+      fileDiagnostics: new Map(map(arrayFrom(fileDiagnostics.entries()), ([k, v]) => [k, v.slice()])),
+      hasReadNonFileDiagnostics
+    };
+    return c;
+  }
+  function revert(checkpoint2) {
+    ({
+      nonFileDiagnostics,
+      filesWithDiagnostics,
+      fileDiagnostics,
+      hasReadNonFileDiagnostics
+    } = checkpoint2);
+  }
   function lookup(diagnostic) {
     let diagnostics;
     if (diagnostic.file) {
@@ -16236,6 +16284,17 @@ function createCompilerDiagnosticFromMessageChain(chain, relatedInformation) {
     relatedInformation
   };
 }
+function prefixDiagnosticWithMessageChain(base, chain) {
+  if (!chain)
+    return base;
+  concatenateDiagnosticMessageChains(chain, createDiagnosticMessageChainFromDiagnostic(base));
+  return {
+    ...base,
+    code: chain.code,
+    category: chain.category,
+    messageText: chain.next ? chain : chain.messageText
+  };
+}
 function chainDiagnosticMessages(details, message, ...args) {
   let text = getLocaleSpecificMessage(message);
   if (some(args)) {
@@ -43193,11 +43252,226 @@ var intrinsicTypeKinds = new Map(Object.entries({
   Uncapitalize: 3 /* Uncapitalize */,
   NoInfer: 4 /* NoInfer */
 }));
-var SymbolLinks = class {
+var SpeculatableCache = (valueOrTarget, _contextOrPropertyKey, descriptor) => {
+  const baseGet = descriptor ? descriptor.get : valueOrTarget.get;
+  const baseSet = descriptor ? descriptor.set : valueOrTarget.set;
+  return {
+    ...descriptor,
+    get: readValue,
+    set: setValue,
+    init(v) {
+      const epoch = this.host.getCurrentSpeculativeEpoch();
+      const values = [];
+      const writtenEpochs = [epoch];
+      values[epoch] = v;
+      return {
+        values,
+        writtenEpochs
+      };
+    }
+  };
+  function readValue() {
+    const internals = baseGet.call(this);
+    if (!internals)
+      return void 0;
+    const {
+      values,
+      writtenEpochs
+    } = internals;
+    const discardedSpeculativeEpochs = this.host.getDiscardedSpeculativeEpochs();
+    const hostEpoch = this instanceof SymbolLinks ? this.symbolEpoch : 0;
+    const symbolDiscarded = discardedSpeculativeEpochs.has(hostEpoch);
+    for (let i = writtenEpochs.length - 1; i >= 0; i--) {
+      if (!symbolDiscarded && discardedSpeculativeEpochs.has(writtenEpochs[i])) {
+        delete values[writtenEpochs[i]];
+        writtenEpochs.splice(i, 1);
+        continue;
+      }
+      return values[writtenEpochs[i]];
+    }
+    return void 0;
+  }
+  function setValue(value) {
+    const internals = baseGet.call(this);
+    const currentSpeculativeEpoch = this.host.getCurrentSpeculativeEpoch();
+    if (!internals) {
+      const values2 = [];
+      const writtenEpochs2 = [];
+      writtenEpochs2.push(currentSpeculativeEpoch);
+      values2[currentSpeculativeEpoch] = value;
+      baseSet.call(this, { values: values2, writtenEpochs: writtenEpochs2 });
+      return value;
+    }
+    const {
+      values,
+      writtenEpochs
+    } = internals;
+    writtenEpochs.push(currentSpeculativeEpoch);
+    values[currentSpeculativeEpoch] = value;
+    return value;
+  }
 };
-function NodeLinks() {
-  this.flags = 0 /* None */;
-}
+var SpeculatableLinks = class {
+  constructor(host) {
+    this.host = host;
+  }
+};
+var _type, _writeType, _nameType;
+var SymbolLinks = class extends SpeculatableLinks {
+  constructor(host, symbolEpoch = 0) {
+    super(host);
+    this.symbolEpoch = symbolEpoch;
+    __privateAdd(this, _type, void 0);
+    __privateAdd(this, _writeType, void 0);
+    __privateAdd(this, _nameType, void 0);
+  }
+  get type() {
+    return __privateGet(this, _type);
+  }
+  set type(_) {
+    __privateSet(this, _type, _);
+  }
+  get writeType() {
+    return __privateGet(this, _writeType);
+  }
+  set writeType(_) {
+    __privateSet(this, _writeType, _);
+  }
+  get nameType() {
+    return __privateGet(this, _nameType);
+  }
+  set nameType(_) {
+    __privateSet(this, _nameType, _);
+  }
+};
+_type = new WeakMap();
+_writeType = new WeakMap();
+_nameType = new WeakMap();
+__decorateClass([
+  SpeculatableCache
+], SymbolLinks.prototype, "type", 1);
+__decorateClass([
+  SpeculatableCache
+], SymbolLinks.prototype, "writeType", 1);
+__decorateClass([
+  SpeculatableCache
+], SymbolLinks.prototype, "nameType", 1);
+var _flags, _resolvedType, _resolvedEnumType, _resolvedSignature, _resolvedSymbol, _resolvedIndexInfo, _effectsSignature, _switchTypes, _contextFreeType, _assertionExpressionType;
+var NodeLinks = class extends SpeculatableLinks {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _flags, 0 /* None */);
+    __privateAdd(this, _resolvedType, void 0);
+    __privateAdd(this, _resolvedEnumType, void 0);
+    __privateAdd(this, _resolvedSignature, void 0);
+    __privateAdd(this, _resolvedSymbol, void 0);
+    __privateAdd(this, _resolvedIndexInfo, void 0);
+    __privateAdd(this, _effectsSignature, void 0);
+    __privateAdd(this, _switchTypes, void 0);
+    __privateAdd(this, _contextFreeType, void 0);
+    __privateAdd(this, _assertionExpressionType, void 0);
+  }
+  get flags() {
+    return __privateGet(this, _flags);
+  }
+  set flags(_) {
+    __privateSet(this, _flags, _);
+  }
+  get resolvedType() {
+    return __privateGet(this, _resolvedType);
+  }
+  set resolvedType(_) {
+    __privateSet(this, _resolvedType, _);
+  }
+  get resolvedEnumType() {
+    return __privateGet(this, _resolvedEnumType);
+  }
+  set resolvedEnumType(_) {
+    __privateSet(this, _resolvedEnumType, _);
+  }
+  get resolvedSignature() {
+    return __privateGet(this, _resolvedSignature);
+  }
+  set resolvedSignature(_) {
+    __privateSet(this, _resolvedSignature, _);
+  }
+  get resolvedSymbol() {
+    return __privateGet(this, _resolvedSymbol);
+  }
+  set resolvedSymbol(_) {
+    __privateSet(this, _resolvedSymbol, _);
+  }
+  get resolvedIndexInfo() {
+    return __privateGet(this, _resolvedIndexInfo);
+  }
+  set resolvedIndexInfo(_) {
+    __privateSet(this, _resolvedIndexInfo, _);
+  }
+  get effectsSignature() {
+    return __privateGet(this, _effectsSignature);
+  }
+  set effectsSignature(_) {
+    __privateSet(this, _effectsSignature, _);
+  }
+  get switchTypes() {
+    return __privateGet(this, _switchTypes);
+  }
+  set switchTypes(_) {
+    __privateSet(this, _switchTypes, _);
+  }
+  get contextFreeType() {
+    return __privateGet(this, _contextFreeType);
+  }
+  set contextFreeType(_) {
+    __privateSet(this, _contextFreeType, _);
+  }
+  get assertionExpressionType() {
+    return __privateGet(this, _assertionExpressionType);
+  }
+  set assertionExpressionType(_) {
+    __privateSet(this, _assertionExpressionType, _);
+  }
+};
+_flags = new WeakMap();
+_resolvedType = new WeakMap();
+_resolvedEnumType = new WeakMap();
+_resolvedSignature = new WeakMap();
+_resolvedSymbol = new WeakMap();
+_resolvedIndexInfo = new WeakMap();
+_effectsSignature = new WeakMap();
+_switchTypes = new WeakMap();
+_contextFreeType = new WeakMap();
+_assertionExpressionType = new WeakMap();
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "flags", 1);
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "resolvedType", 1);
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "resolvedEnumType", 1);
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "resolvedSignature", 1);
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "resolvedSymbol", 1);
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "resolvedIndexInfo", 1);
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "effectsSignature", 1);
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "switchTypes", 1);
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "contextFreeType", 1);
+__decorateClass([
+  SpeculatableCache
+], NodeLinks.prototype, "assertionExpressionType", 1);
 function getNodeId(node) {
   if (!node.id) {
     node.id = nextNodeId;
@@ -43217,7 +43491,18 @@ function isInstantiatedModule(node, preserveConstEnums) {
   return moduleState === 1 /* Instantiated */ || preserveConstEnums && moduleState === 2 /* ConstEnumOnly */;
 }
 function createTypeChecker(host) {
-  var deferredDiagnosticsCallbacks = [];
+  var speculativeCaches = [];
+  var currentSpeculativeEpoch = 0;
+  var discardedSpeculativeEpochs = /* @__PURE__ */ new Set();
+  var speculationHost = {
+    getCurrentSpeculativeEpoch() {
+      return currentSpeculativeEpoch;
+    },
+    getDiscardedSpeculativeEpochs() {
+      return discardedSpeculativeEpochs;
+    }
+  };
+  var deferredDiagnosticsCallbacks = registerSpeculativeCache([]);
   var addLazyDiagnostic = (arg) => {
     deferredDiagnosticsCallbacks.push(arg);
   };
@@ -44153,12 +44438,12 @@ function createTypeChecker(host) {
   var mergedSymbols = [];
   var symbolLinks = [];
   var nodeLinks = [];
-  var flowLoopCaches = [];
-  var flowLoopNodes = [];
-  var flowLoopKeys = [];
-  var flowLoopTypes = [];
-  var sharedFlowNodes = [];
-  var sharedFlowTypes = [];
+  var flowLoopCaches = registerSpeculativeCache([]);
+  var flowLoopNodes = registerSpeculativeCache([]);
+  var flowLoopKeys = registerSpeculativeCache([]);
+  var flowLoopTypes = registerSpeculativeCache([]);
+  var sharedFlowNodes = registerSpeculativeCache([]);
+  var sharedFlowTypes = registerSpeculativeCache([]);
   var flowNodeReachable = [];
   var flowNodePostSuper = [];
   var potentialThisCollisions = [];
@@ -44167,17 +44452,17 @@ function createTypeChecker(host) {
   var potentialReflectCollisions = [];
   var potentialUnusedRenamedBindingElementsInTypes = [];
   var awaitedTypeStack = [];
-  var diagnostics = createDiagnosticCollection();
-  var suggestionDiagnostics = createDiagnosticCollection();
+  var diagnostics = registerSpeculativeCache(createDiagnosticCollection());
+  var suggestionDiagnostics = registerSpeculativeCache(createDiagnosticCollection());
   var typeofType = createTypeofType();
   var _jsxNamespace;
   var _jsxFactoryEntity;
-  var subtypeRelation = /* @__PURE__ */ new Map();
-  var strictSubtypeRelation = /* @__PURE__ */ new Map();
-  var assignableRelation = /* @__PURE__ */ new Map();
-  var comparableRelation = /* @__PURE__ */ new Map();
-  var identityRelation = /* @__PURE__ */ new Map();
-  var enumRelation = /* @__PURE__ */ new Map();
+  var subtypeRelation = registerSpeculativeCache(/* @__PURE__ */ new Map());
+  var strictSubtypeRelation = registerSpeculativeCache(/* @__PURE__ */ new Map());
+  var assignableRelation = registerSpeculativeCache(/* @__PURE__ */ new Map());
+  var comparableRelation = registerSpeculativeCache(/* @__PURE__ */ new Map());
+  var identityRelation = registerSpeculativeCache(/* @__PURE__ */ new Map());
+  var enumRelation = registerSpeculativeCache(/* @__PURE__ */ new Map());
   var builtinGlobals = createSymbolTable();
   builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
   var suggestedExtensions = [
@@ -44356,7 +44641,8 @@ function createTypeChecker(host) {
   function createSymbol(flags, name, checkFlags) {
     symbolCount++;
     const symbol = new Symbol12(flags | 33554432 /* Transient */, name);
-    symbol.links = new SymbolLinks();
+    symbol.epoch = currentSpeculativeEpoch;
+    symbol.links = new SymbolLinks(speculationHost, symbol.epoch);
     symbol.links.checkFlags = checkFlags || 0 /* None */;
     return symbol;
   }
@@ -44614,11 +44900,11 @@ function createTypeChecker(host) {
     if (symbol.flags & 33554432 /* Transient */)
       return symbol.links;
     const id = getSymbolId(symbol);
-    return symbolLinks[id] ?? (symbolLinks[id] = new SymbolLinks());
+    return symbolLinks[id] ?? (symbolLinks[id] = new SymbolLinks(speculationHost));
   }
   function getNodeLinks(node) {
     const nodeId = getNodeId(node);
-    return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
+    return nodeLinks[nodeId] ?? (nodeLinks[nodeId] = new NodeLinks(speculationHost));
   }
   function isGlobalSourceFile(node) {
     return node.kind === 307 /* SourceFile */ && !isExternalOrCommonJsModule(node);
@@ -54514,10 +54800,11 @@ function createTypeChecker(host) {
     const modifiers = getMappedTypeModifiers(type);
     return modifiers & 8 /* ExcludeOptional */ ? -1 : modifiers & 4 /* IncludeOptional */ ? 1 : 0;
   }
+  function getModifiersTypeOptionality(type) {
+    return type.flags & 2097152 /* Intersection */ ? Math.max(...map(type.types, getModifiersTypeOptionality)) : getObjectFlags(type) & 32 /* Mapped */ ? getCombinedMappedTypeOptionality(type) : 0;
+  }
   function getCombinedMappedTypeOptionality(type) {
-    const optionality = getMappedTypeOptionality(type);
-    const modifiersType = getModifiersTypeFromMappedType(type);
-    return optionality || (isGenericMappedType(modifiersType) ? getMappedTypeOptionality(modifiersType) : 0);
+    return getMappedTypeOptionality(type) || getModifiersTypeOptionality(getModifiersTypeFromMappedType(type));
   }
   function isPartialMappedType(type) {
     return !!(getObjectFlags(type) & 32 /* Mapped */ && getMappedTypeModifiers(type) & 4 /* IncludeOptional */);
@@ -58282,7 +58569,13 @@ function createTypeChecker(host) {
   function substituteIndexedMappedType(objectType, index) {
     const mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
     const templateMapper = combineTypeMappers(objectType.mapper, mapper);
-    return instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
+    const instantiatedTemplateType = instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
+    return addOptionality(
+      instantiatedTemplateType,
+      /*isProperty*/
+      true,
+      getCombinedMappedTypeOptionality(objectType) > 0
+    );
   }
   function getIndexedAccessType(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
     return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
@@ -59193,7 +59486,7 @@ function createTypeChecker(host) {
   function getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
     const declaration = type.objectFlags & 4 /* Reference */ ? type.node : type.objectFlags & 8388608 /* InstantiationExpressionType */ ? type.node : type.symbol.declarations[0];
     const links = getNodeLinks(declaration);
-    const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
+    const target = type.objectFlags & 4 /* Reference */ ? getTypeFromTypeNode(declaration) : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
     let typeParameters = links.outerTypeParameters;
     if (!typeParameters) {
       let outerTypeParameters = getOuterTypeParameters(
@@ -71687,8 +71980,8 @@ function createTypeChecker(host) {
     Debug.assert(candidates.length, "Revert #54442 and add a testcase with whatever triggered this");
     const args = getEffectiveCallArguments(node);
     const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
-    let argCheckMode = !isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */;
     let candidatesForArgumentError;
+    let candidateArgumentErrors;
     let candidateForArgumentArityError;
     let candidateForTypeArgumentError;
     let result;
@@ -71719,18 +72012,10 @@ function createTypeChecker(host) {
           if (headMessage) {
             chain = chainDiagnosticMessages(chain, headMessage);
           }
-          const diags = getSignatureApplicabilityError(
-            node,
-            args,
-            last2,
-            assignableRelation,
-            0 /* Normal */,
-            /*reportErrors*/
-            true,
-            () => chain
-          );
+          const diags = candidateArgumentErrors[candidateArgumentErrors.length - 1];
           if (diags) {
-            for (const d of diags) {
+            for (let d of diags) {
+              d = prefixDiagnosticWithMessageChain(d, chain);
               if (last2.declaration && candidatesForArgumentError.length > 3) {
                 addRelatedInfo(d, createDiagnosticForNode(last2.declaration, Diagnostics.The_last_overload_is_declared_here));
               }
@@ -71755,23 +72040,14 @@ function createTypeChecker(host) {
               candidates.length,
               signatureToString(c)
             );
-            const diags2 = getSignatureApplicabilityError(
-              node,
-              args,
-              c,
-              assignableRelation,
-              0 /* Normal */,
-              /*reportErrors*/
-              true,
-              chain2
-            );
+            const diags2 = candidateArgumentErrors[i];
             if (diags2) {
               if (diags2.length <= min2) {
                 min2 = diags2.length;
                 minIndex = i;
               }
               max = Math.max(max, diags2.length);
-              allDiagnostics.push(diags2);
+              allDiagnostics.push(map(diags2, (d) => prefixDiagnosticWithMessageChain(d, chain2())));
             } else {
               Debug.fail("No error for 3 or fewer overload signatures");
             }
@@ -71820,6 +72096,7 @@ function createTypeChecker(host) {
     function addImplementationSuccessElaboration(failed, diagnostic) {
       var _a, _b;
       const oldCandidatesForArgumentError = candidatesForArgumentError;
+      const oldCandidateArgumentErrors = candidateArgumentErrors;
       const oldCandidateForArgumentArityError = candidateForArgumentArityError;
       const oldCandidateForTypeArgumentError = candidateForTypeArgumentError;
       const failedSignatureDeclarations = ((_b = (_a = failed.declaration) == null ? void 0 : _a.symbol) == null ? void 0 : _b.declarations) || emptyArray;
@@ -71833,11 +72110,13 @@ function createTypeChecker(host) {
         }
       }
       candidatesForArgumentError = oldCandidatesForArgumentError;
+      candidateArgumentErrors = oldCandidateArgumentErrors;
       candidateForArgumentArityError = oldCandidateForArgumentArityError;
       candidateForTypeArgumentError = oldCandidateForTypeArgumentError;
     }
     function chooseOverload(candidates2, relation, isSingleNonGenericCandidate2, signatureHelpTrailingComma2 = false) {
       candidatesForArgumentError = void 0;
+      candidateArgumentErrors = void 0;
       candidateForArgumentArityError = void 0;
       candidateForTypeArgumentError = void 0;
       if (isSingleNonGenericCandidate2) {
@@ -71845,101 +72124,113 @@ function createTypeChecker(host) {
         if (some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
           return void 0;
         }
-        if (getSignatureApplicabilityError(
+        let diags;
+        if (diags = getSignatureApplicabilityError(
           node,
           args,
           candidate,
           relation,
           0 /* Normal */,
           /*reportErrors*/
-          false,
+          relation === assignableRelation,
           /*containingMessageChain*/
           void 0
         )) {
           candidatesForArgumentError = [candidate];
+          candidateArgumentErrors = [diags];
           return void 0;
         }
         return candidate;
       }
+      const initialCheckMode = !isDecorator2 && !isSingleNonGenericCandidate2 && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */;
       for (let candidateIndex = 0; candidateIndex < candidates2.length; candidateIndex++) {
         const candidate = candidates2[candidateIndex];
         if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
           continue;
         }
-        let checkCandidate;
-        let inferenceContext;
-        if (candidate.typeParameters) {
-          let typeArgumentTypes;
-          if (some(typeArguments)) {
-            typeArgumentTypes = checkTypeArguments(
-              candidate,
-              typeArguments,
-              /*reportErrors*/
-              false
-            );
-            if (!typeArgumentTypes) {
-              candidateForTypeArgumentError = candidate;
-              continue;
+        const result2 = speculate(() => {
+          let argCheckMode = initialCheckMode;
+          let checkCandidate;
+          let inferenceContext;
+          if (candidate.typeParameters) {
+            let typeArgumentTypes;
+            if (some(typeArguments)) {
+              typeArgumentTypes = checkTypeArguments(
+                candidate,
+                typeArguments,
+                /*reportErrors*/
+                false
+              );
+              if (!typeArgumentTypes) {
+                candidateForTypeArgumentError = candidate;
+                return false;
+              }
+            } else {
+              inferenceContext = createInferenceContext(
+                candidate.typeParameters,
+                candidate,
+                /*flags*/
+                isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
+              );
+              typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
+              argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
             }
-          } else {
-            inferenceContext = createInferenceContext(
-              candidate.typeParameters,
-              candidate,
-              /*flags*/
-              isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
-            );
-            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
-            argCheckMode |= inferenceContext.flags & 4 /* SkippedGenericFunction */ ? 8 /* SkipGenericFunctions */ : 0 /* Normal */;
-          }
-          checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
-          if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
-            candidateForArgumentArityError = checkCandidate;
-            continue;
-          }
-        } else {
-          checkCandidate = candidate;
-        }
-        if (getSignatureApplicabilityError(
-          node,
-          args,
-          checkCandidate,
-          relation,
-          argCheckMode,
-          /*reportErrors*/
-          false,
-          /*containingMessageChain*/
-          void 0
-        )) {
-          (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
-          continue;
-        }
-        if (argCheckMode) {
-          argCheckMode = 0 /* Normal */;
-          if (inferenceContext) {
-            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
-            checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
+            checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
             if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
               candidateForArgumentArityError = checkCandidate;
-              continue;
+              return false;
             }
+          } else {
+            checkCandidate = candidate;
           }
-          if (getSignatureApplicabilityError(
+          let diags;
+          if (diags = getSignatureApplicabilityError(
             node,
             args,
             checkCandidate,
             relation,
             argCheckMode,
             /*reportErrors*/
-            false,
+            relation === assignableRelation,
             /*containingMessageChain*/
             void 0
           )) {
             (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
-            continue;
+            (candidateArgumentErrors || (candidateArgumentErrors = [])).push(diags);
+            return false;
           }
+          if (argCheckMode) {
+            argCheckMode = 0 /* Normal */;
+            if (inferenceContext) {
+              const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
+              checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
+              if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
+                candidateForArgumentArityError = checkCandidate;
+                return false;
+              }
+            }
+            if (diags = getSignatureApplicabilityError(
+              node,
+              args,
+              checkCandidate,
+              relation,
+              argCheckMode,
+              /*reportErrors*/
+              relation === assignableRelation,
+              /*containingMessageChain*/
+              void 0
+            )) {
+              (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
+              (candidateArgumentErrors || (candidateArgumentErrors = [])).push(diags);
+              return false;
+            }
+          }
+          candidates2[candidateIndex] = checkCandidate;
+          return checkCandidate;
+        });
+        if (result2) {
+          return result2;
         }
-        candidates2[candidateIndex] = checkCandidate;
-        return checkCandidate;
       }
       return void 0;
     }
@@ -83125,6 +83416,78 @@ function createTypeChecker(host) {
     }
     return getDeclarationOfKind(moduleSymbol, 307 /* SourceFile */);
   }
+  function speculate(cb) {
+    currentSpeculativeEpoch++;
+    const startEpoch = currentSpeculativeEpoch;
+    const initialState = snapshotCheckerState();
+    const result = cb();
+    const endEpoch = currentSpeculativeEpoch;
+    currentSpeculativeEpoch++;
+    if (!result) {
+      for (let i = startEpoch; i <= endEpoch; i++) {
+        discardedSpeculativeEpochs.add(i);
+      }
+      restoreCheckerState(initialState);
+      return void 0;
+    }
+    return result;
+  }
+  function registerSpeculativeCache(collection) {
+    speculativeCaches.push(collection);
+    return collection;
+  }
+  function snapshotCheckerState() {
+    const state = { restores: map(speculativeCaches, save) };
+    return state;
+    function save(cache) {
+      if (Array.isArray(cache)) {
+        return saveArray(cache);
+      } else if (cache instanceof Map) {
+        return saveMap(cache);
+      } else if (cache instanceof Set) {
+        return saveSet(cache);
+      } else if (cache.add && cache.getDiagnostics) {
+        return saveDiagnosticCollection(cache);
+      }
+      return Debug.fail("Unknown speculative cache type");
+    }
+    function saveArray(cache) {
+      const original = cache.slice();
+      return () => {
+        cache.length = 0;
+        cache.push(...original);
+      };
+    }
+    function saveMap(cache) {
+      const original = arrayFrom(cache.entries());
+      return () => {
+        cache.clear();
+        for (const [k, v] of original) {
+          cache.set(k, v);
+        }
+      };
+    }
+    function saveSet(cache) {
+      const original = arrayFrom(cache.entries());
+      return () => {
+        cache.clear();
+        for (const [_, v] of original) {
+          cache.add(v);
+        }
+      };
+    }
+    function saveDiagnosticCollection(cache) {
+      const c = cache.checkpoint();
+      return () => {
+        cache.revert(c);
+      };
+    }
+  }
+  function restoreCheckerState(state) {
+    for (const restore of state.restores) {
+      restore();
+    }
+  }
   function initializeTypeChecker() {
     for (const file of host.getSourceFiles()) {
       bindSourceFile(file, compilerOptions);