Bump version to 5.8.3 and LKG

Author: typescript-bot

lib/_tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.8";
-var version = "5.8.2";
+var version = "5.8.3";
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -50405,10 +50405,11 @@ function createTypeChecker(host) {
       serializeExistingTypeNode(context, typeNode, addUndefined) {
         return serializeExistingTypeNode(context, typeNode, !!addUndefined);
       },
-      serializeReturnTypeForSignature(syntacticContext, signatureDeclaration) {
+      serializeReturnTypeForSignature(syntacticContext, signatureDeclaration, symbol) {
         const context = syntacticContext;
         const signature = getSignatureFromDeclaration(signatureDeclaration);
-        const returnType = context.enclosingSymbolTypes.get(getSymbolId(getSymbolOfDeclaration(signatureDeclaration))) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper);
+        symbol ?? (symbol = getSymbolOfDeclaration(signatureDeclaration));
+        const returnType = context.enclosingSymbolTypes.get(getSymbolId(symbol)) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper);
         return serializeInferredReturnTypeForSignature(context, signature, returnType);
       },
       serializeTypeOfExpression(syntacticContext, expr) {
@@ -50422,7 +50423,7 @@ function createTypeChecker(host) {
         symbol ?? (symbol = getSymbolOfDeclaration(declaration));
         let type = (_a = context.enclosingSymbolTypes) == null ? void 0 : _a.get(getSymbolId(symbol));
         if (type === void 0) {
-          type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType;
+          type = symbol.flags & 98304 /* Accessor */ && declaration.kind === 178 /* SetAccessor */ ? instantiateType(getWriteTypeOfSymbol(symbol), context.mapper) : symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType;
         }
         const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
         if (addUndefinedForParameter) {
@@ -50482,6 +50483,7 @@ function createTypeChecker(host) {
         const context = syntacticContext;
         if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) {
           let name = lit.text;
+          const originalName = name;
           const nodeSymbol = getNodeLinks(parent).resolvedSymbol;
           const meaning = parent.isTypeOf ? 111551 /* Value */ : 788968 /* Type */;
           const parentSymbol = nodeSymbol && isSymbolAccessible(
@@ -50511,7 +50513,9 @@ function createTypeChecker(host) {
               context.tracker.reportLikelyUnsafeImportRequiredError(name);
             }
           }
-          return name;
+          if (name !== originalName) {
+            return name;
+          }
         }
       },
       canReuseTypeNode(context, typeNode) {
@@ -51568,12 +51572,13 @@ function createTypeChecker(host) {
       if (propertySymbol.flags & 98304 /* Accessor */) {
         const writeType = getWriteTypeOfSymbol(propertySymbol);
         if (propertyType !== writeType && !isErrorType(propertyType) && !isErrorType(writeType)) {
+          const symbolMapper = getSymbolLinks(propertySymbol).mapper;
           const getterDeclaration = getDeclarationOfKind(propertySymbol, 177 /* GetAccessor */);
           const getterSignature = getSignatureFromDeclaration(getterDeclaration);
           typeElements.push(
             setCommentRange2(
               context,
-              signatureToSignatureDeclarationHelper(getterSignature, 177 /* GetAccessor */, context, { name: propertyName }),
+              signatureToSignatureDeclarationHelper(symbolMapper ? instantiateSignature(getterSignature, symbolMapper) : getterSignature, 177 /* GetAccessor */, context, { name: propertyName }),
               getterDeclaration
             )
           );
@@ -51582,7 +51587,7 @@ function createTypeChecker(host) {
           typeElements.push(
             setCommentRange2(
               context,
-              signatureToSignatureDeclarationHelper(setterSignature, 178 /* SetAccessor */, context, { name: propertyName }),
+              signatureToSignatureDeclarationHelper(symbolMapper ? instantiateSignature(setterSignature, symbolMapper) : setterSignature, 178 /* SetAccessor */, context, { name: propertyName }),
               setterDeclaration
             )
           );
@@ -52725,13 +52730,13 @@ function createTypeChecker(host) {
       const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
       const decl = declaration ?? symbol.valueDeclaration ?? getDeclarationWithTypeAnnotation(symbol) ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
       if (decl) {
+        const restore = addSymbolTypeToContext(context, symbol, type);
         if (isAccessor(decl)) {
           result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
         } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608 /* RequiresWidening */)) {
-          const restore = addSymbolTypeToContext(context, symbol, type);
           result = syntacticNodeBuilder.serializeTypeOfDeclaration(decl, symbol, context);
-          restore();
         }
+        restore();
       }
       if (!result) {
         if (addUndefinedForParameter) {
@@ -52885,10 +52890,7 @@ function createTypeChecker(host) {
           /*context*/
           void 0
         );
-        if (updated !== node2) {
-          setTextRange2(context, updated, node2);
-        }
-        return updated;
+        return setTextRange2(context, updated, node2);
       }
     }
     function serializeTypeName(context, node, isTypeOf, typeArguments) {
@@ -76781,6 +76783,11 @@ function createTypeChecker(host) {
       if (file && fileExtensionIsOneOf(file.fileName, [".cts" /* Cts */, ".mts" /* Mts */])) {
         grammarErrorOnNode(node, Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead);
       }
+      if (compilerOptions.erasableSyntaxOnly) {
+        const start = skipTrivia(file.text, node.pos);
+        const end = node.expression.pos;
+        diagnostics.add(createFileDiagnostic(file, start, end - start, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled));
+      }
     }
     return checkAssertionWorker(node, checkMode);
   }
@@ -131862,9 +131869,11 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
         if (!resolver.canReuseTypeNode(context, node)) {
           return resolver.serializeExistingTypeNode(context, node);
         }
+        const specifier = rewriteModuleSpecifier2(node, node.argument.literal);
+        const literal = specifier === node.argument.literal ? reuseNode(context, node.argument.literal) : specifier;
         return factory.updateImportTypeNode(
           node,
-          factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier2(node, node.argument.literal)),
+          literal === node.argument.literal ? reuseNode(context, node.argument) : factory.createLiteralTypeNode(literal),
           visitNode(node.attributes, visitExistingNodeTreeSymbols, isImportAttributes),
           visitNode(node.qualifier, visitExistingNodeTreeSymbols, isEntityName),
           visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode),
@@ -132019,10 +132028,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
       }
       function rewriteModuleSpecifier2(parent, lit) {
         const newName = resolver.getModuleSpecifierOverride(context, parent, lit);
-        if (newName) {
-          return setOriginalNode(factory.createStringLiteral(newName), lit);
-        }
-        return visitNode(lit, visitExistingNodeTreeSymbols, isStringLiteral);
+        return newName ? setOriginalNode(factory.createStringLiteral(newName), lit) : lit;
       }
     }
   }
@@ -132189,12 +132195,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
       return withNewScope(context, node, () => serializeTypeAnnotationOfDeclaration(accessorType, context, node, symbol) ?? inferTypeOfDeclaration(node, symbol, context));
     }
     if (accessorDeclarations.getAccessor) {
-      return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature(
-        accessorDeclarations.getAccessor,
-        /*symbol*/
-        void 0,
-        context
-      ));
+      return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature(accessorDeclarations.getAccessor, symbol, context));
     }
     return void 0;
   }
@@ -132304,14 +132305,14 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     }
     return resolver.serializeTypeOfExpression(context, node) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
   }
-  function inferReturnTypeOfSignatureSignature(node, context, reportFallback) {
+  function inferReturnTypeOfSignatureSignature(node, context, symbol, reportFallback) {
     if (reportFallback) {
       context.tracker.reportInferenceFallback(node);
     }
     if (context.noInferenceFallback === true) {
       return factory.createKeywordTypeNode(133 /* AnyKeyword */);
     }
-    return resolver.serializeReturnTypeForSignature(context, node) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
+    return resolver.serializeReturnTypeForSignature(context, node, symbol) ?? factory.createKeywordTypeNode(133 /* AnyKeyword */);
   }
   function inferAccessorType(node, allAccessors, context, symbol, reportFallback = true) {
     if (node.kind === 177 /* GetAccessor */) {
@@ -132601,18 +132602,17 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     );
   }
   function reuseTypeParameters(typeParameters, context) {
-    return typeParameters == null ? void 0 : typeParameters.map(
-      (tp) => {
-        var _a;
-        return factory.updateTypeParameterDeclaration(
-          tp,
-          (_a = tp.modifiers) == null ? void 0 : _a.map((m) => reuseNode(context, m)),
-          reuseNode(context, tp.name),
-          serializeExistingTypeNodeWithFallback(tp.constraint, context),
-          serializeExistingTypeNodeWithFallback(tp.default, context)
-        );
-      }
-    );
+    return typeParameters == null ? void 0 : typeParameters.map((tp) => {
+      var _a;
+      const { node: tpName } = resolver.trackExistingEntityName(context, tp.name);
+      return factory.updateTypeParameterDeclaration(
+        tp,
+        (_a = tp.modifiers) == null ? void 0 : _a.map((m) => reuseNode(context, m)),
+        tpName,
+        serializeExistingTypeNodeWithFallback(tp.constraint, context),
+        serializeExistingTypeNodeWithFallback(tp.default, context)
+      );
+    });
   }
   function typeFromObjectLiteralMethod(method, name, context, isConstContext) {
     const returnType = createReturnFromSignature(
@@ -132747,7 +132747,7 @@ function createSyntacticTypeNodeBuilder(options, resolver) {
     } else if (isValueSignatureDeclaration(fn)) {
       returnType = typeFromSingleReturnExpression(fn, context);
     }
-    return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, reportFallback && returnType.reportFallback && !returnTypeNode);
+    return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, symbol, reportFallback && returnType.reportFallback && !returnTypeNode);
   }
   function typeFromSingleReturnExpression(declaration, context) {
     let candidateExpr;