@typescript-deploys/pr-build 5.5.0-pr-57421-17 → 5.5.0-pr-57403-34

package/lib/tsc.js

@@ -15,35 +15,6 @@ 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";
@@ -3721,6 +3692,7 @@ var ObjectFlags = /* @__PURE__ */ ((ObjectFlags3) => {
   ObjectFlags3[ObjectFlags3["ContainsSpread"] = 2097152] = "ContainsSpread";
   ObjectFlags3[ObjectFlags3["ObjectRestType"] = 4194304] = "ObjectRestType";
   ObjectFlags3[ObjectFlags3["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType";
+  ObjectFlags3[ObjectFlags3["SingleSignatureType"] = 134217728] = "SingleSignatureType";
   ObjectFlags3[ObjectFlags3["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated";
   ObjectFlags3[ObjectFlags3["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists";
@@ -4863,7 +4835,7 @@ var sys = (() => {
     }
     let activeSession;
     let profilePath = "./profile.cpuprofile";
-    const Buffer2 = require("buffer").Buffer;
+    const Buffer = require("buffer").Buffer;
     const isMacOs = process.platform === "darwin";
     const isLinuxOrMacOs = process.platform === "linux" || isMacOs;
     const platform = _os.platform();
@@ -5073,7 +5045,7 @@ var sys = (() => {
       }
     }
     function bufferFrom(input, encoding) {
-      return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding);
+      return Buffer.from && Buffer.from !== Int8Array.from ? Buffer.from(input, encoding) : new Buffer(input, encoding);
     }
     function isFileSystemCaseSensitive() {
       if (platform === "win32" || platform === "win64") {
@@ -14651,34 +14623,15 @@ function getSemanticJsxChildren(children) {
 }
 function createDiagnosticCollection() {
   let nonFileDiagnostics = [];
-  let filesWithDiagnostics = [];
-  let fileDiagnostics = /* @__PURE__ */ new Map();
+  const filesWithDiagnostics = [];
+  const fileDiagnostics = /* @__PURE__ */ new Map();
   let hasReadNonFileDiagnostics = false;
   return {
     add,
     lookup,
     getGlobalDiagnostics,
-    getDiagnostics,
-    checkpoint,
-    revert
+    getDiagnostics
   };
-  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) {
@@ -16284,17 +16237,6 @@ 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)) {
@@ -43252,226 +43194,11 @@ var intrinsicTypeKinds = new Map(Object.entries({
   Uncapitalize: 3 /* Uncapitalize */,
   NoInfer: 4 /* NoInfer */
 }));
-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;
-  }
+var SymbolLinks = class {
 };
-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 NodeLinks() {
+  this.flags = 0 /* None */;
+}
 function getNodeId(node) {
   if (!node.id) {
     node.id = nextNodeId;
@@ -43491,18 +43218,7 @@ function isInstantiatedModule(node, preserveConstEnums) {
   return moduleState === 1 /* Instantiated */ || preserveConstEnums && moduleState === 2 /* ConstEnumOnly */;
 }
 function createTypeChecker(host) {
-  var speculativeCaches = [];
-  var currentSpeculativeEpoch = 0;
-  var discardedSpeculativeEpochs = /* @__PURE__ */ new Set();
-  var speculationHost = {
-    getCurrentSpeculativeEpoch() {
-      return currentSpeculativeEpoch;
-    },
-    getDiscardedSpeculativeEpochs() {
-      return discardedSpeculativeEpochs;
-    }
-  };
-  var deferredDiagnosticsCallbacks = registerSpeculativeCache([]);
+  var deferredDiagnosticsCallbacks = [];
   var addLazyDiagnostic = (arg) => {
     deferredDiagnosticsCallbacks.push(arg);
   };
@@ -44438,12 +44154,12 @@ function createTypeChecker(host) {
   var mergedSymbols = [];
   var symbolLinks = [];
   var nodeLinks = [];
-  var flowLoopCaches = registerSpeculativeCache([]);
-  var flowLoopNodes = registerSpeculativeCache([]);
-  var flowLoopKeys = registerSpeculativeCache([]);
-  var flowLoopTypes = registerSpeculativeCache([]);
-  var sharedFlowNodes = registerSpeculativeCache([]);
-  var sharedFlowTypes = registerSpeculativeCache([]);
+  var flowLoopCaches = [];
+  var flowLoopNodes = [];
+  var flowLoopKeys = [];
+  var flowLoopTypes = [];
+  var sharedFlowNodes = [];
+  var sharedFlowTypes = [];
   var flowNodeReachable = [];
   var flowNodePostSuper = [];
   var potentialThisCollisions = [];
@@ -44452,17 +44168,17 @@ function createTypeChecker(host) {
   var potentialReflectCollisions = [];
   var potentialUnusedRenamedBindingElementsInTypes = [];
   var awaitedTypeStack = [];
-  var diagnostics = registerSpeculativeCache(createDiagnosticCollection());
-  var suggestionDiagnostics = registerSpeculativeCache(createDiagnosticCollection());
+  var diagnostics = createDiagnosticCollection();
+  var suggestionDiagnostics = createDiagnosticCollection();
   var typeofType = createTypeofType();
   var _jsxNamespace;
   var _jsxFactoryEntity;
-  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 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 builtinGlobals = createSymbolTable();
   builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
   var suggestedExtensions = [
@@ -44641,8 +44357,7 @@ function createTypeChecker(host) {
   function createSymbol(flags, name, checkFlags) {
     symbolCount++;
     const symbol = new Symbol12(flags | 33554432 /* Transient */, name);
-    symbol.epoch = currentSpeculativeEpoch;
-    symbol.links = new SymbolLinks(speculationHost, symbol.epoch);
+    symbol.links = new SymbolLinks();
     symbol.links.checkFlags = checkFlags || 0 /* None */;
     return symbol;
   }
@@ -44900,11 +44615,11 @@ function createTypeChecker(host) {
     if (symbol.flags & 33554432 /* Transient */)
       return symbol.links;
     const id = getSymbolId(symbol);
-    return symbolLinks[id] ?? (symbolLinks[id] = new SymbolLinks(speculationHost));
+    return symbolLinks[id] ?? (symbolLinks[id] = new SymbolLinks());
   }
   function getNodeLinks(node) {
     const nodeId = getNodeId(node);
-    return nodeLinks[nodeId] ?? (nodeLinks[nodeId] = new NodeLinks(speculationHost));
+    return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks());
   }
   function isGlobalSourceFile(node) {
     return node.kind === 307 /* SourceFile */ && !isExternalOrCommonJsModule(node);
@@ -48663,7 +48378,7 @@ function createTypeChecker(host) {
         }
         const abstractSignatures = filter(resolved.constructSignatures, (signature) => !!(signature.flags & 4 /* Abstract */));
         if (some(abstractSignatures)) {
-          const types = map(abstractSignatures, getOrCreateTypeFromSignature);
+          const types = map(abstractSignatures, (s) => getOrCreateTypeFromSignature(s));
           const typeElementCount = resolved.callSignatures.length + (resolved.constructSignatures.length - abstractSignatures.length) + resolved.indexInfos.length + // exclude `prototype` when writing a class expression as a type literal, as per
           // the logic in `createTypeNodesFromResolvedType`.
           (context.flags & 2048 /* WriteClassExpressionAsTypeLiteral */ ? countWhere(resolved.properties, (p) => !(p.flags & 4194304 /* Prototype */)) : length(resolved.properties));
@@ -56064,6 +55779,12 @@ function createTypeChecker(host) {
       isInJSFile(signature.declaration)
     );
   }
+  function getImplementationSignature(signature) {
+    return signature.typeParameters ? signature.implementationSignatureCache || (signature.implementationSignatureCache = createImplementationSignature(signature)) : signature;
+  }
+  function createImplementationSignature(signature) {
+    return signature.typeParameters ? instantiateSignature(signature, createTypeMapper([], [])) : signature;
+  }
   function getBaseSignature(signature) {
     const typeParameters = signature.typeParameters;
     if (typeParameters) {
@@ -56086,12 +55807,22 @@ function createTypeChecker(host) {
     }
     return signature;
   }
-  function getOrCreateTypeFromSignature(signature) {
+  function getOrCreateTypeFromSignature(signature, outerTypeParameters) {
     var _a;
     if (!signature.isolatedSignatureType) {
       const kind = (_a = signature.declaration) == null ? void 0 : _a.kind;
       const isConstructor = kind === void 0 || kind === 176 /* Constructor */ || kind === 180 /* ConstructSignature */ || kind === 185 /* ConstructorType */;
-      const type = createObjectType(16 /* Anonymous */);
+      const type = createObjectType(16 /* Anonymous */ | 134217728 /* SingleSignatureType */, createSymbol(16 /* Function */, "__function" /* Function */));
+      if (signature.declaration && !nodeIsSynthesized(signature.declaration)) {
+        type.symbol.declarations = [signature.declaration];
+        type.symbol.valueDeclaration = signature.declaration;
+      }
+      outerTypeParameters || (outerTypeParameters = signature.declaration && getOuterTypeParameters(
+        signature.declaration,
+        /*includeThisTypes*/
+        true
+      ));
+      type.outerTypeParameters = outerTypeParameters;
       type.members = emptySymbols;
       type.properties = emptyArray;
       type.callSignatures = !isConstructor ? [signature] : emptyArray;
@@ -59486,8 +59217,8 @@ 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 */ ? getTypeFromTypeNode(declaration) : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
-    let typeParameters = links.outerTypeParameters;
+    const target = type.objectFlags & 4 /* Reference */ ? links.resolvedType : type.objectFlags & 64 /* Instantiated */ ? type.target : type;
+    let typeParameters = type.objectFlags & 134217728 /* SingleSignatureType */ ? type.outerTypeParameters : links.outerTypeParameters;
     if (!typeParameters) {
       let outerTypeParameters = getOuterTypeParameters(
         declaration,
@@ -59668,6 +59399,9 @@ function createTypeChecker(host) {
     if (type.objectFlags & 8388608 /* InstantiationExpressionType */) {
       result.node = type.node;
     }
+    if (type.objectFlags & 134217728 /* SingleSignatureType */) {
+      result.outerTypeParameters = type.outerTypeParameters;
+    }
     result.target = type;
     result.mapper = mapper;
     result.aliasSymbol = aliasSymbol || type.aliasSymbol;
@@ -64288,7 +64022,7 @@ function createTypeChecker(host) {
     if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
       return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
     }
-    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
+    const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 134217728 /* SingleSignatureType */ && !!length(type.outerTypeParameters) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
     if (type.flags & 3899393 /* ObjectFlagsType */) {
       type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
     }
@@ -64570,6 +64304,9 @@ function createTypeChecker(host) {
       pos = p;
     }
   }
+  function isTupleOfSelf(typeParameter, type) {
+    return isTupleType(type) && getTupleElementType(type, 0) === getIndexedAccessType(typeParameter, getNumberLiteralType(0)) && !getTypeOfPropertyOfType(type, "1");
+  }
   function inferTypes(inferences, originalSource, originalTarget, priority = 0 /* None */, contravariant = false) {
     let bivariant = false;
     let propagationType;
@@ -64655,6 +64392,9 @@ function createTypeChecker(host) {
               inference.priority = priority;
             }
             if (priority === inference.priority) {
+              if (isTupleOfSelf(inference.typeParameter, candidate)) {
+                return;
+              }
               if (contravariant && !bivariant) {
                 if (!contains(inference.contraCandidates, candidate)) {
                   inference.contraCandidates = append(inference.contraCandidates, candidate);
@@ -71577,7 +71317,7 @@ function createTypeChecker(host) {
     argument = skipParentheses(argument);
     return isSatisfiesExpression(argument) ? skipParentheses(argument.expression) : argument;
   }
-  function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain) {
+  function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors2, containingMessageChain, inferenceContext) {
     const errorOutputContainer = { errors: void 0, skipLogging: true };
     if (isJsxOpeningLikeElement(node)) {
       if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors2, containingMessageChain, errorOutputContainer)) {
@@ -71611,7 +71351,8 @@ function createTypeChecker(host) {
           void 0,
           checkMode
         );
-        const checkArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
+        const regularArgType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType;
+        const checkArgType = inferenceContext ? instantiateType(regularArgType, inferenceContext.nonFixingMapper) : regularArgType;
         const effectiveCheckArgumentNode = getEffectiveCheckNode(arg);
         if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors2 ? effectiveCheckArgumentNode : void 0, effectiveCheckArgumentNode, headMessage, containingMessageChain, errorOutputContainer)) {
           Debug.assert(!reportErrors2 || !!errorOutputContainer.errors, "parameter should have errors when reporting errors");
@@ -71980,8 +71721,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;
@@ -72012,10 +71753,20 @@ function createTypeChecker(host) {
           if (headMessage) {
             chain = chainDiagnosticMessages(chain, headMessage);
           }
-          const diags = candidateArgumentErrors[candidateArgumentErrors.length - 1];
+          const diags = getSignatureApplicabilityError(
+            node,
+            args,
+            last2,
+            assignableRelation,
+            0 /* Normal */,
+            /*reportErrors*/
+            true,
+            () => chain,
+            /*inferenceContext*/
+            void 0
+          );
           if (diags) {
-            for (let d of diags) {
-              d = prefixDiagnosticWithMessageChain(d, chain);
+            for (const d of diags) {
               if (last2.declaration && candidatesForArgumentError.length > 3) {
                 addRelatedInfo(d, createDiagnosticForNode(last2.declaration, Diagnostics.The_last_overload_is_declared_here));
               }
@@ -72040,14 +71791,25 @@ function createTypeChecker(host) {
               candidates.length,
               signatureToString(c)
             );
-            const diags2 = candidateArgumentErrors[i];
+            const diags2 = getSignatureApplicabilityError(
+              node,
+              args,
+              c,
+              assignableRelation,
+              0 /* Normal */,
+              /*reportErrors*/
+              true,
+              chain2,
+              /*inferenceContext*/
+              void 0
+            );
             if (diags2) {
               if (diags2.length <= min2) {
                 min2 = diags2.length;
                 minIndex = i;
               }
               max = Math.max(max, diags2.length);
-              allDiagnostics.push(map(diags2, (d) => prefixDiagnosticWithMessageChain(d, chain2())));
+              allDiagnostics.push(diags2);
             } else {
               Debug.fail("No error for 3 or fewer overload signatures");
             }
@@ -72096,7 +71858,6 @@ 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;
@@ -72110,13 +71871,11 @@ 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) {
@@ -72124,113 +71883,108 @@ function createTypeChecker(host) {
         if (some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
           return void 0;
         }
-        let diags;
-        if (diags = getSignatureApplicabilityError(
+        if (getSignatureApplicabilityError(
           node,
           args,
           candidate,
           relation,
           0 /* Normal */,
           /*reportErrors*/
-          relation === assignableRelation,
+          false,
           /*containingMessageChain*/
+          void 0,
+          /*inferenceContext*/
           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];
+        let candidate = candidates2[candidateIndex];
         if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma2)) {
           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 */;
+        let checkCandidate;
+        let inferenceContext;
+        if (candidate.typeParameters) {
+          if (candidate.declaration && findAncestor(node, (a) => a === candidate.declaration)) {
+            candidate = getImplementationSignature(candidate);
+          }
+          let typeArgumentTypes;
+          if (some(typeArguments)) {
+            typeArgumentTypes = checkTypeArguments(
+              candidate,
+              typeArguments,
+              /*reportErrors*/
+              false
+            );
+            if (!typeArgumentTypes) {
+              candidateForTypeArgumentError = candidate;
+              continue;
             }
-            checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters);
+          } else {
+            inferenceContext = createInferenceContext(
+              candidate.typeParameters,
+              candidate,
+              /*flags*/
+              isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
+            );
+            typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext), inferenceContext.nonFixingMapper);
+            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,
+          inferenceContext
+        )) {
+          (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
+          continue;
+        }
+        if (argCheckMode) {
+          argCheckMode = 0 /* Normal */;
+          if (inferenceContext) {
+            const typeArgumentTypes = instantiateTypes(inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext), inferenceContext.mapper);
+            checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
             if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma2)) {
               candidateForArgumentArityError = checkCandidate;
-              return false;
+              continue;
             }
-          } else {
-            checkCandidate = candidate;
           }
-          let diags;
-          if (diags = getSignatureApplicabilityError(
+          if (getSignatureApplicabilityError(
             node,
             args,
             checkCandidate,
             relation,
             argCheckMode,
             /*reportErrors*/
-            relation === assignableRelation,
+            false,
             /*containingMessageChain*/
-            void 0
+            void 0,
+            inferenceContext
           )) {
             (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
-            (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;
-            }
+            continue;
           }
-          candidates2[candidateIndex] = checkCandidate;
-          return checkCandidate;
-        });
-        if (result2) {
-          return result2;
         }
+        candidates2[candidateIndex] = checkCandidate;
+        return checkCandidate;
       }
       return void 0;
     }
@@ -75920,7 +75674,7 @@ function createTypeChecker(host) {
                 }
               }
             }
-            return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context));
+            return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context), flatMap(inferenceContexts, (c) => c && map(c.inferences, (i) => i.typeParameter)).slice());
           }
         }
       }
@@ -83416,78 +83170,6 @@ 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);