typescript 5.5.0-dev.20240523 → 5.5.0-dev.20240525

package/lib/typescript.js

@@ -2370,7 +2370,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240523`;
+var version = `${versionMajorMinor}.0-dev.20240525`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6200,7 +6200,7 @@ var RegularExpressionFlags = /* @__PURE__ */ ((RegularExpressionFlags2) => {
   RegularExpressionFlags2[RegularExpressionFlags2["Unicode"] = 32] = "Unicode";
   RegularExpressionFlags2[RegularExpressionFlags2["UnicodeSets"] = 64] = "UnicodeSets";
   RegularExpressionFlags2[RegularExpressionFlags2["Sticky"] = 128] = "Sticky";
-  RegularExpressionFlags2[RegularExpressionFlags2["UnicodeMode"] = 96] = "UnicodeMode";
+  RegularExpressionFlags2[RegularExpressionFlags2["AnyUnicodeMode"] = 96] = "AnyUnicodeMode";
   RegularExpressionFlags2[RegularExpressionFlags2["Modifiers"] = 28] = "Modifiers";
   return RegularExpressionFlags2;
 })(RegularExpressionFlags || {});
@@ -6602,6 +6602,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["TemplateLiteral"] = 134217728] = "TemplateLiteral";
   TypeFlags2[TypeFlags2["StringMapping"] = 268435456] = "StringMapping";
   TypeFlags2[TypeFlags2["Reserved1"] = 536870912] = "Reserved1";
+  TypeFlags2[TypeFlags2["Reserved2"] = 1073741824] = "Reserved2";
   TypeFlags2[TypeFlags2["AnyOrUnknown"] = 3] = "AnyOrUnknown";
   TypeFlags2[TypeFlags2["Nullable"] = 98304] = "Nullable";
   TypeFlags2[TypeFlags2["Literal"] = 2944] = "Literal";
@@ -6640,6 +6641,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   TypeFlags2[TypeFlags2["IncludesEmptyObject"] = 16777216 /* Conditional */] = "IncludesEmptyObject";
   TypeFlags2[TypeFlags2["IncludesInstantiable"] = 33554432 /* Substitution */] = "IncludesInstantiable";
   TypeFlags2[TypeFlags2["IncludesConstrainedTypeVariable"] = 536870912 /* Reserved1 */] = "IncludesConstrainedTypeVariable";
+  TypeFlags2[TypeFlags2["IncludesError"] = 1073741824 /* Reserved2 */] = "IncludesError";
   TypeFlags2[TypeFlags2["NotPrimitiveUnion"] = 36323331] = "NotPrimitiveUnion";
   return TypeFlags2;
 })(TypeFlags || {});
@@ -13324,25 +13326,19 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
   }
   function reScanSlashToken(reportErrors2) {
     if (token === 44 /* SlashToken */ || token === 69 /* SlashEqualsToken */) {
-      let p = tokenStart + 1;
+      const startOfRegExpBody = tokenStart + 1;
+      pos = startOfRegExpBody;
       let inEscape = false;
       let inCharacterClass = false;
       while (true) {
-        if (p >= end) {
-          tokenFlags |= 4 /* Unterminated */;
-          error2(Diagnostics.Unterminated_regular_expression_literal);
-          break;
-        }
-        const ch = charCodeUnchecked(p);
-        if (isLineBreak(ch)) {
+        const ch = charCodeChecked(pos);
+        if (ch === -1 /* EOF */ || isLineBreak(ch)) {
           tokenFlags |= 4 /* Unterminated */;
-          error2(Diagnostics.Unterminated_regular_expression_literal);
           break;
         }
         if (inEscape) {
           inEscape = false;
         } else if (ch === 47 /* slash */ && !inCharacterClass) {
-          p++;
           break;
         } else if (ch === 91 /* openBracket */) {
           inCharacterClass = true;
@@ -13351,59 +13347,86 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         } else if (ch === 93 /* closeBracket */) {
           inCharacterClass = false;
         }
-        p++;
+        pos++;
       }
-      const isUnterminated = !!(tokenFlags & 4 /* Unterminated */);
-      const endOfBody = p - (isUnterminated ? 0 : 1);
-      let regExpFlags = 0 /* None */;
-      while (p < end) {
-        const ch = charCodeUnchecked(p);
-        if (!isIdentifierPart(ch, languageVersion)) {
-          break;
+      const endOfRegExpBody = pos;
+      if (tokenFlags & 4 /* Unterminated */) {
+        pos = startOfRegExpBody;
+        inEscape = false;
+        let characterClassDepth = 0;
+        let inDecimalQuantifier = false;
+        let groupDepth = 0;
+        while (pos < endOfRegExpBody) {
+          const ch = charCodeUnchecked(pos);
+          if (inEscape) {
+            inEscape = false;
+          } else if (ch === 92 /* backslash */) {
+            inEscape = true;
+          } else if (ch === 91 /* openBracket */) {
+            characterClassDepth++;
+          } else if (ch === 93 /* closeBracket */ && characterClassDepth) {
+            characterClassDepth--;
+          } else if (!characterClassDepth) {
+            if (ch === 123 /* openBrace */) {
+              inDecimalQuantifier = true;
+            } else if (ch === 125 /* closeBrace */ && inDecimalQuantifier) {
+              inDecimalQuantifier = false;
+            } else if (!inDecimalQuantifier) {
+              if (ch === 40 /* openParen */) {
+                groupDepth++;
+              } else if (ch === 41 /* closeParen */ && groupDepth) {
+                groupDepth--;
+              } else if (ch === 41 /* closeParen */ || ch === 93 /* closeBracket */ || ch === 125 /* closeBrace */) {
+                break;
+              }
+            }
+          }
+          pos++;
         }
-        if (reportErrors2) {
-          const flag = characterToRegularExpressionFlag(String.fromCharCode(ch));
-          if (flag === void 0) {
-            error2(Diagnostics.Unknown_regular_expression_flag, p, 1);
-          } else if (regExpFlags & flag) {
-            error2(Diagnostics.Duplicate_regular_expression_flag, p, 1);
-          } else if (((regExpFlags | flag) & 96 /* UnicodeMode */) === 96 /* UnicodeMode */) {
-            error2(Diagnostics.The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously, p, 1);
-          } else {
-            regExpFlags |= flag;
-            checkRegularExpressionFlagAvailable(flag, p);
+        while (isWhiteSpaceLike(charCodeChecked(pos - 1)) || charCodeChecked(pos - 1) === 59 /* semicolon */) pos--;
+        error2(Diagnostics.Unterminated_regular_expression_literal, tokenStart, pos - tokenStart);
+      } else {
+        pos++;
+        let regExpFlags = 0 /* None */;
+        while (true) {
+          const ch = codePointChecked(pos);
+          if (ch === -1 /* EOF */ || !isIdentifierPart(ch, languageVersion)) {
+            break;
+          }
+          if (reportErrors2) {
+            const flag = characterToRegularExpressionFlag(String.fromCharCode(ch));
+            if (flag === void 0) {
+              error2(Diagnostics.Unknown_regular_expression_flag, pos, 1);
+            } else if (regExpFlags & flag) {
+              error2(Diagnostics.Duplicate_regular_expression_flag, pos, 1);
+            } else if (((regExpFlags | flag) & 96 /* AnyUnicodeMode */) === 96 /* AnyUnicodeMode */) {
+              error2(Diagnostics.The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously, pos, 1);
+            } else {
+              regExpFlags |= flag;
+              checkRegularExpressionFlagAvailable(flag, pos);
+            }
           }
+          pos++;
+        }
+        if (reportErrors2) {
+          scanRange(startOfRegExpBody, endOfRegExpBody - startOfRegExpBody, () => {
+            scanRegularExpressionWorker(
+              regExpFlags,
+              /*annexB*/
+              true
+            );
+          });
         }
-        p++;
-      }
-      pos = p;
-      if (reportErrors2) {
-        const saveTokenStart = tokenStart;
-        const saveTokenFlags = tokenFlags;
-        const savePos = pos;
-        const saveEnd = end;
-        pos = tokenStart + 1;
-        end = endOfBody;
-        scanRegularExpressionWorker(
-          regExpFlags,
-          isUnterminated,
-          /*annexB*/
-          true
-        );
-        tokenStart = saveTokenStart;
-        tokenFlags = saveTokenFlags;
-        pos = savePos;
-        end = saveEnd;
       }
       tokenValue = text.substring(tokenStart, pos);
       token = 14 /* RegularExpressionLiteral */;
     }
     return token;
   }
-  function scanRegularExpressionWorker(regExpFlags, isUnterminated, annexB) {
+  function scanRegularExpressionWorker(regExpFlags, annexB) {
     var unicodeSetsMode = !!(regExpFlags & 64 /* UnicodeSets */);
-    var unicodeMode = !!(regExpFlags & 96 /* UnicodeMode */);
-    if (unicodeMode) {
+    var anyUnicodeMode = !!(regExpFlags & 96 /* AnyUnicodeMode */);
+    if (anyUnicodeMode) {
       annexB = false;
     }
     var mayContainStrings = false;
@@ -13522,7 +13545,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
                 if (max || charCodeChecked(pos) === 125 /* closeBrace */) {
                   error2(Diagnostics.Incomplete_quantifier_Digit_expected, digitsStart, 0);
                 } else {
-                  if (unicodeMode) {
+                  if (anyUnicodeMode) {
                     error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
                   }
                   isPreviousTermQuantifiable = true;
@@ -13533,7 +13556,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
                 error2(Diagnostics.Numbers_out_of_order_in_quantifier, digitsStart, pos - digitsStart);
               }
             } else if (!min2) {
-              if (unicodeMode) {
+              if (anyUnicodeMode) {
                 error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, start2, 1, String.fromCharCode(ch));
               }
               isPreviousTermQuantifiable = true;
@@ -13573,10 +13596,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             }
           case 93 /* closeBracket */:
           case 125 /* closeBrace */:
-            if (isUnterminated && !isInGroup) {
-              return;
-            }
-            if (unicodeMode || ch === 41 /* closeParen */) {
+            if (anyUnicodeMode || ch === 41 /* closeParen */) {
               error2(Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash, pos, 1, String.fromCharCode(ch));
             }
             pos++;
@@ -13625,7 +13645,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
               true
             );
             scanExpectedChar(62 /* greaterThan */);
-          } else if (unicodeMode) {
+          } else if (anyUnicodeMode) {
             error2(Diagnostics.k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets, pos - 2, 2);
           }
           break;
@@ -13658,6 +13678,9 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       Debug.assertEqual(charCodeUnchecked(pos - 1), 92 /* backslash */);
       let ch = charCodeChecked(pos);
       switch (ch) {
+        case -1 /* EOF */:
+          error2(Diagnostics.Undetermined_character_escape, pos - 1, 1);
+          return "\\";
         case 99 /* c */:
           pos++;
           ch = charCodeChecked(pos);
@@ -13665,7 +13688,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             pos++;
             return String.fromCharCode(ch & 31);
           }
-          if (unicodeMode) {
+          if (anyUnicodeMode) {
             error2(Diagnostics.c_must_be_followed_by_an_ASCII_letter, pos - 2, 2);
           } else if (atomEscape && annexB) {
             pos--;
@@ -13690,14 +13713,10 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           pos++;
           return String.fromCharCode(ch);
         default:
-          if (pos >= end) {
-            error2(Diagnostics.Undetermined_character_escape, pos - 1, 1);
-            return "\\";
-          }
           pos--;
           return scanEscapeSequence(
             /*shouldEmitInvalidEscapeError*/
-            unicodeMode,
+            anyUnicodeMode,
             /*isRegularExpression*/
             annexB ? "annex-b" : true
           );
@@ -14173,10 +14192,10 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
               }
             }
             scanExpectedChar(125 /* closeBrace */);
-            if (!unicodeMode) {
+            if (!anyUnicodeMode) {
               error2(Diagnostics.Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set, start2, pos - start2);
             }
-          } else if (unicodeMode) {
+          } else if (anyUnicodeMode) {
             error2(Diagnostics._0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces, pos - 2, 2, String.fromCharCode(ch));
           }
           return true;
@@ -14196,7 +14215,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       return value;
     }
     function scanSourceCharacter() {
-      const size = unicodeMode ? charSize(charCodeChecked(pos)) : 1;
+      const size = anyUnicodeMode ? charSize(charCodeChecked(pos)) : 1;
       pos += size;
       return size > 0 ? text.substring(pos - size, pos) : "";
     }
@@ -32859,10 +32878,7 @@ var Parser;
   function parseErrorAtPosition(start, length2, message, ...args) {
     const lastError = lastOrUndefined(parseDiagnostics);
     let result;
-    if (message.category === 3 /* Message */ && lastError && start === lastError.start && length2 === lastError.length) {
-      result = createDetachedDiagnostic(fileName, sourceText, start, length2, message, ...args);
-      addRelatedInfo(lastError, result);
-    } else if (!lastError || start !== lastError.start) {
+    if (!lastError || start !== lastError.start) {
       result = createDetachedDiagnostic(fileName, sourceText, start, length2, message, ...args);
       parseDiagnostics.push(result);
     }
@@ -51035,7 +51051,12 @@ function createTypeChecker(host) {
         if (resolvedTarget === unknownSymbol) {
           return source;
         }
-        target = cloneSymbol(resolvedTarget);
+        if (!(resolvedTarget.flags & getExcludedSymbolFlags(source.flags)) || (source.flags | resolvedTarget.flags) & 67108864 /* Assignment */) {
+          target = cloneSymbol(resolvedTarget);
+        } else {
+          reportMergeSymbolError(target, source);
+          return source;
+        }
       }
       if (source.flags & 512 /* ValueModule */ && target.flags & 512 /* ValueModule */ && target.constEnumOnlyModule && !source.constEnumOnlyModule) {
         target.constEnumOnlyModule = false;
@@ -51065,27 +51086,30 @@ function createTypeChecker(host) {
         );
       }
     } else {
-      const isEitherEnum = !!(target.flags & 384 /* Enum */ || source.flags & 384 /* Enum */);
-      const isEitherBlockScoped = !!(target.flags & 2 /* BlockScopedVariable */ || source.flags & 2 /* BlockScopedVariable */);
+      reportMergeSymbolError(target, source);
+    }
+    return target;
+    function reportMergeSymbolError(target2, source2) {
+      const isEitherEnum = !!(target2.flags & 384 /* Enum */ || source2.flags & 384 /* Enum */);
+      const isEitherBlockScoped = !!(target2.flags & 2 /* BlockScopedVariable */ || source2.flags & 2 /* BlockScopedVariable */);
       const message = isEitherEnum ? Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations : isEitherBlockScoped ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0;
-      const sourceSymbolFile = source.declarations && getSourceFileOfNode(source.declarations[0]);
-      const targetSymbolFile = target.declarations && getSourceFileOfNode(target.declarations[0]);
+      const sourceSymbolFile = source2.declarations && getSourceFileOfNode(source2.declarations[0]);
+      const targetSymbolFile = target2.declarations && getSourceFileOfNode(target2.declarations[0]);
       const isSourcePlainJs = isPlainJsFile(sourceSymbolFile, compilerOptions.checkJs);
       const isTargetPlainJs = isPlainJsFile(targetSymbolFile, compilerOptions.checkJs);
-      const symbolName2 = symbolToString(source);
+      const symbolName2 = symbolToString(source2);
       if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) {
         const firstFile = comparePaths(sourceSymbolFile.path, targetSymbolFile.path) === -1 /* LessThan */ ? sourceSymbolFile : targetSymbolFile;
         const secondFile = firstFile === sourceSymbolFile ? targetSymbolFile : sourceSymbolFile;
         const filesDuplicates = getOrUpdate(amalgamatedDuplicates, `${firstFile.path}|${secondFile.path}`, () => ({ firstFile, secondFile, conflictingSymbols: /* @__PURE__ */ new Map() }));
         const conflictingSymbolInfo = getOrUpdate(filesDuplicates.conflictingSymbols, symbolName2, () => ({ isBlockScoped: isEitherBlockScoped, firstFileLocations: [], secondFileLocations: [] }));
-        if (!isSourcePlainJs) addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source);
-        if (!isTargetPlainJs) addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target);
+        if (!isSourcePlainJs) addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source2);
+        if (!isTargetPlainJs) addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target2);
       } else {
-        if (!isSourcePlainJs) addDuplicateDeclarationErrorsForSymbols(source, message, symbolName2, target);
-        if (!isTargetPlainJs) addDuplicateDeclarationErrorsForSymbols(target, message, symbolName2, source);
+        if (!isSourcePlainJs) addDuplicateDeclarationErrorsForSymbols(source2, message, symbolName2, target2);
+        if (!isTargetPlainJs) addDuplicateDeclarationErrorsForSymbols(target2, message, symbolName2, source2);
       }
     }
-    return target;
     function addDuplicateLocations(locs, symbol) {
       if (symbol.declarations) {
         for (const decl of symbol.declarations) {
@@ -53931,6 +53955,9 @@ function createTypeChecker(host) {
   function isClassInstanceSide(type) {
     return !!type.symbol && !!(type.symbol.flags & 32 /* Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || !!(type.flags & 524288 /* Object */) && !!(getObjectFlags(type) & 16777216 /* IsClassInstanceClone */));
   }
+  function getTypeFromTypeNodeWithoutContext(node) {
+    return getTypeFromTypeNode(node);
+  }
   function createNodeBuilder() {
     return {
       typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
@@ -53959,6 +53986,12 @@ function createTypeChecker(host) {
       symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
       symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext2(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
+    function getTypeFromTypeNode2(context, node, noMappedTypes) {
+      const type = getTypeFromTypeNodeWithoutContext(node);
+      if (!context.mapper) return type;
+      const mappedType = instantiateType(type, context.mapper);
+      return noMappedTypes && mappedType !== type ? void 0 : mappedType;
+    }
     function setTextRange2(context, range, location) {
       if (!nodeIsSynthesized(range) && !(range.flags & 16 /* Synthesized */) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
         range = factory.cloneNode(range);
@@ -54004,7 +54037,7 @@ function createTypeChecker(host) {
       }
       const clone2 = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2);
       if (clone2) {
-        if (addUndefined && !someType(getTypeFromTypeNode(typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
+        if (addUndefined && !someType(getTypeFromTypeNode2(context, typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
           return factory.createUnionTypeNode([clone2, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
         }
         return clone2;
@@ -54017,14 +54050,18 @@ function createTypeChecker(host) {
       }
       return void 0;
     }
-    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, annotationType) {
-      if (typeNodeIsEquivalentToType(existing, host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
+    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, annotationType = getTypeFromTypeNode2(
+      context,
+      existing,
+      /*noMappedTypes*/
+      true
+    )) {
+      if (annotationType && typeNodeIsEquivalentToType(host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
         const result = tryReuseExistingTypeNodeHelper(context, existing);
         if (result) {
           return result;
         }
       }
-      context.tracker.reportInferenceFallback(existing);
       return void 0;
     }
     function symbolToNode(symbol, context, meaning) {
@@ -54066,7 +54103,8 @@ function createTypeChecker(host) {
         mustCreateTypeParametersNamesLookups: true,
         typeParameterNames: void 0,
         typeParameterNamesByText: void 0,
-        typeParameterNamesByTextNextNameCount: void 0
+        typeParameterNamesByTextNextNameCount: void 0,
+        mapper: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -54357,8 +54395,8 @@ function createTypeChecker(host) {
           context.inferTypeParameters = type2.root.inferTypeParameters;
           const extendsTypeNode2 = typeToTypeNodeHelper(instantiateType(type2.root.extendsType, newMapper), context);
           context.inferTypeParameters = saveInferTypeParameters2;
-          const trueTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type2.root.node.trueType), newMapper));
-          const falseTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type2.root.node.falseType), newMapper));
+          const trueTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode2(context, type2.root.node.trueType), newMapper));
+          const falseTypeNode2 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode2(context, type2.root.node.falseType), newMapper));
           return factory.createConditionalTypeNode(
             checkTypeNode,
             factory.createInferTypeNode(factory.createTypeParameterDeclaration(
@@ -54441,7 +54479,7 @@ function createTypeChecker(host) {
         context.approximateLength += 10;
         const result = setEmitFlags(mappedTypeNode, 1 /* SingleLine */);
         if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) && context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
-          const originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode(type2.declaration.typeParameter.constraint.type)) || unknownType, type2.mapper);
+          const originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode2(context, type2.declaration.typeParameter.constraint.type)) || unknownType, type2.mapper);
           return factory.createConditionalTypeNode(
             typeToTypeNodeHelper(getModifiersTypeFromMappedType(type2), context),
             factory.createInferTypeNode(factory.createTypeParameterDeclaration(
@@ -55068,7 +55106,7 @@ function createTypeChecker(host) {
         /*skipUnionExpanding*/
         true
       )[0];
-      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters, signature.parameters);
+      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters, signature.parameters, signature.mapper);
       context.approximateLength += 3;
       if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
         typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
@@ -55176,11 +55214,15 @@ function createTypeChecker(host) {
     function getParametersInScope(node) {
       return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).parameters : void 0;
     }
-    function enterNewScope(context, declaration, expandedParams, typeParameters, originalParameters) {
+    function enterNewScope(context, declaration, expandedParams, typeParameters, originalParameters, mapper) {
       const cleanupContext = cloneNodeBuilderContext(context);
       let cleanupParams;
       let cleanupTypeParams;
       const oldEnclosingDecl = context.enclosingDeclaration;
+      const oldMapper = context.mapper;
+      if (mapper) {
+        context.mapper = mapper;
+      }
       if (context.enclosingDeclaration && declaration) {
         let pushFakeScope2 = function(kind, addAll) {
           Debug.assert(context.enclosingDeclaration);
@@ -55279,6 +55321,7 @@ function createTypeChecker(host) {
         cleanupTypeParams == null ? void 0 : cleanupTypeParams();
         cleanupContext();
         context.enclosingDeclaration = oldEnclosingDecl;
+        context.mapper = oldMapper;
       };
     }
     function tryGetThisParameterDeclaration(signature, context) {
@@ -55296,7 +55339,7 @@ function createTypeChecker(host) {
             "this",
             /*questionToken*/
             void 0,
-            typeToTypeNodeHelper(getTypeFromTypeNode(thisTag.typeExpression), context)
+            typeToTypeNodeHelper(getTypeFromTypeNode2(context, thisTag.typeExpression), context)
           );
         }
       }
@@ -55934,31 +55977,32 @@ function createTypeChecker(host) {
       var _a;
       const addUndefined = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
       const enclosingDeclaration = context.enclosingDeclaration;
+      const oldFlags = context.flags;
+      if (declaration && hasInferredType(declaration) && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
+        syntacticNodeBuilder.serializeTypeOfDeclaration(declaration, context);
+      }
+      context.flags |= -2147483648 /* NoSyntacticPrinter */;
       if (enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */)) {
-        const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
+        const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol);
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
-          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
+          const result2 = !isTypePredicateNode(existing) && tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
           if (result2) {
+            context.flags = oldFlags;
             return result2;
           }
         }
       }
-      const oldFlags = context.flags;
       if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol && (!context.enclosingDeclaration || some(symbol.declarations, (d) => getSourceFileOfNode(d) === getSourceFileOfNode(context.enclosingDeclaration)))) {
         context.flags |= 1048576 /* AllowUniqueESSymbolType */;
       }
       const decl = declaration ?? symbol.valueDeclaration ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
       const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0;
-      if (decl && hasInferredType(decl) && !(context.flags & -2147483648 /* NoSyntacticPrinter */)) {
-        syntacticNodeBuilder.serializeTypeOfDeclaration(decl, context);
-      }
-      context.flags |= -2147483648 /* NoSyntacticPrinter */;
       const result = expressionOrTypeToTypeNode(context, expr, type, addUndefined);
       context.flags = oldFlags;
       return result;
     }
-    function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type, typeFromTypeNode = getTypeFromTypeNode(typeNode)) {
+    function typeNodeIsEquivalentToType(annotatedDeclaration, type, typeFromTypeNode) {
       if (typeFromTypeNode === type) {
         return true;
       }
@@ -55988,13 +56032,10 @@ function createTypeChecker(host) {
     function serializeReturnTypeForSignatureWorker(context, signature) {
       const typePredicate = getTypePredicateOfSignature(signature);
       const type = getReturnTypeOfSignature(signature);
-      if (context.enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */)) {
+      if (context.enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */) && signature.declaration && !nodeIsSynthesized(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, thisInstantiated);
+        if (annotation && getTypeFromTypeNode2(context, annotation) === type) {
+          const result = tryReuseExistingTypeNodeHelper(context, annotation);
           if (result) {
             return result;
           }
@@ -56137,13 +56178,26 @@ function createTypeChecker(host) {
           !(length(existing.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))));
         }
       }
+      if (isThisTypeNode(existing)) {
+        if (context.mapper === void 0) return true;
+        const type = getTypeFromTypeNode2(
+          context,
+          existing,
+          /*noMappedTypes*/
+          true
+        );
+        return !!type;
+      }
       if (isTypeReferenceNode(existing)) {
         if (isConstTypeReference(existing)) return false;
         const type = getTypeFromTypeReference(existing);
         const symbol = getNodeLinks(existing).resolvedSymbol;
         if (!symbol) return false;
         if (symbol.flags & 262144 /* TypeParameter */) {
-          return true;
+          const type2 = getDeclaredTypeOfSymbol(symbol);
+          if (context.mapper && getMappedType(type2, context.mapper) !== type2) {
+            return false;
+          }
         }
         if (isInJSDoc(existing)) {
           return existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) && !getIntendedTypeFromJSDocTypeReference(existing) && symbol.flags & 788968 /* Type */;
@@ -56156,7 +56210,7 @@ function createTypeChecker(host) {
       return true;
     }
     function serializeExistingTypeNode(context, typeNode) {
-      const type = getTypeFromTypeNode(typeNode);
+      const type = getTypeFromTypeNode2(context, typeNode);
       return typeToTypeNodeHelper(type, context);
     }
     function tryReuseExistingTypeNodeHelper(context, existing) {
@@ -56204,8 +56258,8 @@ function createTypeChecker(host) {
         if (isJSDocTypeLiteral(node)) {
           return factory.createTypeLiteralNode(map(node.jsDocPropertyTags, (t) => {
             const name = isIdentifier(t.name) ? t.name : t.name.right;
-            const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode(node), name.escapedText);
-            const overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode(t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0;
+            const typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode2(context, node), name.escapedText);
+            const overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode2(context, t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : void 0;
             return factory.createPropertySignature(
               /*modifiers*/
               void 0,
@@ -56246,7 +56300,7 @@ function createTypeChecker(host) {
                 /*modifiers*/
                 void 0,
                 getEffectiveDotDotDotForParameter(p),
-                getNameForJSDocFunctionParameter(p, i),
+                setTextRange2(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p),
                 p.questionToken,
                 visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
                 /*initializer*/
@@ -56261,7 +56315,7 @@ function createTypeChecker(host) {
                 /*modifiers*/
                 void 0,
                 getEffectiveDotDotDotForParameter(p),
-                getNameForJSDocFunctionParameter(p, i),
+                setTextRange2(context, factory.createIdentifier(getNameForJSDocFunctionParameter(p, i)), p),
                 p.questionToken,
                 visitNode(p.type, visitExistingNodeTreeSymbols, isTypeNode),
                 /*initializer*/
@@ -56271,6 +56325,21 @@ function createTypeChecker(host) {
             );
           }
         }
+        if (isThisTypeNode(node)) {
+          if (canReuseTypeNode(context, node)) {
+            return node;
+          }
+          return serializeExistingTypeNode(context, node);
+        }
+        if (isTypeParameterDeclaration(node)) {
+          return factory.updateTypeParameterDeclaration(
+            node,
+            node.modifiers,
+            setTextRange2(context, typeParameterToName(getDeclaredTypeOfSymbol(getSymbolOfDeclaration(node)), context), node),
+            visitNode(node.constraint, visitExistingNodeTreeSymbols, isTypeNode),
+            visitNode(node.default, visitExistingNodeTreeSymbols, isTypeNode)
+          );
+        }
         if (isTypeReferenceNode(node)) {
           if (canReuseTypeNode(context, node)) {
             const { introducesError, node: newName } = trackExistingEntityName(node.typeName, context);
@@ -56302,7 +56371,7 @@ function createTypeChecker(host) {
           if (isInJSDoc(node) && nodeSymbol && // The import type resolved using jsdoc fallback logic
           (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
           !(length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) {
-            return setTextRange2(context, typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
+            return setTextRange2(context, typeToTypeNodeHelper(getTypeFromTypeNode2(context, node), context), node);
           }
           return factory.updateImportTypeNode(
             node,
@@ -56372,10 +56441,16 @@ function createTypeChecker(host) {
             return factory.updateComputedPropertyName(node, literal);
           }
         }
-        if (isTypePredicateNode(node) && isIdentifier(node.parameterName)) {
-          const { node: result, introducesError } = trackExistingEntityName(node.parameterName, context);
-          hadError = hadError || introducesError;
-          return factory.updateTypePredicateNode(node, node.assertsModifier, result, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
+        if (isTypePredicateNode(node)) {
+          let parameterName;
+          if (isIdentifier(node.parameterName)) {
+            const { node: result, introducesError } = trackExistingEntityName(node.parameterName, context);
+            hadError = hadError || introducesError;
+            parameterName = result;
+          } else {
+            parameterName = node.parameterName;
+          }
+          return factory.updateTypePredicateNode(node, node.assertsModifier, parameterName, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
         }
         if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
           const visited = visitEachChild(
@@ -57151,7 +57226,7 @@ function createTypeChecker(host) {
           }
           return cleanup(factory.createExpressionWithTypeArguments(
             expr,
-            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(context, a, getTypeFromTypeNode(a)) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
+            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(context, a, getTypeFromTypeNode2(context, a)) || typeToTypeNodeHelper(getTypeFromTypeNode2(context, a), context))
           ));
           function cleanup(result2) {
             context.enclosingDeclaration = oldEnclosing;
@@ -63695,6 +63770,7 @@ function createTypeChecker(host) {
       if (flags & 465829888 /* Instantiable */) includes |= 33554432 /* IncludesInstantiable */;
       if (flags & 2097152 /* Intersection */ && getObjectFlags(type) & 67108864 /* IsConstrainedTypeVariable */) includes |= 536870912 /* IncludesConstrainedTypeVariable */;
       if (type === wildcardType) includes |= 8388608 /* IncludesWildcard */;
+      if (isErrorType(type)) includes |= 1073741824 /* IncludesError */;
       if (!strictNullChecks && flags & 98304 /* Nullable */) {
         if (!(getObjectFlags(type) & 65536 /* ContainsWideningType */)) includes |= 4194304 /* IncludesNonWideningType */;
       } else {
@@ -63886,7 +63962,7 @@ function createTypeChecker(host) {
     const includes = addTypesToUnion(typeSet, 0, types);
     if (unionReduction !== 0 /* None */) {
       if (includes & 3 /* AnyOrUnknown */) {
-        return includes & 1 /* Any */ ? includes & 8388608 /* IncludesWildcard */ ? wildcardType : anyType : unknownType;
+        return includes & 1 /* Any */ ? includes & 8388608 /* IncludesWildcard */ ? wildcardType : includes & 1073741824 /* IncludesError */ ? errorType : anyType : unknownType;
       }
       if (includes & 32768 /* Undefined */) {
         if (typeSet.length >= 2 && typeSet[0] === undefinedType && typeSet[1] === missingType) {
@@ -64012,6 +64088,7 @@ function createTypeChecker(host) {
     } else {
       if (flags & 3 /* AnyOrUnknown */) {
         if (type === wildcardType) includes |= 8388608 /* IncludesWildcard */;
+        if (isErrorType(type)) includes |= 1073741824 /* IncludesError */;
       } else if (strictNullChecks || !(flags & 98304 /* Nullable */)) {
         if (type === missingType) {
           includes |= 262144 /* IncludesMissingType */;
@@ -64139,7 +64216,7 @@ function createTypeChecker(host) {
       return neverType;
     }
     if (includes & 1 /* Any */) {
-      return includes & 8388608 /* IncludesWildcard */ ? wildcardType : anyType;
+      return includes & 8388608 /* IncludesWildcard */ ? wildcardType : includes & 1073741824 /* IncludesError */ ? errorType : anyType;
     }
     if (!strictNullChecks && includes & 98304 /* Nullable */) {
       return includes & 16777216 /* IncludesEmptyObject */ ? neverType : includes & 32768 /* Undefined */ ? undefinedType : nullType;
@@ -89642,6 +89719,7 @@ function createTypeChecker(host) {
   function getSingleReturnExpression(declaration) {
     let candidateExpr;
     if (declaration && !nodeIsMissing(declaration.body)) {
+      if (getFunctionFlags(declaration) & 3 /* AsyncGenerator */) return void 0;
       const body = declaration.body;
       if (body && isBlock(body)) {
         forEachReturnStatement(body, (s) => {
@@ -97225,10 +97303,9 @@ function transformClassFields(context) {
       }
     }
   }
-  function getClassThis() {
+  function tryGetClassThis() {
     const lex = getClassLexicalEnvironment();
-    const classThis = lex.classThis ?? lex.classConstructor ?? (currentClassContainer == null ? void 0 : currentClassContainer.name);
-    return Debug.checkDefined(classThis);
+    return lex.classThis ?? lex.classConstructor ?? (currentClassContainer == null ? void 0 : currentClassContainer.name);
   }
   function transformAutoAccessor(node) {
     const commentRange = getCommentRange(node);
@@ -97256,7 +97333,7 @@ function transformClassFields(context) {
     setOriginalNode(backingField, node);
     setEmitFlags(backingField, 3072 /* NoComments */);
     setSourceMapRange(backingField, sourceMapRange);
-    const receiver = isStatic(node) ? getClassThis() : factory2.createThis();
+    const receiver = isStatic(node) ? tryGetClassThis() ?? factory2.createThis() : factory2.createThis();
     const getter = createAccessorPropertyGetRedirector(factory2, node, modifiers, getterName, receiver);
     setOriginalNode(getter, node);
     setCommentRange(getter, commentRange);
@@ -97822,7 +97899,7 @@ function transformClassFields(context) {
     var _a;
     let facts = 0 /* None */;
     const original = getOriginalNode(node);
-    if (isClassDeclaration(original) && classOrConstructorParameterIsDecorated(legacyDecorators, original)) {
+    if (isClassLike(original) && classOrConstructorParameterIsDecorated(legacyDecorators, original)) {
       facts |= 1 /* ClassWasDecorated */;
     }
     if (shouldTransformPrivateElementsOrClassStaticBlocks && (classHasClassThisAssignment(node) || classHasExplicitlyAssignedName(node))) {
@@ -115867,13 +115944,18 @@ function transformDeclarations(context) {
     if (isDeclaration(input)) {
       if (isDeclarationAndNotVisible(input)) return;
       if (hasDynamicName(input)) {
-        if (isolatedDeclarations && (isClassDeclaration(input.parent) || isObjectLiteralExpression(input.parent))) {
-          context.addDiagnostic(createDiagnosticForNode(input, Diagnostics.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations));
-        }
-        if (isolatedDeclarations && (isInterfaceDeclaration(input.parent) || isTypeLiteralNode(input.parent)) && !isEntityNameExpression(input.name.expression)) {
-          context.addDiagnostic(createDiagnosticForNode(input, Diagnostics.Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations));
-        }
-        if (!isEntityNameExpression(input.name.expression)) {
+        if (isolatedDeclarations) {
+          if (isClassDeclaration(input.parent) || isObjectLiteralExpression(input.parent)) {
+            context.addDiagnostic(createDiagnosticForNode(input, Diagnostics.Computed_property_names_on_class_or_object_literals_cannot_be_inferred_with_isolatedDeclarations));
+            return;
+          } else if (
+            // Type declarations just need to double-check that the input computed name is an entity name expression
+            (isInterfaceDeclaration(input.parent) || isTypeLiteralNode(input.parent)) && !isEntityNameExpression(input.name.expression)
+          ) {
+            context.addDiagnostic(createDiagnosticForNode(input, Diagnostics.Computed_properties_must_be_number_or_string_literals_variables_or_dotted_expressions_with_isolatedDeclarations));
+            return;
+          }
+        } else if (!resolver.isLateBound(getParseTreeNode(input)) || !isEntityNameExpression(input.name.expression)) {
           return;
         }
       }
@@ -126836,6 +126918,7 @@ var BuilderState;
         getKeys: (v) => reverse.get(v),
         getValues: (k) => forward.get(k),
         keys: () => forward.keys(),
+        size: () => forward.size,
         deleteKey: (k) => {
           (deleted || (deleted = /* @__PURE__ */ new Set())).add(k);
           const set = forward.get(k);
@@ -126962,12 +127045,15 @@ var BuilderState;
     return oldState && !oldState.referencedMap === !newReferencedMap;
   }
   BuilderState2.canReuseOldState = canReuseOldState;
+  function createReferencedMap(options) {
+    return options.module !== 0 /* None */ && !options.outFile ? createManyToManyPathMap() : void 0;
+  }
+  BuilderState2.createReferencedMap = createReferencedMap;
   function create(newProgram, oldState, disableUseFileVersionAsSignature) {
     var _a, _b;
     const fileInfos = /* @__PURE__ */ new Map();
     const options = newProgram.getCompilerOptions();
-    const isOutFile = options.outFile;
-    const referencedMap = options.module !== 0 /* None */ && !isOutFile ? createManyToManyPathMap() : void 0;
+    const referencedMap = createReferencedMap(options);
     const useOldState = canReuseOldState(referencedMap, oldState);
     newProgram.getTypeChecker();
     for (const sourceFile of newProgram.getSourceFiles()) {
@@ -126984,7 +127070,7 @@ var BuilderState;
         version: version2,
         signature,
         // No need to calculate affectsGlobalScope with --out since its not used at all
-        affectsGlobalScope: !isOutFile ? isFileAffectingGlobalScope(sourceFile) || void 0 : void 0,
+        affectsGlobalScope: !options.outFile ? isFileAffectingGlobalScope(sourceFile) || void 0 : void 0,
         impliedFormat: sourceFile.impliedNodeFormat
       });
     }
@@ -127273,7 +127359,7 @@ function createBuilderProgramState(newProgram, oldState) {
       if (emitDiagnostics) {
         (state.emitDiagnosticsPerFile ?? (state.emitDiagnosticsPerFile = /* @__PURE__ */ new Map())).set(
           sourceFilePath,
-          oldState.hasReusableDiagnostic ? convertToDiagnostics(emitDiagnostics, newProgram) : repopulateDiagnostics(emitDiagnostics, newProgram)
+          oldState.hasReusableDiagnostic ? convertToDiagnostics(emitDiagnostics, sourceFilePath, newProgram) : repopulateDiagnostics(emitDiagnostics, newProgram)
         );
       }
       if (canCopySemanticDiagnostics) {
@@ -127283,7 +127369,7 @@ function createBuilderProgramState(newProgram, oldState) {
         if (diagnostics) {
           state.semanticDiagnosticsPerFile.set(
             sourceFilePath,
-            oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram) : repopulateDiagnostics(diagnostics, newProgram)
+            oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, sourceFilePath, newProgram) : repopulateDiagnostics(diagnostics, newProgram)
           );
           (state.semanticDiagnosticsFromOldState ?? (state.semanticDiagnosticsFromOldState = /* @__PURE__ */ new Set())).add(sourceFilePath);
         }
@@ -127370,17 +127456,17 @@ function convertOrRepopulateDiagnosticMessageChain(chain, sourceFile, newProgram
 function convertOrRepopulateDiagnosticMessageChainArray(array, sourceFile, newProgram, repopulateInfo) {
   return sameMap(array, (chain) => convertOrRepopulateDiagnosticMessageChain(chain, sourceFile, newProgram, repopulateInfo));
 }
-function convertToDiagnostics(diagnostics, newProgram) {
+function convertToDiagnostics(diagnostics, diagnosticFilePath, newProgram) {
   if (!diagnostics.length) return emptyArray;
   let buildInfoDirectory;
   return diagnostics.map((diagnostic) => {
-    const result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPathInBuildInfoDirectory);
+    const result = convertToDiagnosticRelatedInformation(diagnostic, diagnosticFilePath, newProgram, toPathInBuildInfoDirectory);
     result.reportsUnnecessary = diagnostic.reportsUnnecessary;
     result.reportsDeprecated = diagnostic.reportDeprecated;
     result.source = diagnostic.source;
     result.skippedOn = diagnostic.skippedOn;
     const { relatedInformation } = diagnostic;
-    result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, newProgram, toPathInBuildInfoDirectory)) : [] : void 0;
+    result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, diagnosticFilePath, newProgram, toPathInBuildInfoDirectory)) : [] : void 0;
     return result;
   });
   function toPathInBuildInfoDirectory(path) {
@@ -127388,9 +127474,9 @@ function convertToDiagnostics(diagnostics, newProgram) {
     return toPath(path, buildInfoDirectory, newProgram.getCanonicalFileName);
   }
 }
-function convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath3) {
+function convertToDiagnosticRelatedInformation(diagnostic, diagnosticFilePath, newProgram, toPath3) {
   const { file } = diagnostic;
-  const sourceFile = file ? newProgram.getSourceFileByPath(toPath3(file)) : void 0;
+  const sourceFile = file !== false ? newProgram.getSourceFileByPath(file ? toPath3(file) : diagnosticFilePath) : void 0;
   return {
     ...diagnostic,
     file: sourceFile,
@@ -127706,7 +127792,7 @@ function isProgramBundleEmitBuildInfo(info) {
   return !!((_a = info.options) == null ? void 0 : _a.outFile);
 }
 function getBuildInfo2(state) {
-  var _a;
+  var _a, _b;
   const currentDirectory = Debug.checkDefined(state.program).getCurrentDirectory();
   const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory));
   const latestChangedDtsFile = state.latestChangedDtsFile ? relativeToBuildInfoEnsuringAbsolutePath(state.latestChangedDtsFile) : void 0;
@@ -127743,7 +127829,7 @@ function getBuildInfo2(state) {
   let fileNamesToFileIdListId;
   let emitSignatures;
   const fileInfos = arrayFrom(state.fileInfos.entries(), ([key, value]) => {
-    var _a2, _b;
+    var _a2, _b2;
     const fileId = toFileId(key);
     tryAddRoot(key, fileId);
     Debug.assert(fileNames[fileId - 1] === relativeToBuildInfo(key));
@@ -127752,7 +127838,7 @@ function getBuildInfo2(state) {
     if (state.compilerOptions.composite) {
       const file = state.program.getSourceFileByPath(key);
       if (!isJsonSourceFile(file) && sourceFileMayBeEmitted(file, state.program)) {
-        const emitSignature = (_b = state.emitSignatures) == null ? void 0 : _b.get(key);
+        const emitSignature = (_b2 = state.emitSignatures) == null ? void 0 : _b2.get(key);
         if (emitSignature !== actualSignature) {
           emitSignatures = append(
             emitSignatures,
@@ -127786,15 +127872,15 @@ function getBuildInfo2(state) {
     );
   });
   let referencedMap;
-  if (state.referencedMap) {
+  if ((_a = state.referencedMap) == null ? void 0 : _a.size()) {
     referencedMap = arrayFrom(state.referencedMap.keys()).sort(compareStringsCaseSensitive).map((key) => [
       toFileId(key),
       toFileIdListId(state.referencedMap.getValues(key))
     ]);
   }
-  const semanticDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics(state.semanticDiagnosticsPerFile);
+  const semanticDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics();
   let affectedFilesPendingEmit;
-  if ((_a = state.affectedFilesPendingEmit) == null ? void 0 : _a.size) {
+  if ((_b = state.affectedFilesPendingEmit) == null ? void 0 : _b.size) {
     const fullEmitForOptions = getBuilderFileEmit(state.compilerOptions);
     const seenFiles = /* @__PURE__ */ new Set();
     for (const path of arrayFrom(state.affectedFilesPendingEmit.keys()).sort(compareStringsCaseSensitive)) {
@@ -127822,7 +127908,7 @@ function getBuildInfo2(state) {
       changeFileSet = append(changeFileSet, toFileId(path));
     }
   }
-  const emitDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics(state.emitDiagnosticsPerFile);
+  const emitDiagnosticsPerFile = convertToProgramBuildInfoEmitDiagnostics();
   const program = {
     fileNames,
     fileInfos,
@@ -127914,40 +128000,53 @@ function getBuildInfo2(state) {
     }
     return value;
   }
-  function convertToProgramBuildInfoDiagnostics(diagnostics) {
+  function convertToProgramBuildInfoDiagnostics() {
     let result;
-    if (diagnostics) {
-      for (const key of arrayFrom(diagnostics.keys()).sort(compareStringsCaseSensitive)) {
-        const value = diagnostics.get(key);
-        result = append(
-          result,
-          value.length ? [
-            toFileId(key),
-            convertToReusableDiagnostics(value)
-          ] : toFileId(key)
-        );
+    state.fileInfos.forEach((_value, key) => {
+      var _a2;
+      const value = (_a2 = state.semanticDiagnosticsPerFile) == null ? void 0 : _a2.get(key);
+      if (!value) {
+        if (!state.changedFilesSet.has(key)) result = append(result, toFileId(key));
+      } else if (value.length) {
+        result = append(result, [
+          toFileId(key),
+          convertToReusableDiagnostics(value, key)
+        ]);
       }
+    });
+    return result;
+  }
+  function convertToProgramBuildInfoEmitDiagnostics() {
+    var _a2;
+    let result;
+    if (!((_a2 = state.emitDiagnosticsPerFile) == null ? void 0 : _a2.size)) return result;
+    for (const key of arrayFrom(state.emitDiagnosticsPerFile.keys()).sort(compareStringsCaseSensitive)) {
+      const value = state.emitDiagnosticsPerFile.get(key);
+      result = append(result, [
+        toFileId(key),
+        convertToReusableDiagnostics(value, key)
+      ]);
     }
     return result;
   }
-  function convertToReusableDiagnostics(diagnostics) {
+  function convertToReusableDiagnostics(diagnostics, diagnosticFilePath) {
     Debug.assert(!!diagnostics.length);
     return diagnostics.map((diagnostic) => {
-      const result = convertToReusableDiagnosticRelatedInformation(diagnostic);
+      const result = convertToReusableDiagnosticRelatedInformation(diagnostic, diagnosticFilePath);
       result.reportsUnnecessary = diagnostic.reportsUnnecessary;
       result.reportDeprecated = diagnostic.reportsDeprecated;
       result.source = diagnostic.source;
       result.skippedOn = diagnostic.skippedOn;
       const { relatedInformation } = diagnostic;
-      result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToReusableDiagnosticRelatedInformation(r)) : [] : void 0;
+      result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToReusableDiagnosticRelatedInformation(r, diagnosticFilePath)) : [] : void 0;
       return result;
     });
   }
-  function convertToReusableDiagnosticRelatedInformation(diagnostic) {
+  function convertToReusableDiagnosticRelatedInformation(diagnostic, diagnosticFilePath) {
     const { file } = diagnostic;
     return {
       ...diagnostic,
-      file: file ? relativeToBuildInfo(file.resolvedPath) : void 0,
+      file: file ? file.resolvedPath === diagnosticFilePath ? void 0 : relativeToBuildInfo(file.resolvedPath) : false,
       messageText: isString(diagnostic.messageText) ? diagnostic.messageText : convertToReusableDiagnosticMessageChain(diagnostic.messageText)
     };
   }
@@ -128346,16 +128445,17 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
         );
       }
     });
+    const changedFilesSet = new Set(map(program.changeFileSet, toFilePath));
     const fullEmitForOptions = program.affectedFilesPendingEmit ? getBuilderFileEmit(program.options || {}) : void 0;
     state = {
       fileInfos,
       compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
-      referencedMap: toManyToManyPathMap(program.referencedMap),
-      semanticDiagnosticsPerFile: toPerFileDiagnostics(program.semanticDiagnosticsPerFile),
-      emitDiagnosticsPerFile: toPerFileDiagnostics(program.emitDiagnosticsPerFile),
+      referencedMap: toManyToManyPathMap(program.referencedMap, program.options ?? {}),
+      semanticDiagnosticsPerFile: toPerFileSemanticDiagnostics(program.semanticDiagnosticsPerFile, fileInfos, changedFilesSet),
+      emitDiagnosticsPerFile: toPerFileEmitDiagnostics(program.emitDiagnosticsPerFile),
       hasReusableDiagnostic: true,
       affectedFilesPendingEmit: program.affectedFilesPendingEmit && arrayToMap(program.affectedFilesPendingEmit, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => toBuilderFileEmit(value, fullEmitForOptions)),
-      changedFilesSet: new Set(map(program.changeFileSet, toFilePath)),
+      changedFilesSet,
       latestChangedDtsFile,
       emitSignatures: (emitSignatures == null ? void 0 : emitSignatures.size) ? emitSignatures : void 0
     };
@@ -128397,16 +128497,27 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
   function toFilePathsSet(fileIdsListId) {
     return filePathsSetList[fileIdsListId - 1];
   }
-  function toManyToManyPathMap(referenceMap) {
-    if (!referenceMap) {
-      return void 0;
-    }
-    const map2 = BuilderState.createManyToManyPathMap();
+  function toManyToManyPathMap(referenceMap, options) {
+    const map2 = BuilderState.createReferencedMap(options);
+    if (!map2 || !referenceMap) return map2;
     referenceMap.forEach(([fileId, fileIdListId]) => map2.set(toFilePath(fileId), toFilePathsSet(fileIdListId)));
     return map2;
   }
-  function toPerFileDiagnostics(diagnostics) {
-    return diagnostics && arrayToMap(diagnostics, (value) => toFilePath(isNumber(value) ? value : value[0]), (value) => isNumber(value) ? emptyArray : value[1]);
+  function toPerFileSemanticDiagnostics(diagnostics, fileInfos, changedFilesSet) {
+    const semanticDiagnostics = new Map(
+      mapDefinedIterator(
+        fileInfos.keys(),
+        (key) => !changedFilesSet.has(key) ? [key, emptyArray] : void 0
+      )
+    );
+    diagnostics == null ? void 0 : diagnostics.forEach((value) => {
+      if (isNumber(value)) semanticDiagnostics.delete(toFilePath(value));
+      else semanticDiagnostics.set(toFilePath(value[0]), value[1]);
+    });
+    return semanticDiagnostics.size ? semanticDiagnostics : void 0;
+  }
+  function toPerFileEmitDiagnostics(diagnostics) {
+    return diagnostics && arrayToMap(diagnostics, (value) => toFilePath(value[0]), (value) => value[1]);
   }
 }
 function getBuildInfoFileVersionMap(program, buildInfoPath, host) {
@@ -131997,7 +132108,7 @@ function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime,
   }
 }
 function getUpToDateStatusWorker(state, project, resolvedPath) {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   if (!project.fileNames.length && !canJsonReportNoInputFiles(project.raw)) {
     return {
       type: 15 /* ContainerOnly */
@@ -132069,7 +132180,7 @@ function getUpToDateStatusWorker(state, project, resolvedPath) {
       };
     }
     if (buildInfo.program) {
-      if (((_a = buildInfo.program.changeFileSet) == null ? void 0 : _a.length) || (!project.options.noEmit ? ((_b = buildInfo.program.affectedFilesPendingEmit) == null ? void 0 : _b.length) || ((_c = buildInfo.program.emitDiagnosticsPerFile) == null ? void 0 : _c.length) : some(buildInfo.program.semanticDiagnosticsPerFile, isArray))) {
+      if (((_a = buildInfo.program.changeFileSet) == null ? void 0 : _a.length) || (!project.options.noEmit ? ((_b = buildInfo.program.affectedFilesPendingEmit) == null ? void 0 : _b.length) || ((_c = buildInfo.program.emitDiagnosticsPerFile) == null ? void 0 : _c.length) : (_d = buildInfo.program.semanticDiagnosticsPerFile) == null ? void 0 : _d.length)) {
         return {
           type: 7 /* OutOfDateBuildInfo */,
           buildInfoFile: buildInfoPath
@@ -133941,8 +134052,8 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     serializeReturnTypeForSignature,
     serializeTypeOfExpression
   };
-  function serializeExistingTypeAnnotation(type) {
-    return type === void 0 ? void 0 : !type.parent || !isParameter(type.parent) || !resolver.requiresAddingImplicitUndefined(type.parent) || canAddUndefined(type);
+  function serializeExistingTypeAnnotation(type, addUndefined) {
+    return type !== void 0 && (!addUndefined || type && canAddUndefined(type)) ? true : void 0;
   }
   function serializeTypeOfExpression(expr, context, addUndefined, preserveLiterals) {
     return typeFromExpression(
@@ -134063,12 +134174,17 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     const declaredType = getEffectiveTypeAnnotationNode(node);
     const addUndefined = resolver.requiresAddingImplicitUndefined(node);
     let resultType;
-    if (!addUndefined) {
-      if (declaredType) {
-        return serializeExistingTypeAnnotation(declaredType);
-      }
+    if (declaredType) {
+      resultType = serializeExistingTypeAnnotation(declaredType, addUndefined);
+    } else {
       if (node.initializer && isIdentifier(node.name)) {
-        resultType = typeFromExpression(node.initializer, context);
+        resultType = typeFromExpression(
+          node.initializer,
+          context,
+          /*isConstContext*/
+          void 0,
+          addUndefined
+        );
       }
     }
     return resultType ?? inferTypeOfDeclaration(node, context);
@@ -134331,6 +134447,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
   function typeFromSingleReturnExpression(declaration, context) {
     let candidateExpr;
     if (declaration && !nodeIsMissing(declaration.body)) {
+      if (getFunctionFlags(declaration) & 3 /* AsyncGenerator */) return void 0;
       const body = declaration.body;
       if (body && isBlock(body)) {
         forEachReturnStatement(body, (s) => {
@@ -142906,7 +143023,7 @@ registerRefactor(refactorNameForMoveToFile, {
     if (!interactiveRefactorArguments) {
       return emptyArray;
     }
-    if (context.endPosition !== void 0) {
+    if (context.triggerReason === "implicit" && context.endPosition !== void 0) {
       const startNodeAncestor = findAncestor(getTokenAtPosition(file, context.startPosition), isBlockLike);
       const endNodeAncestor = findAncestor(getTokenAtPosition(file, context.endPosition), isBlockLike);
       if (startNodeAncestor && !isSourceFile(startNodeAncestor) && endNodeAncestor && !isSourceFile(endNodeAncestor)) {
@@ -143897,11 +144014,19 @@ registerRefactor(refactorName5, {
   kinds: [moveToNewFileAction.kind],
   getAvailableActions: function getRefactorActionsToMoveToNewFile(context) {
     const statements = getStatementsToMove(context);
+    const file = context.file;
+    if (context.triggerReason === "implicit" && context.endPosition !== void 0) {
+      const startNodeAncestor = findAncestor(getTokenAtPosition(file, context.startPosition), isBlockLike);
+      const endNodeAncestor = findAncestor(getTokenAtPosition(file, context.endPosition), isBlockLike);
+      if (startNodeAncestor && !isSourceFile(startNodeAncestor) && endNodeAncestor && !isSourceFile(endNodeAncestor)) {
+        return emptyArray;
+      }
+    }
     if (context.preferences.allowTextChangesInNewFiles && statements) {
-      const file = context.file;
+      const file2 = context.file;
       const affectedTextRange = {
-        start: { line: getLineAndCharacterOfPosition(file, statements.all[0].getStart(file)).line, offset: getLineAndCharacterOfPosition(file, statements.all[0].getStart(file)).character },
-        end: { line: getLineAndCharacterOfPosition(file, last(statements.all).end).line, offset: getLineAndCharacterOfPosition(file, last(statements.all).end).character }
+        start: { line: getLineAndCharacterOfPosition(file2, statements.all[0].getStart(file2)).line, offset: getLineAndCharacterOfPosition(file2, statements.all[0].getStart(file2)).character },
+        end: { line: getLineAndCharacterOfPosition(file2, last(statements.all).end).line, offset: getLineAndCharacterOfPosition(file2, last(statements.all).end).character }
       };
       return [{ name: refactorName5, description: description2, actions: [{ ...moveToNewFileAction, range: affectedTextRange }] }];
     }
@@ -167490,7 +167615,7 @@ function entryToDocumentSpan(entry) {
   }
 }
 function getPrefixAndSuffixText(entry, originalNode, checker, quotePreference) {
-  if (entry.kind !== 0 /* Span */ && isIdentifier(originalNode)) {
+  if (entry.kind !== 0 /* Span */ && (isIdentifier(originalNode) || isStringLiteralLike(originalNode))) {
     const { node, kind } = entry;
     const parent2 = node.parent;
     const name = originalNode.text;
@@ -173273,7 +173398,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symb
             typeChecker,
             resolvedSymbol,
             getSourceFileOfNode(resolvedNode),
-            resolvedNode,
+            enclosingDeclaration,
             declarationName,
             type,
             semanticMeaning,