typescript 5.5.0-dev.20240327 → 5.5.0-dev.20240329

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240327`;
+var version = `${versionMajorMinor}.0-dev.20240329`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -3699,6 +3699,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";
@@ -17697,6 +17698,91 @@ function isSyntacticallyString(expr) {
   }
   return false;
 }
+function createEvaluator({ evaluateElementAccessExpression, evaluateEntityNameExpression }) {
+  function evaluate(expr, location) {
+    switch (expr.kind) {
+      case 224 /* PrefixUnaryExpression */:
+        const value = evaluate(expr.operand, location);
+        if (typeof value === "number") {
+          switch (expr.operator) {
+            case 40 /* PlusToken */:
+              return value;
+            case 41 /* MinusToken */:
+              return -value;
+            case 55 /* TildeToken */:
+              return ~value;
+          }
+        }
+        break;
+      case 226 /* BinaryExpression */:
+        const left = evaluate(expr.left, location);
+        const right = evaluate(expr.right, location);
+        if (typeof left === "number" && typeof right === "number") {
+          switch (expr.operatorToken.kind) {
+            case 52 /* BarToken */:
+              return left | right;
+            case 51 /* AmpersandToken */:
+              return left & right;
+            case 49 /* GreaterThanGreaterThanToken */:
+              return left >> right;
+            case 50 /* GreaterThanGreaterThanGreaterThanToken */:
+              return left >>> right;
+            case 48 /* LessThanLessThanToken */:
+              return left << right;
+            case 53 /* CaretToken */:
+              return left ^ right;
+            case 42 /* AsteriskToken */:
+              return left * right;
+            case 44 /* SlashToken */:
+              return left / right;
+            case 40 /* PlusToken */:
+              return left + right;
+            case 41 /* MinusToken */:
+              return left - right;
+            case 45 /* PercentToken */:
+              return left % right;
+            case 43 /* AsteriskAsteriskToken */:
+              return left ** right;
+          }
+        } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
+          return "" + left + right;
+        }
+        break;
+      case 11 /* StringLiteral */:
+      case 15 /* NoSubstitutionTemplateLiteral */:
+        return expr.text;
+      case 228 /* TemplateExpression */:
+        return evaluateTemplateExpression(expr, location);
+      case 9 /* NumericLiteral */:
+        return +expr.text;
+      case 217 /* ParenthesizedExpression */:
+        return evaluate(expr.expression, location);
+      case 80 /* Identifier */:
+        return evaluateEntityNameExpression(expr, location);
+      case 211 /* PropertyAccessExpression */:
+        if (isEntityNameExpression(expr)) {
+          return evaluateEntityNameExpression(expr, location);
+        }
+        break;
+      case 212 /* ElementAccessExpression */:
+        return evaluateElementAccessExpression(expr, location);
+    }
+    return void 0;
+  }
+  function evaluateTemplateExpression(expr, location) {
+    let result = expr.head.text;
+    for (const span of expr.templateSpans) {
+      const value = evaluate(span.expression, location);
+      if (value === void 0) {
+        return void 0;
+      }
+      result += value;
+      result += span.literal.text;
+    }
+    return result;
+  }
+  return evaluate;
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -42598,13 +42684,21 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
     }
     const nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, getDirectoryPath(modulePath));
     const nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
-    if (nearestSourcePackageJson !== nearestTargetPackageJson) {
+    const ignoreCase = !hostUsesCaseSensitiveFileNames(host);
+    if (!packageJsonPathsAreEqual(nearestTargetPackageJson, nearestSourcePackageJson, ignoreCase)) {
       return maybeNonRelative;
     }
     return relativePath;
   }
   return isPathRelativeToParent(maybeNonRelative) || countPathComponents(relativePath) < countPathComponents(maybeNonRelative) ? relativePath : maybeNonRelative;
 }
+function packageJsonPathsAreEqual(a, b, ignoreCase) {
+  if (a === b)
+    return true;
+  if (a === void 0 || b === void 0)
+    return false;
+  return comparePaths(a, b, ignoreCase) === 0 /* EqualTo */;
+}
 function countPathComponents(path) {
   let count = 0;
   for (let i = startsWith(path, "./") ? 2 : 0; i < path.length; i++) {
@@ -43370,6 +43464,10 @@ function createTypeChecker(host) {
   var checkBinaryExpression = createCheckBinaryExpression();
   var emitResolver = createResolver();
   var nodeBuilder = createNodeBuilder();
+  var evaluate = createEvaluator({
+    evaluateElementAccessExpression,
+    evaluateEntityNameExpression
+  });
   var globals = createSymbolTable();
   var undefinedSymbol = createSymbol(4 /* Property */, "undefined");
   undefinedSymbol.declarations = [];
@@ -47868,17 +47966,8 @@ function createTypeChecker(host) {
       typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
       typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
       expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(
-        context,
-        type,
-        symbol,
-        enclosingDeclaration,
-        /*includePrivateSymbol*/
-        void 0,
-        /*bundled*/
-        void 0,
-        addUndefined
-      )),
+      serializeTypeForDeclaration: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
       indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
@@ -47897,7 +47986,7 @@ function createTypeChecker(host) {
       symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
       symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
       typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker, bundled) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context, bundled)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
       symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
@@ -47915,12 +48004,12 @@ function createTypeChecker(host) {
       }
       return typeToTypeNodeHelper(type, context);
     }
-    function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined, includePrivateSymbol, bundled) {
+    function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined) {
       const originalType = type;
       if (addUndefined) {
         type = getOptionalType(type);
       }
-      const clone = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2, includePrivateSymbol, bundled);
+      const clone = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2);
       if (clone) {
         if (addUndefined && !someType(getTypeFromTypeNode(typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
           return factory.createUnionTypeNode([clone, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
@@ -47928,16 +48017,16 @@ function createTypeChecker(host) {
         return clone;
       }
       if (addUndefined && originalType !== type) {
-        const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2, includePrivateSymbol, bundled);
+        const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2);
         if (cloneMissingUndefined) {
           return factory.createUnionTypeNode([cloneMissingUndefined, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
         }
       }
       return void 0;
     }
-    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, includePrivateSymbol, bundled, annotationType) {
+    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, annotationType) {
       if (typeNodeIsEquivalentToType(existing, host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
-        const result = tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled);
+        const result = tryReuseExistingTypeNodeHelper(context, existing);
         if (result) {
           return result;
         }
@@ -47972,7 +48061,8 @@ function createTypeChecker(host) {
         symbolDepth: void 0,
         inferTypeParameters: void 0,
         approximateLength: 0,
-        trackedSymbols: void 0
+        trackedSymbols: void 0,
+        bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration))
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -48540,7 +48630,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));
@@ -48963,9 +49053,8 @@ function createTypeChecker(host) {
     }
     function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
       var _a;
-      const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
-      if (suppressAny)
-        context.flags &= ~256 /* SuppressAnyReturnType */;
+      const flags = context.flags;
+      context.flags &= ~256 /* SuppressAnyReturnType */;
       context.approximateLength += 3;
       let typeParameters;
       let typeArguments;
@@ -49041,27 +49130,17 @@ function createTypeChecker(host) {
           );
         }
       }
-      const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports));
+      const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
         parameters.unshift(thisParameter);
       }
-      let returnTypeNode;
-      const typePredicate = getTypePredicateOfSignature(signature);
-      if (typePredicate) {
-        returnTypeNode = typePredicateToTypePredicateNodeHelper(typePredicate, context);
-      } else {
-        const returnType = getReturnTypeOfSignature(signature);
-        if (returnType && !(suppressAny && isTypeAny(returnType))) {
-          returnTypeNode = serializeReturnTypeForSignature(context, returnType, signature, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports);
-        } else if (!suppressAny) {
-          returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
-        }
-      }
+      context.flags = flags;
+      const returnTypeNode = serializeReturnTypeForSignature(context, signature);
       let modifiers = options == null ? void 0 : options.modifiers;
       if (kind === 185 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
-        const flags = modifiersToFlags(modifiers);
-        modifiers = factory.createModifiersFromModifierFlags(flags | 64 /* Abstract */);
+        const flags2 = modifiersToFlags(modifiers);
+        modifiers = factory.createModifiersFromModifierFlags(flags2 | 64 /* Abstract */);
       }
       const node = kind === 179 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 180 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 173 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (options == null ? void 0 : options.name) ?? factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 174 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
@@ -49190,11 +49269,11 @@ function createTypeChecker(host) {
         return getDeclarationOfKind(parameterSymbol, 341 /* JSDocParameterTag */);
       }
     }
-    function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
+    function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags) {
       const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
       const parameterType = getTypeOfSymbol(parameterSymbol);
       const addUndefined = parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration);
-      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports, addUndefined);
+      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, addUndefined);
       const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
       const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
       const dotDotDotToken = isRest ? factory.createToken(26 /* DotDotDotToken */) : void 0;
@@ -49763,7 +49842,7 @@ function createTypeChecker(host) {
       return initial;
     }
     function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
-      return symbol.declarations && find(symbol.declarations, (s) => !!getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
+      return symbol.declarations && find(symbol.declarations, (s) => !!getNonlocalEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
     }
     function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
       return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
@@ -49774,13 +49853,13 @@ function createTypeChecker(host) {
       }
       return enclosingDeclaration;
     }
-    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled, addUndefined) {
+    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined) {
       var _a;
       if (!isErrorType(type) && enclosingDeclaration) {
         const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
-          const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
-          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined, includePrivateSymbol, bundled);
+          const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
+          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
           if (result2) {
             return result2;
           }
@@ -49805,22 +49884,43 @@ function createTypeChecker(host) {
       }
       return false;
     }
-    function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
+    function serializeReturnTypeForSignature(context, signature) {
+      const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
+      const flags = context.flags;
+      if (suppressAny)
+        context.flags &= ~256 /* SuppressAnyReturnType */;
+      let returnTypeNode;
+      const returnType = getReturnTypeOfSignature(signature);
+      if (returnType && !(suppressAny && isTypeAny(returnType))) {
+        returnTypeNode = serializeReturnTypeForSignatureWorker(context, signature);
+      } else if (!suppressAny) {
+        returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
+      }
+      context.flags = flags;
+      return returnTypeNode;
+    }
+    function serializeReturnTypeForSignatureWorker(context, signature) {
+      const typePredicate = getTypePredicateOfSignature(signature);
+      const type = getReturnTypeOfSignature(signature);
       if (!isErrorType(type) && context.enclosingDeclaration) {
-        const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
+        const annotation = signature.declaration && getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
         const enclosingDeclarationIgnoringFakeScope = getEnclosingDeclarationIgnoringFakeScope(context.enclosingDeclaration);
         if (!!findAncestor(annotation, (n) => n === enclosingDeclarationIgnoringFakeScope) && annotation) {
           const annotated = getTypeFromTypeNode(annotation);
           const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
-          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, includePrivateSymbol, bundled, thisInstantiated);
+          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, thisInstantiated);
           if (result) {
             return result;
           }
         }
       }
-      return typeToTypeNodeHelper(type, context);
+      if (typePredicate) {
+        return typePredicateToTypePredicateNodeHelper(typePredicate, context);
+      }
+      const expr = signature.declaration && getPossibleTypeNodeReuseExpression(signature.declaration);
+      return expressionOrTypeToTypeNode(context, expr, type);
     }
-    function trackExistingEntityName(node, context, includePrivateSymbol) {
+    function trackExistingEntityName(node, context) {
       let introducesError = false;
       const leftmost = getFirstIdentifier(node);
       if (isInJSFile(node) && (isExportsIdentifier(leftmost) || isModuleExportsAccessExpression(leftmost.parent) || isQualifiedName(leftmost.parent) && isModuleIdentifier(leftmost.parent.left) && isExportsIdentifier(leftmost.parent.right))) {
@@ -49849,23 +49949,21 @@ function createTypeChecker(host) {
           }
         } else {
           context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
-          includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
         }
         if (isIdentifier(node)) {
           const type = getDeclaredTypeOfSymbol(sym);
           const name = sym.flags & 262144 /* TypeParameter */ ? typeParameterToName(type, context) : factory.cloneNode(node);
           name.symbol = sym;
-          return { introducesError, node: setEmitFlags(setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */) };
+          return { introducesError, node: setTextRange(setEmitFlags(setOriginalNode(name, node), 16777216 /* NoAsciiEscaping */), node) };
         }
       }
       return { introducesError, node };
     }
-    function tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled) {
+    function tryReuseExistingTypeNodeHelper(context, existing) {
       if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
         cancellationToken.throwIfCancellationRequested();
       }
       let hadError = false;
-      const file = getSourceFileOfNode(existing);
       const transformed = visitNode(existing, visitExistingNodeTreeSymbols, isTypeNode);
       if (hadError) {
         return void 0;
@@ -49984,40 +50082,43 @@ function createTypeChecker(host) {
             node.isTypeOf
           );
         }
-        if (isParameter(node)) {
-          if (!node.type && !node.initializer) {
-            return factory.updateParameterDeclaration(
-              node,
-              /*modifiers*/
-              void 0,
-              node.dotDotDotToken,
-              visitEachChild(
-                node.name,
-                visitExistingNodeTreeSymbols,
-                /*context*/
-                void 0
-              ),
-              node.questionToken,
-              factory.createKeywordTypeNode(133 /* AnyKeyword */),
-              /*initializer*/
-              void 0
-            );
-          }
+        if (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !isLateBindableName(node.name)) {
+          return void 0;
         }
-        if (isPropertySignature(node)) {
-          if (!node.type && !node.initializer) {
-            return factory.updatePropertySignature(node, node.modifiers, node.name, node.questionToken, factory.createKeywordTypeNode(133 /* AnyKeyword */));
+        if (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) {
+          let visited = visitEachChild(
+            node,
+            visitExistingNodeTreeSymbols,
+            /*context*/
+            void 0
+          );
+          if (visited === node) {
+            visited = setTextRange(factory.cloneNode(node), node);
+          }
+          visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */);
+          if (isParameter(node)) {
+            visited.modifiers = void 0;
           }
+          return visited;
         }
         if (isEntityName(node) || isEntityNameExpression(node)) {
-          const { introducesError, node: result } = trackExistingEntityName(node, context, includePrivateSymbol);
+          const { introducesError, node: result } = trackExistingEntityName(node, context);
           hadError = hadError || introducesError;
           if (result !== node) {
             return result;
           }
         }
-        if (file && isTupleTypeNode(node) && !nodeIsSynthesized(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
-          setEmitFlags(node, 1 /* SingleLine */);
+        if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
+          const visited = visitEachChild(
+            node,
+            visitExistingNodeTreeSymbols,
+            /*context*/
+            void 0
+          );
+          const clone = setTextRange(visited === node ? factory.cloneNode(node) : visited, node);
+          const flags = getEmitFlags(clone);
+          setEmitFlags(clone, flags | (context.flags & 1024 /* MultilineObjectLiterals */ && isTypeLiteralNode(node) ? 0 : 1 /* SingleLine */));
+          return clone;
         }
         return visitEachChild(
           node,
@@ -50032,7 +50133,7 @@ function createTypeChecker(host) {
           return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
         }
         function rewriteModuleSpecifier(parent, lit) {
-          if (bundled) {
+          if (context.bundled) {
             if (context.tracker && context.tracker.moduleResolverHost) {
               const targetFile = getExternalModuleFileFromDeclaration(parent);
               if (targetFile) {
@@ -50051,7 +50152,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    function symbolTableToDeclarationStatements(symbolTable, context, bundled) {
+    function symbolTableToDeclarationStatements(symbolTable, context) {
       var _a;
       const serializePropertySymbolForClass = makeSerializePropertySymbol(
         factory.createPropertyDeclaration,
@@ -50110,7 +50211,7 @@ function createTypeChecker(host) {
         const baseName = unescapeLeadingUnderscores(name);
         void getInternalSymbolName(symbol, baseName);
       });
-      let addingDeclare = !bundled;
+      let addingDeclare = !context.bundled;
       const exportEquals = symbolTable.get("export=" /* ExportEquals */);
       if (exportEquals && symbolTable.size > 1 && exportEquals.flags & (2097152 /* Alias */ | 1536 /* Module */)) {
         symbolTable = createSymbolTable();
@@ -50391,7 +50492,7 @@ function createTypeChecker(host) {
                         name,
                         /*exclamationToken*/
                         void 0,
-                        serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled)
+                        serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration)
                       )
                     ], flags)
                   ),
@@ -50533,9 +50634,7 @@ function createTypeChecker(host) {
           jsdocAliasDecl.typeExpression.type,
           aliasType,
           /*host*/
-          void 0,
-          includePrivateSymbol,
-          bundled
+          void 0
         ) || typeToTypeNodeHelper(aliasType, context);
         addResult(
           setSyntheticLeadingComments(
@@ -50665,7 +50764,7 @@ function createTypeChecker(host) {
       function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) {
         const signatures = getSignaturesOfType(type, 0 /* Call */);
         for (const sig of signatures) {
-          const decl = signatureToSignatureDeclarationHelper(sig, 262 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName), privateSymbolVisitor: includePrivateSymbol, bundledImports: bundled });
+          const decl = signatureToSignatureDeclarationHelper(sig, 262 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName) });
           addResult(setTextRange(decl, getSignatureTextRangeLocation(sig)), modifierFlags);
         }
         if (!(symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && !!symbol.exports && !!symbol.exports.size)) {
@@ -50759,7 +50858,7 @@ function createTypeChecker(host) {
               );
             }
             let introducesError;
-            ({ introducesError, node: expr } = trackExistingEntityName(expr, context, includePrivateSymbol));
+            ({ introducesError, node: expr } = trackExistingEntityName(expr, context));
             if (introducesError) {
               return cleanup(
                 /*result*/
@@ -50769,15 +50868,7 @@ function createTypeChecker(host) {
           }
           return cleanup(factory.createExpressionWithTypeArguments(
             expr,
-            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(
-              context,
-              a,
-              getTypeFromTypeNode(a),
-              /*host*/
-              void 0,
-              includePrivateSymbol,
-              bundled
-            ) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
+            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(context, a, getTypeFromTypeNode(a)) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
           ));
           function cleanup(result2) {
             context.enclosingDeclaration = oldEnclosing;
@@ -51002,7 +51093,7 @@ function createTypeChecker(host) {
             break;
           case 273 /* ImportClause */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
-            const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.moduleSpecifier;
+            const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.moduleSpecifier;
             const attributes = isImportDeclaration(node.parent) ? node.parent.attributes : void 0;
             const isTypeOnly = isJSDocImportTag(node.parent);
             addResult(
@@ -51024,7 +51115,7 @@ function createTypeChecker(host) {
           }
           case 274 /* NamespaceImport */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
-            const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.moduleSpecifier;
+            const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.moduleSpecifier;
             const isTypeOnly = isJSDocImportTag(node.parent.parent);
             addResult(
               factory.createImportDeclaration(
@@ -51058,7 +51149,7 @@ function createTypeChecker(host) {
             break;
           case 276 /* ImportSpecifier */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
-            const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.parent.moduleSpecifier;
+            const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.parent.moduleSpecifier;
             const isTypeOnly = isJSDocImportTag(node.parent.parent.parent);
             addResult(
               factory.createImportDeclaration(
@@ -51212,7 +51303,7 @@ function createTypeChecker(host) {
                   varName,
                   /*exclamationToken*/
                   void 0,
-                  serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration, includePrivateSymbol, bundled)
+                  serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration)
                 )
               ], flags)
             );
@@ -51296,7 +51387,7 @@ function createTypeChecker(host) {
                     paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
                     /*questionToken*/
                     void 0,
-                    isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled)
+                    isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration)
                   )],
                   /*body*/
                   void 0
@@ -51311,7 +51402,7 @@ function createTypeChecker(host) {
                   factory.createModifiersFromModifierFlags(flag),
                   name,
                   [],
-                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
+                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration),
                   /*body*/
                   void 0
                 ),
@@ -51325,7 +51416,7 @@ function createTypeChecker(host) {
                 factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                 name,
                 p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
-                isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
+                isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration),
                 // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357
                 // interface members can't have initializers, however class members _can_
                 /*initializer*/
@@ -54697,11 +54788,15 @@ 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) {
-    return getMappedTypeOptionality(type) || getModifiersTypeOptionality(getModifiersTypeFromMappedType(type));
+    if (getObjectFlags(type) & 32 /* Mapped */) {
+      return getMappedTypeOptionality(type) || getCombinedMappedTypeOptionality(getModifiersTypeFromMappedType(type));
+    }
+    if (type.flags & 2097152 /* Intersection */) {
+      const optionality = getCombinedMappedTypeOptionality(type.types[0]);
+      return every(type.types, (t, i) => i === 0 || getCombinedMappedTypeOptionality(t) === optionality) ? optionality : 0;
+    }
+    return 0;
   }
   function isPartialMappedType(type) {
     return !!(getObjectFlags(type) & 32 /* Mapped */ && getMappedTypeModifiers(type) & 4 /* IncludeOptional */);
@@ -55978,6 +56073,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) {
@@ -56000,12 +56101,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;
@@ -58494,13 +58605,18 @@ function createTypeChecker(host) {
     const mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]);
     const templateMapper = combineTypeMappers(objectType.mapper, mapper);
     const instantiatedTemplateType = instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper);
+    const isOptional = getMappedTypeOptionality(objectType) > 0 || (isGenericType(objectType) ? getCombinedMappedTypeOptionality(getModifiersTypeFromMappedType(objectType)) > 0 : couldAccessOptionalProperty(objectType, index));
     return addOptionality(
       instantiatedTemplateType,
       /*isProperty*/
       true,
-      getCombinedMappedTypeOptionality(objectType) > 0
+      isOptional
     );
   }
+  function couldAccessOptionalProperty(objectType, indexType) {
+    const indexConstraint = getBaseConstraintOfType(indexType);
+    return !!indexConstraint && some(getPropertiesOfType(objectType), (p) => !!(p.flags & 16777216 /* Optional */) && isTypeAssignableTo(getLiteralTypeFromProperty(p, 8576 /* StringOrNumberLiteralOrUnique */), indexConstraint));
+  }
   function getIndexedAccessType(objectType, indexType, accessFlags = 0 /* None */, accessNode, aliasSymbol, aliasTypeArguments) {
     return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
   }
@@ -59411,7 +59527,7 @@ function createTypeChecker(host) {
     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;
-    let typeParameters = links.outerTypeParameters;
+    let typeParameters = type.objectFlags & 134217728 /* SingleSignatureType */ ? type.outerTypeParameters : links.outerTypeParameters;
     if (!typeParameters) {
       let outerTypeParameters = getOuterTypeParameters(
         declaration,
@@ -59591,6 +59707,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;
@@ -64222,7 +64341,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);
     }
@@ -64506,6 +64625,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;
@@ -64591,6 +64713,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);
@@ -71529,7 +71654,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)) {
@@ -71563,7 +71688,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");
@@ -71975,7 +72101,9 @@ function createTypeChecker(host) {
             0 /* Normal */,
             /*reportErrors*/
             true,
-            () => chain
+            () => chain,
+            /*inferenceContext*/
+            void 0
           );
           if (diags) {
             for (const d of diags) {
@@ -72011,7 +72139,9 @@ function createTypeChecker(host) {
               0 /* Normal */,
               /*reportErrors*/
               true,
-              chain2
+              chain2,
+              /*inferenceContext*/
+              void 0
             );
             if (diags2) {
               if (diags2.length <= min2) {
@@ -72102,6 +72232,8 @@ function createTypeChecker(host) {
           /*reportErrors*/
           false,
           /*containingMessageChain*/
+          void 0,
+          /*inferenceContext*/
           void 0
         )) {
           candidatesForArgumentError = [candidate];
@@ -72110,13 +72242,16 @@ function createTypeChecker(host) {
         return candidate;
       }
       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;
         }
         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(
@@ -72136,7 +72271,7 @@ function createTypeChecker(host) {
               /*flags*/
               isInJSFile(node) ? 2 /* AnyDefault */ : 0 /* None */
             );
-            typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* SkipGenericFunctions */, inferenceContext);
+            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);
@@ -72156,7 +72291,8 @@ function createTypeChecker(host) {
           /*reportErrors*/
           false,
           /*containingMessageChain*/
-          void 0
+          void 0,
+          inferenceContext
         )) {
           (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
           continue;
@@ -72164,7 +72300,7 @@ function createTypeChecker(host) {
         if (argCheckMode) {
           argCheckMode = 0 /* Normal */;
           if (inferenceContext) {
-            const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, 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;
@@ -72180,7 +72316,8 @@ function createTypeChecker(host) {
             /*reportErrors*/
             false,
             /*containingMessageChain*/
-            void 0
+            void 0,
+            inferenceContext
           )) {
             (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate);
             continue;
@@ -75720,7 +75857,7 @@ function createTypeChecker(host) {
     ) || unknownType, isTemplateLiteralContextualType)) {
       return getTemplateLiteralType(texts, types);
     }
-    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluateTemplateExpression(node);
+    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node);
     return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
   }
   function isTemplateLiteralContextualType(type) {
@@ -75934,7 +76071,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());
           }
         }
       }
@@ -76109,7 +76246,8 @@ function createTypeChecker(host) {
     if (getIsolatedModules(compilerOptions)) {
       Debug.assert(!!(type.symbol.flags & 128 /* ConstEnum */));
       const constEnumDeclaration = type.symbol.valueDeclaration;
-      if (constEnumDeclaration.flags & 33554432 /* Ambient */ && !isValidTypeOnlyAliasUseSite(node)) {
+      const redirect = host.getRedirectReferenceForResolutionFromSourceOfProject(getSourceFileOfNode(constEnumDeclaration).resolvedPath);
+      if (constEnumDeclaration.flags & 33554432 /* Ambient */ && !isValidTypeOnlyAliasUseSite(node) && (!redirect || !shouldPreserveConstEnums(redirect.commandLine.options))) {
         error(node, Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled, isolatedModulesLikeFlagName);
       }
     }
@@ -80696,122 +80834,53 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function evaluate(expr, location) {
-    switch (expr.kind) {
-      case 224 /* PrefixUnaryExpression */:
-        const value = evaluate(expr.operand, location);
-        if (typeof value === "number") {
-          switch (expr.operator) {
-            case 40 /* PlusToken */:
-              return value;
-            case 41 /* MinusToken */:
-              return -value;
-            case 55 /* TildeToken */:
-              return ~value;
-          }
-        }
-        break;
-      case 226 /* BinaryExpression */:
-        const left = evaluate(expr.left, location);
-        const right = evaluate(expr.right, location);
-        if (typeof left === "number" && typeof right === "number") {
-          switch (expr.operatorToken.kind) {
-            case 52 /* BarToken */:
-              return left | right;
-            case 51 /* AmpersandToken */:
-              return left & right;
-            case 49 /* GreaterThanGreaterThanToken */:
-              return left >> right;
-            case 50 /* GreaterThanGreaterThanGreaterThanToken */:
-              return left >>> right;
-            case 48 /* LessThanLessThanToken */:
-              return left << right;
-            case 53 /* CaretToken */:
-              return left ^ right;
-            case 42 /* AsteriskToken */:
-              return left * right;
-            case 44 /* SlashToken */:
-              return left / right;
-            case 40 /* PlusToken */:
-              return left + right;
-            case 41 /* MinusToken */:
-              return left - right;
-            case 45 /* PercentToken */:
-              return left % right;
-            case 43 /* AsteriskAsteriskToken */:
-              return left ** right;
-          }
-        } else if ((typeof left === "string" || typeof left === "number") && (typeof right === "string" || typeof right === "number") && expr.operatorToken.kind === 40 /* PlusToken */) {
-          return "" + left + right;
-        }
-        break;
-      case 11 /* StringLiteral */:
-      case 15 /* NoSubstitutionTemplateLiteral */:
-        return expr.text;
-      case 228 /* TemplateExpression */:
-        return evaluateTemplateExpression(expr, location);
-      case 9 /* NumericLiteral */:
-        checkGrammarNumericLiteral(expr);
-        return +expr.text;
-      case 217 /* ParenthesizedExpression */:
-        return evaluate(expr.expression, location);
-      case 80 /* Identifier */: {
-        const identifier = expr;
-        if (isInfinityOrNaNString(identifier.escapedText) && resolveEntityName(
-          identifier,
-          111551 /* Value */,
-          /*ignoreErrors*/
-          true
-        ) === getGlobalSymbol(
-          identifier.escapedText,
-          111551 /* Value */,
-          /*diagnostic*/
-          void 0
-        )) {
-          return +identifier.escapedText;
-        }
+  function evaluateEntityNameExpression(expr, location) {
+    const symbol = resolveEntityName(
+      expr,
+      111551 /* Value */,
+      /*ignoreErrors*/
+      true
+    );
+    if (!symbol)
+      return void 0;
+    if (expr.kind === 80 /* Identifier */) {
+      const identifier = expr;
+      if (isInfinityOrNaNString(identifier.escapedText) && symbol === getGlobalSymbol(
+        identifier.escapedText,
+        111551 /* Value */,
+        /*diagnostic*/
+        void 0
+      )) {
+        return +identifier.escapedText;
       }
-      case 211 /* PropertyAccessExpression */:
-        if (isEntityNameExpression(expr)) {
-          const symbol = resolveEntityName(
-            expr,
-            111551 /* Value */,
-            /*ignoreErrors*/
-            true
-          );
-          if (symbol) {
-            if (symbol.flags & 8 /* EnumMember */) {
-              return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
-            }
-            if (isConstantVariable(symbol)) {
-              const declaration = symbol.valueDeclaration;
-              if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
-                return evaluate(declaration.initializer, declaration);
-              }
-            }
-          }
-        }
-        break;
-      case 212 /* ElementAccessExpression */:
-        const root = expr.expression;
-        if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
-          const rootSymbol = resolveEntityName(
-            root,
-            111551 /* Value */,
-            /*ignoreErrors*/
-            true
-          );
-          if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
-            const name = escapeLeadingUnderscores(expr.argumentExpression.text);
-            const member = rootSymbol.exports.get(name);
-            if (member) {
-              return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
-            }
-          }
+    }
+    if (symbol.flags & 8 /* EnumMember */) {
+      return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
+    }
+    if (isConstantVariable(symbol)) {
+      const declaration = symbol.valueDeclaration;
+      if (declaration && isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
+        return evaluate(declaration.initializer, declaration);
+      }
+    }
+  }
+  function evaluateElementAccessExpression(expr, location) {
+    const root = expr.expression;
+    if (isEntityNameExpression(root) && isStringLiteralLike(expr.argumentExpression)) {
+      const rootSymbol = resolveEntityName(
+        root,
+        111551 /* Value */,
+        /*ignoreErrors*/
+        true
+      );
+      if (rootSymbol && rootSymbol.flags & 384 /* Enum */) {
+        const name = escapeLeadingUnderscores(expr.argumentExpression.text);
+        const member = rootSymbol.exports.get(name);
+        if (member) {
+          return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
         }
-        break;
+      }
     }
-    return void 0;
   }
   function evaluateEnumMember(expr, symbol, location) {
     const declaration = symbol.valueDeclaration;
@@ -80825,18 +80894,6 @@ function createTypeChecker(host) {
     }
     return getEnumMemberValue(declaration);
   }
-  function evaluateTemplateExpression(expr, location) {
-    let result = expr.head.text;
-    for (const span of expr.templateSpans) {
-      const value = evaluate(span.expression, location);
-      if (value === void 0) {
-        return void 0;
-      }
-      result += value;
-      result += span.literal.text;
-    }
-    return result;
-  }
   function checkEnumDeclaration(node) {
     addLazyDiagnostic(() => checkEnumDeclarationWorker(node));
   }
@@ -83103,9 +83160,23 @@ function createTypeChecker(host) {
   function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
     return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
   }
+  function getAllAccessorDeclarationsForDeclaration(accessor) {
+    accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration);
+    const otherKind = accessor.kind === 178 /* SetAccessor */ ? 177 /* GetAccessor */ : 178 /* SetAccessor */;
+    const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(accessor), otherKind);
+    const firstAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? otherAccessor : accessor;
+    const secondAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? accessor : otherAccessor;
+    const setAccessor = accessor.kind === 178 /* SetAccessor */ ? accessor : otherAccessor;
+    const getAccessor = accessor.kind === 177 /* GetAccessor */ ? accessor : otherAccessor;
+    return {
+      firstAccessor,
+      secondAccessor,
+      setAccessor,
+      getAccessor
+    };
+  }
   function getPossibleTypeNodeReuseExpression(declaration) {
-    var _a;
-    return isFunctionLike(declaration) && !isSetAccessor(declaration) ? getSingleReturnExpression(declaration) : isExportAssignment(declaration) ? declaration.expression : !!declaration.initializer ? declaration.initializer : isParameter(declaration) && isSetAccessor(declaration.parent) ? getSingleReturnExpression(getAllAccessorDeclarations((_a = getSymbolOfDeclaration(declaration.parent)) == null ? void 0 : _a.declarations, declaration.parent).getAccessor) : void 0;
+    return isFunctionLike(declaration) && !isSetAccessor(declaration) ? getSingleReturnExpression(declaration) : isExportAssignment(declaration) ? declaration.expression : !!declaration.initializer ? declaration.initializer : isParameter(declaration) && isSetAccessor(declaration.parent) ? getSingleReturnExpression(getAllAccessorDeclarationsForDeclaration(declaration.parent).getAccessor) : void 0;
   }
   function getSingleReturnExpression(declaration) {
     let candidateExpr;
@@ -83131,20 +83202,7 @@ function createTypeChecker(host) {
     if (!signatureDeclaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
-    const signature = getSignatureFromDeclaration(signatureDeclaration);
-    const typePredicate = getTypePredicateOfSignature(signature);
-    if (typePredicate) {
-      return nodeBuilder.typePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
-    }
-    return nodeBuilder.expressionOrTypeToTypeNode(
-      getPossibleTypeNodeReuseExpression(signatureDeclaration),
-      getReturnTypeOfSignature(signature),
-      /*addUndefined*/
-      void 0,
-      enclosingDeclaration,
-      flags | 1024 /* MultilineObjectLiterals */,
-      tracker
-    );
+    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
   }
   function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
@@ -83303,6 +83361,35 @@ function createTypeChecker(host) {
       return parseIsolatedEntityName(compilerOptions.jsxFragmentFactory, languageVersion);
     }
   }
+  function getNonlocalEffectiveTypeAnnotationNode(node) {
+    const direct = getEffectiveTypeAnnotationNode(node);
+    if (direct) {
+      return direct;
+    }
+    if (node.kind === 169 /* Parameter */ && node.parent.kind === 178 /* SetAccessor */) {
+      const other = getAllAccessorDeclarationsForDeclaration(node.parent).getAccessor;
+      if (other) {
+        return getEffectiveReturnTypeNode(other);
+      }
+    }
+    return void 0;
+  }
+  function getNonlocalEffectiveReturnTypeAnnotationNode(node) {
+    const direct = getEffectiveReturnTypeNode(node);
+    if (direct) {
+      return direct;
+    }
+    if (node.kind === 177 /* GetAccessor */) {
+      const other = getAllAccessorDeclarationsForDeclaration(node).setAccessor;
+      if (other) {
+        const param = getSetAccessorValueParameter(other);
+        if (param) {
+          return getEffectiveTypeAnnotationNode(param);
+        }
+      }
+    }
+    return void 0;
+  }
   function createResolver() {
     return {
       getReferencedExportContainer,
@@ -83356,34 +83443,19 @@ function createTypeChecker(host) {
       },
       getJsxFactoryEntity,
       getJsxFragmentFactoryEntity,
-      getAllAccessorDeclarations(accessor) {
-        accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration);
-        const otherKind = accessor.kind === 178 /* SetAccessor */ ? 177 /* GetAccessor */ : 178 /* SetAccessor */;
-        const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(accessor), otherKind);
-        const firstAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? otherAccessor : accessor;
-        const secondAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? accessor : otherAccessor;
-        const setAccessor = accessor.kind === 178 /* SetAccessor */ ? accessor : otherAccessor;
-        const getAccessor = accessor.kind === 177 /* GetAccessor */ ? accessor : otherAccessor;
-        return {
-          firstAccessor,
-          secondAccessor,
-          setAccessor,
-          getAccessor
-        };
-      },
       isBindingCapturedByNode: (node, decl) => {
         const parseNode = getParseTreeNode(node);
         const parseDecl = getParseTreeNode(decl);
         return !!parseNode && !!parseDecl && (isVariableDeclaration(parseDecl) || isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
       },
-      getDeclarationStatementsForSourceFile: (node, flags, tracker, bundled) => {
+      getDeclarationStatementsForSourceFile: (node, flags, tracker) => {
         const n = getParseTreeNode(node);
         Debug.assert(n && n.kind === 307 /* SourceFile */, "Non-sourcefile node passed into getDeclarationsForSourceFile");
         const sym = getSymbolOfDeclaration(node);
         if (!sym) {
-          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker, bundled);
+          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker);
         }
-        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker, bundled);
+        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker);
       },
       isImportRequiredByAugmentation
     };
@@ -83725,7 +83797,7 @@ function createTypeChecker(host) {
             return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
           }
         } else if (legacyDecorators && (node.kind === 177 /* GetAccessor */ || node.kind === 178 /* SetAccessor */)) {
-          const accessors = getAllAccessorDeclarations(node.parent.members, node);
+          const accessors = getAllAccessorDeclarationsForDeclaration(node);
           if (hasDecorators(accessors.firstAccessor) && node === accessors.secondAccessor) {
             return grammarErrorOnFirstToken(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
           }
@@ -88916,7 +88988,7 @@ function transformTypeScript(context) {
     if (typeSerializer) {
       let decorators;
       if (shouldAddTypeMetadata(node)) {
-        const typeMetadata = emitHelpers().createMetadataHelper("design:type", typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node));
+        const typeMetadata = emitHelpers().createMetadataHelper("design:type", typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node, container));
         decorators = append(decorators, factory2.createDecorator(typeMetadata));
       }
       if (shouldAddParamTypesMetadata(node)) {
@@ -88943,7 +89015,7 @@ function transformTypeScript(context) {
           /*type*/
           void 0,
           factory2.createToken(39 /* EqualsGreaterThanToken */),
-          typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node)
+          typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node, container)
         ));
         properties = append(properties, typeProperty);
       }
@@ -92380,7 +92452,7 @@ function createRuntimeTypeSerializer(context) {
   let currentNameScope;
   return {
     serializeTypeNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeNode, node),
-    serializeTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeOfNode, node),
+    serializeTypeOfNode: (serializerContext, node, container) => setSerializerContextAnd(serializerContext, serializeTypeOfNode, node, container),
     serializeParameterTypesOfNode: (serializerContext, node, container) => setSerializerContextAnd(serializerContext, serializeParameterTypesOfNode, node, container),
     serializeReturnTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeReturnTypeOfNode, node)
   };
@@ -92394,18 +92466,18 @@ function createRuntimeTypeSerializer(context) {
     currentNameScope = savedCurrentNameScope;
     return result;
   }
-  function getAccessorTypeNode(node) {
-    const accessors = resolver.getAllAccessorDeclarations(node);
+  function getAccessorTypeNode(node, container) {
+    const accessors = getAllAccessorDeclarations(container.members, node);
     return accessors.setAccessor && getSetAccessorTypeAnnotationNode(accessors.setAccessor) || accessors.getAccessor && getEffectiveReturnTypeNode(accessors.getAccessor);
   }
-  function serializeTypeOfNode(node) {
+  function serializeTypeOfNode(node, container) {
     switch (node.kind) {
       case 172 /* PropertyDeclaration */:
       case 169 /* Parameter */:
         return serializeTypeNode(node.type);
       case 178 /* SetAccessor */:
       case 177 /* GetAccessor */:
-        return serializeTypeNode(getAccessorTypeNode(node));
+        return serializeTypeNode(getAccessorTypeNode(node, container));
       case 263 /* ClassDeclaration */:
       case 231 /* ClassExpression */:
       case 174 /* MethodDeclaration */:
@@ -92428,7 +92500,7 @@ function createRuntimeTypeSerializer(context) {
         if (parameter.dotDotDotToken) {
           expressions.push(serializeTypeNode(getRestParameterElementType(parameter.type)));
         } else {
-          expressions.push(serializeTypeOfNode(parameter));
+          expressions.push(serializeTypeOfNode(parameter, container));
         }
       }
     }
@@ -108455,13 +108527,13 @@ function transformDeclarations(context) {
       context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized, propertyName));
     }
   }
-  function transformDeclarationsForJS(sourceFile, bundled) {
+  function transformDeclarationsForJS(sourceFile) {
     const oldDiag = getSymbolAccessibilityDiagnostic;
     getSymbolAccessibilityDiagnostic = (s) => s.errorNode && canProduceDiagnostics(s.errorNode) ? createGetSymbolAccessibilityDiagnosticForNode(s.errorNode)(s) : {
       diagnosticMessage: s.errorModuleName ? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,
       errorNode: s.errorNode || sourceFile
     };
-    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker, bundled);
+    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker);
     getSymbolAccessibilityDiagnostic = oldDiag;
     return result;
   }
@@ -108492,11 +108564,7 @@ function transformDeclarations(context) {
           if (isExternalOrCommonJsModule(sourceFile) || isJsonSourceFile(sourceFile)) {
             resultHasExternalModuleIndicator = false;
             needsDeclare = false;
-            const statements = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(
-              sourceFile,
-              /*bundled*/
-              true
-            )) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
+            const statements = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
             const newFile = factory2.updateSourceFile(
               sourceFile,
               [factory2.createModuleDeclaration(
@@ -108818,7 +108886,7 @@ function transformDeclarations(context) {
       if (!isPrivate) {
         const valueParameter = getSetAccessorValueParameter(input);
         if (valueParameter) {
-          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
+          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input));
           newValueParameter = ensureParameter(
             valueParameter,
             /*modifierMask*/
@@ -109104,7 +109172,7 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
+          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input));
           return cleanup(factory2.updateGetAccessorDeclaration(
             input,
             ensureModifiers(input),
@@ -110952,7 +111020,6 @@ var notImplementedResolver = {
   isLiteralConstDeclaration: notImplemented,
   getJsxFactoryEntity: notImplemented,
   getJsxFragmentFactoryEntity: notImplemented,
-  getAllAccessorDeclarations: notImplemented,
   isBindingCapturedByNode: notImplemented,
   getDeclarationStatementsForSourceFile: notImplemented,
   isImportRequiredByAugmentation: notImplemented
@@ -117018,6 +117085,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     getResolvedProjectReferenceByPath,
     forEachResolvedProjectReference: forEachResolvedProjectReference2,
     isSourceOfProjectReferenceRedirect,
+    getRedirectReferenceForResolutionFromSourceOfProject,
     emitBuildInfo,
     fileExists,
     readFile,
@@ -121893,7 +121961,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
           impliedFormatPackageJsons.delete(newFile.resolvedPath);
       });
       impliedFormatPackageJsons.forEach((existing, path) => {
-        if (!(newProgram == null ? void 0 : newProgram.getSourceFileByPath(path))) {
+        const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path);
+        if (!newFile || newFile.resolvedPath !== path) {
           existing.forEach((location) => fileWatchesOfAffectingLocations.get(location).files--);
           impliedFormatPackageJsons.delete(path);
         }