@typescript-deploys/pr-build 5.5.0-pr-58528-2 → 5.5.0-pr-58495-31

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-insiders.20240513`;
+var version = `${versionMajorMinor}.0-insiders.20240515`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -13651,7 +13651,8 @@ function getLeadingCommentRangesOfNode(node, sourceFileOfNode) {
 }
 function getJSDocCommentRanges(node, text) {
   const commentRanges = node.kind === 169 /* Parameter */ || node.kind === 168 /* TypeParameter */ || node.kind === 218 /* FunctionExpression */ || node.kind === 219 /* ArrowFunction */ || node.kind === 217 /* ParenthesizedExpression */ || node.kind === 260 /* VariableDeclaration */ || node.kind === 281 /* ExportSpecifier */ ? concatenate(getTrailingCommentRanges(text, node.pos), getLeadingCommentRanges(text, node.pos)) : getLeadingCommentRanges(text, node.pos);
-  return filter(commentRanges, (comment) => text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 2) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 3) !== 47 /* slash */);
+  return filter(commentRanges, (comment) => comment.end <= node.end && // Due to parse errors sometime empty parameter may get comments assigned to it that end up not in parameter range
+  text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 2) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 3) !== 47 /* slash */);
 }
 var fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
 var fullTripleSlashReferenceTypeReferenceDirectiveRegEx = /^(\/\/\/\s*<reference\s+types\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
@@ -49019,7 +49020,7 @@ function createTypeChecker(host) {
       return { accessibility: 0 /* Accessible */ };
     }
     return symbol && hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) || {
-      accessibility: 1 /* NotAccessible */,
+      accessibility: 3 /* NotResolved */,
       errorSymbolName: getTextOfNode(firstIdentifier),
       errorNode: firstIdentifier
     };
@@ -49157,6 +49158,7 @@ function createTypeChecker(host) {
       if (!nodeIsSynthesized(range) && !(range.flags & 16 /* Synthesized */) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
         range = factory.cloneNode(range);
       }
+      if (range === location) return range;
       if (!location) {
         return range;
       }
@@ -51293,6 +51295,57 @@ function createTypeChecker(host) {
         return updated;
       }
     }
+    function serializeTypeName(context, node, isTypeOf, typeArguments) {
+      const meaning = isTypeOf ? 111551 /* Value */ : 788968 /* Type */;
+      const symbol = resolveEntityName(
+        node,
+        meaning,
+        /*ignoreErrors*/
+        true
+      );
+      if (!symbol) return void 0;
+      const resolvedSymbol = symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol;
+      if (isSymbolAccessible(
+        symbol,
+        context.enclosingDeclaration,
+        meaning,
+        /*shouldComputeAliasesToMakeVisible*/
+        false
+      ).accessibility !== 0 /* Accessible */) return void 0;
+      return symbolToTypeNode(resolvedSymbol, context, meaning, typeArguments);
+    }
+    function canReuseTypeNode(context, existing) {
+      if (isInJSFile(existing)) {
+        if (isLiteralImportTypeNode(existing)) {
+          void getTypeFromImportTypeNode(existing);
+          const nodeSymbol = getNodeLinks(existing).resolvedSymbol;
+          return !nodeSymbol || !// The import type resolved using jsdoc fallback logic
+          (!existing.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
+          !(length(existing.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))));
+        }
+      }
+      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;
+        }
+        if (isInJSDoc(existing)) {
+          return existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) && !getIntendedTypeFromJSDocTypeReference(existing) && symbol.flags & 788968 /* Type */;
+        }
+      }
+      if (isTypeOperatorNode(existing) && existing.operator === 158 /* UniqueKeyword */ && existing.type.kind === 155 /* SymbolKeyword */) {
+        const effectiveEnclosingContext = context.enclosingDeclaration && getEnclosingDeclarationIgnoringFakeScope(context.enclosingDeclaration);
+        return !!findAncestor(existing, (n) => n === effectiveEnclosingContext);
+      }
+      return true;
+    }
+    function serializeExistingTypeNode(context, typeNode) {
+      const type = getTypeFromTypeNode(typeNode);
+      return typeToTypeNodeHelper(type, context);
+    }
     function tryReuseExistingTypeNodeHelper(context, existing) {
       if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
         cancellationToken.throwIfCancellationRequested();
@@ -51302,6 +51355,7 @@ function createTypeChecker(host) {
       if (hadError) {
         return void 0;
       }
+      context.approximateLength += existing.end - existing.pos;
       return transformed;
       function visitExistingNodeTreeSymbols(node) {
         const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
@@ -51401,20 +51455,38 @@ function createTypeChecker(host) {
             );
           }
         }
-        if (isTypeReferenceNode(node) && isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(
-          node,
-          788968 /* Type */,
-          /*ignoreErrors*/
-          true
-        ))) {
-          return setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
+        if (isTypeReferenceNode(node)) {
+          if (canReuseTypeNode(context, node)) {
+            const { introducesError, node: newName } = trackExistingEntityName(node.typeName, context);
+            const typeArguments = visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode);
+            if (!introducesError) {
+              const updated = factory.updateTypeReferenceNode(
+                node,
+                newName,
+                typeArguments
+              );
+              return setTextRange2(context, updated, node);
+            } else {
+              const serializedName = serializeTypeName(
+                context,
+                node.typeName,
+                /*isTypeOf*/
+                false,
+                typeArguments
+              );
+              if (serializedName) {
+                return setTextRange2(context, serializedName, node.typeName);
+              }
+            }
+          }
+          return serializeExistingTypeNode(context, node);
         }
         if (isLiteralImportTypeNode(node)) {
           const nodeSymbol = getNodeLinks(node).resolvedSymbol;
           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 setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
+            return setTextRange2(context, typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
           }
           return factory.updateImportTypeNode(
             node,
@@ -51446,13 +51518,48 @@ function createTypeChecker(host) {
           }
           return visited;
         }
-        if (isEntityName(node) || isEntityNameExpression(node)) {
-          if (isDeclarationName(node)) {
-            return node;
+        if (isTypeQueryNode(node)) {
+          const { introducesError, node: exprName } = trackExistingEntityName(node.exprName, context);
+          if (introducesError) {
+            const serializedName = serializeTypeName(
+              context,
+              node.exprName,
+              /*isTypeOf*/
+              true
+            );
+            if (serializedName) {
+              return setTextRange2(context, serializedName, node.exprName);
+            }
+            return serializeExistingTypeNode(context, node);
           }
-          const { introducesError, node: result } = trackExistingEntityName(node, context);
+          return factory.updateTypeQueryNode(
+            node,
+            exprName,
+            visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode)
+          );
+        }
+        if (isComputedPropertyName(node) && isEntityNameExpression(node.expression)) {
+          const { node: result, introducesError } = trackExistingEntityName(node.expression, context);
+          if (!introducesError) {
+            return factory.updateComputedPropertyName(node, result);
+          } else {
+            const type = getWidenedType(getRegularTypeOfExpression(node.expression));
+            const computedPropertyNameType = typeToTypeNodeHelper(type, context);
+            Debug.assertNode(computedPropertyNameType, isLiteralTypeNode);
+            const literal = computedPropertyNameType.literal;
+            if (literal.kind === 11 /* StringLiteral */ && isIdentifierText(literal.text, getEmitScriptTarget(compilerOptions))) {
+              return factory.createIdentifier(literal.text);
+            }
+            if (literal.kind === 9 /* NumericLiteral */ && !literal.text.startsWith("-")) {
+              return literal;
+            }
+            return factory.updateComputedPropertyName(node, literal);
+          }
+        }
+        if (isTypePredicateNode(node) && isIdentifier(node.parameterName)) {
+          const { node: result, introducesError } = trackExistingEntityName(node.parameterName, context);
           hadError = hadError || introducesError;
-          return result;
+          return factory.updateTypePredicateNode(node, node.assertsModifier, result, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
         }
         if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
           const visited = visitEachChild(
@@ -51486,6 +51593,11 @@ function createTypeChecker(host) {
             falseType2
           );
         }
+        if (isTypeOperatorNode(node) && node.operator === 158 /* UniqueKeyword */ && node.type.kind === 155 /* SymbolKeyword */) {
+          if (!canReuseTypeNode(context, node)) {
+            return serializeExistingTypeNode(context, node);
+          }
+        }
         return visitEachChild(
           node,
           visitExistingNodeTreeSymbols,
@@ -57272,10 +57384,14 @@ function createTypeChecker(host) {
         }
         if (type || jsdocPredicate) {
           signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
-        } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType.flags & 16 /* Boolean */) && getParameterCount(signature) > 0) {
+        } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType.flags & (16 /* Boolean */ | 49152 /* VoidLike */)) && getParameterCount(signature) > 0) {
           const { declaration } = signature;
           signature.resolvedTypePredicate = noTypePredicate;
-          signature.resolvedTypePredicate = getTypePredicateFromBody(declaration) || noTypePredicate;
+          if (!signature.resolvedReturnType || signature.resolvedReturnType.flags & 16 /* Boolean */) {
+            signature.resolvedTypePredicate = getTypePredicateFromBody(declaration) || noTypePredicate;
+          } else if (!signature.resolvedReturnType || signature.resolvedReturnType.flags & 49152 /* VoidLike */) {
+            signature.resolvedTypePredicate = getTypeAssertionFromBody(declaration) || noTypePredicate;
+          }
         } else {
           signature.resolvedTypePredicate = noTypePredicate;
         }
@@ -76073,6 +76189,48 @@ function createTypeChecker(host) {
     const falseSubtype = getFlowTypeOfReference(param.name, initType, trueType2, func, falseCondition);
     return falseSubtype.flags & 131072 /* Never */ ? trueType2 : void 0;
   }
+  function getTypeAssertionFromBody(func) {
+    switch (func.kind) {
+      case 176 /* Constructor */:
+      case 177 /* GetAccessor */:
+      case 178 /* SetAccessor */:
+      case 219 /* ArrowFunction */:
+      case 218 /* FunctionExpression */:
+      case 174 /* MethodDeclaration */:
+        return void 0;
+    }
+    const functionFlags = getFunctionFlags(func);
+    if (functionFlags !== 0 /* Normal */ || !func.body) return void 0;
+    const returnFlowNodes = [];
+    const bailedEarly = forEachReturnStatement(func.body, (returnStatement) => {
+      if (!returnStatement.flowNode) {
+        return true;
+      }
+      returnFlowNodes.push(returnStatement.flowNode);
+    });
+    if (bailedEarly) return void 0;
+    if (functionHasImplicitReturn(func)) {
+      returnFlowNodes.push(func.endFlowNode);
+    }
+    if (!returnFlowNodes.length) return void 0;
+    return forEach(func.parameters, (param, i) => {
+      const initType = getTypeOfSymbol(param.symbol);
+      if (!initType || !isIdentifier(param.name) || isSymbolAssigned(param.symbol) || isRestParameter(param)) {
+        return;
+      }
+      const typesAtReturn = [];
+      const bailedEarly2 = forEach(returnFlowNodes, (flowNode) => {
+        const type = getFlowTypeOfReference(param.name, initType, initType, func, flowNode);
+        if (type === initType) return true;
+        typesAtReturn.push(type);
+      });
+      if (bailedEarly2) return;
+      const assertedType = getUnionType(typesAtReturn, 2 /* Subtype */);
+      const patchedInitType = mapType(initType, (t) => t.flags & 16384 /* Void */ ? undefinedType : t.flags & 1 /* Any */ ? unknownType : t);
+      if (isTypeAssignableTo(patchedInitType, assertedType)) return;
+      return createTypePredicate(3 /* AssertsIdentifier */, unescapeLeadingUnderscores(param.name.escapedText), i, assertedType);
+    });
+  }
   function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
     addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
     return;
@@ -77451,6 +77609,10 @@ function createTypeChecker(host) {
       texts.push(span.literal.text);
       types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
     }
+    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node).value;
+    if (evaluated) {
+      return getFreshTypeOfLiteralType(getStringLiteralType(evaluated));
+    }
     if (isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(
       node,
       /*contextFlags*/
@@ -77458,8 +77620,7 @@ function createTypeChecker(host) {
     ) || unknownType, isTemplateLiteralContextualType)) {
       return getTemplateLiteralType(texts, types);
     }
-    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node).value;
-    return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
+    return stringType;
   }
   function isTemplateLiteralContextualType(type) {
     return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
@@ -110149,7 +110310,7 @@ function transformDeclarations(context) {
           }
         }
       }
-    } else {
+    } else if (symbolAccessibilityResult.accessibility !== 3 /* NotResolved */) {
       const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
       if (errorInfo) {
         if (errorInfo.typeName) {
@@ -118040,7 +118201,7 @@ function createModuleResolutionLoader(containingFile, redirectedReference, optio
   };
 }
 function getTypeReferenceResolutionName(entry) {
-  return !isString(entry) ? toFileNameLowerCase(entry.fileName) : entry;
+  return !isString(entry) ? entry.fileName : entry;
 }
 var typeReferenceResolutionNameAndModeGetter = {
   getName: getTypeReferenceResolutionName,
@@ -118792,7 +118953,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     return (_a2 = resolvedTypeReferenceDirectiveNames == null ? void 0 : resolvedTypeReferenceDirectiveNames.get(file.path)) == null ? void 0 : _a2.get(typeDirectiveName, mode);
   }
   function getResolvedTypeReferenceDirectiveFromTypeReferenceDirective(typeRef, sourceFile) {
-    return getResolvedTypeReferenceDirective(sourceFile, toFileNameLowerCase(typeRef.fileName), typeRef.resolutionMode || sourceFile.impliedNodeFormat);
+    return getResolvedTypeReferenceDirective(sourceFile, typeRef.fileName, typeRef.resolutionMode || sourceFile.impliedNodeFormat);
   }
   function forEachResolvedModule(callback, file) {
     forEachResolution(resolvedModules, callback, file);
@@ -120334,7 +120495,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     for (let index = 0; index < typeDirectives.length; index++) {
       const ref = file.typeReferenceDirectives[index];
       const resolvedTypeReferenceDirective = resolutions[index];
-      const fileName = toFileNameLowerCase(ref.fileName);
+      const fileName = ref.fileName;
       resolutionsInFile.set(fileName, getModeForFileReference(ref, file.impliedNodeFormat), resolvedTypeReferenceDirective);
       const mode = ref.resolutionMode || getDefaultResolutionModeForFile2(file);
       processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: 5 /* TypeReferenceDirective */, file: file.path, index });

package/lib/typescript.js

@@ -2368,7 +2368,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-insiders.20240513`;
+var version = `${versionMajorMinor}.0-insiders.20240515`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6394,6 +6394,7 @@ var SymbolAccessibility = /* @__PURE__ */ ((SymbolAccessibility2) => {
   SymbolAccessibility2[SymbolAccessibility2["Accessible"] = 0] = "Accessible";
   SymbolAccessibility2[SymbolAccessibility2["NotAccessible"] = 1] = "NotAccessible";
   SymbolAccessibility2[SymbolAccessibility2["CannotBeNamed"] = 2] = "CannotBeNamed";
+  SymbolAccessibility2[SymbolAccessibility2["NotResolved"] = 3] = "NotResolved";
   return SymbolAccessibility2;
 })(SymbolAccessibility || {});
 var SyntheticSymbolKind = /* @__PURE__ */ ((SyntheticSymbolKind2) => {
@@ -17550,7 +17551,8 @@ function getLeadingCommentRangesOfNode(node, sourceFileOfNode) {
 }
 function getJSDocCommentRanges(node, text) {
   const commentRanges = node.kind === 169 /* Parameter */ || node.kind === 168 /* TypeParameter */ || node.kind === 218 /* FunctionExpression */ || node.kind === 219 /* ArrowFunction */ || node.kind === 217 /* ParenthesizedExpression */ || node.kind === 260 /* VariableDeclaration */ || node.kind === 281 /* ExportSpecifier */ ? concatenate(getTrailingCommentRanges(text, node.pos), getLeadingCommentRanges(text, node.pos)) : getLeadingCommentRanges(text, node.pos);
-  return filter(commentRanges, (comment) => text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 2) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 3) !== 47 /* slash */);
+  return filter(commentRanges, (comment) => comment.end <= node.end && // Due to parse errors sometime empty parameter may get comments assigned to it that end up not in parameter range
+  text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 2) === 42 /* asterisk */ && text.charCodeAt(comment.pos + 3) !== 47 /* slash */);
 }
 var fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
 var fullTripleSlashReferenceTypeReferenceDirectiveRegEx = /^(\/\/\/\s*<reference\s+types\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
@@ -53813,7 +53815,7 @@ function createTypeChecker(host) {
       return { accessibility: 0 /* Accessible */ };
     }
     return symbol && hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) || {
-      accessibility: 1 /* NotAccessible */,
+      accessibility: 3 /* NotResolved */,
       errorSymbolName: getTextOfNode(firstIdentifier),
       errorNode: firstIdentifier
     };
@@ -53951,6 +53953,7 @@ function createTypeChecker(host) {
       if (!nodeIsSynthesized(range) && !(range.flags & 16 /* Synthesized */) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
         range = factory.cloneNode(range);
       }
+      if (range === location) return range;
       if (!location) {
         return range;
       }
@@ -56087,6 +56090,57 @@ function createTypeChecker(host) {
         return updated;
       }
     }
+    function serializeTypeName(context, node, isTypeOf, typeArguments) {
+      const meaning = isTypeOf ? 111551 /* Value */ : 788968 /* Type */;
+      const symbol = resolveEntityName(
+        node,
+        meaning,
+        /*ignoreErrors*/
+        true
+      );
+      if (!symbol) return void 0;
+      const resolvedSymbol = symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol;
+      if (isSymbolAccessible(
+        symbol,
+        context.enclosingDeclaration,
+        meaning,
+        /*shouldComputeAliasesToMakeVisible*/
+        false
+      ).accessibility !== 0 /* Accessible */) return void 0;
+      return symbolToTypeNode(resolvedSymbol, context, meaning, typeArguments);
+    }
+    function canReuseTypeNode(context, existing) {
+      if (isInJSFile(existing)) {
+        if (isLiteralImportTypeNode(existing)) {
+          void getTypeFromImportTypeNode(existing);
+          const nodeSymbol = getNodeLinks(existing).resolvedSymbol;
+          return !nodeSymbol || !// The import type resolved using jsdoc fallback logic
+          (!existing.isTypeOf && !(nodeSymbol.flags & 788968 /* Type */) || // The import type had type arguments autofilled by js fallback logic
+          !(length(existing.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))));
+        }
+      }
+      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;
+        }
+        if (isInJSDoc(existing)) {
+          return existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) && !getIntendedTypeFromJSDocTypeReference(existing) && symbol.flags & 788968 /* Type */;
+        }
+      }
+      if (isTypeOperatorNode(existing) && existing.operator === 158 /* UniqueKeyword */ && existing.type.kind === 155 /* SymbolKeyword */) {
+        const effectiveEnclosingContext = context.enclosingDeclaration && getEnclosingDeclarationIgnoringFakeScope(context.enclosingDeclaration);
+        return !!findAncestor(existing, (n) => n === effectiveEnclosingContext);
+      }
+      return true;
+    }
+    function serializeExistingTypeNode(context, typeNode) {
+      const type = getTypeFromTypeNode(typeNode);
+      return typeToTypeNodeHelper(type, context);
+    }
     function tryReuseExistingTypeNodeHelper(context, existing) {
       if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
         cancellationToken.throwIfCancellationRequested();
@@ -56096,6 +56150,7 @@ function createTypeChecker(host) {
       if (hadError) {
         return void 0;
       }
+      context.approximateLength += existing.end - existing.pos;
       return transformed;
       function visitExistingNodeTreeSymbols(node) {
         const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : void 0;
@@ -56195,20 +56250,38 @@ function createTypeChecker(host) {
             );
           }
         }
-        if (isTypeReferenceNode(node) && isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(
-          node,
-          788968 /* Type */,
-          /*ignoreErrors*/
-          true
-        ))) {
-          return setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
+        if (isTypeReferenceNode(node)) {
+          if (canReuseTypeNode(context, node)) {
+            const { introducesError, node: newName } = trackExistingEntityName(node.typeName, context);
+            const typeArguments = visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode);
+            if (!introducesError) {
+              const updated = factory.updateTypeReferenceNode(
+                node,
+                newName,
+                typeArguments
+              );
+              return setTextRange2(context, updated, node);
+            } else {
+              const serializedName = serializeTypeName(
+                context,
+                node.typeName,
+                /*isTypeOf*/
+                false,
+                typeArguments
+              );
+              if (serializedName) {
+                return setTextRange2(context, serializedName, node.typeName);
+              }
+            }
+          }
+          return serializeExistingTypeNode(context, node);
         }
         if (isLiteralImportTypeNode(node)) {
           const nodeSymbol = getNodeLinks(node).resolvedSymbol;
           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 setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
+            return setTextRange2(context, typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node);
           }
           return factory.updateImportTypeNode(
             node,
@@ -56240,13 +56313,48 @@ function createTypeChecker(host) {
           }
           return visited;
         }
-        if (isEntityName(node) || isEntityNameExpression(node)) {
-          if (isDeclarationName(node)) {
-            return node;
+        if (isTypeQueryNode(node)) {
+          const { introducesError, node: exprName } = trackExistingEntityName(node.exprName, context);
+          if (introducesError) {
+            const serializedName = serializeTypeName(
+              context,
+              node.exprName,
+              /*isTypeOf*/
+              true
+            );
+            if (serializedName) {
+              return setTextRange2(context, serializedName, node.exprName);
+            }
+            return serializeExistingTypeNode(context, node);
           }
-          const { introducesError, node: result } = trackExistingEntityName(node, context);
+          return factory.updateTypeQueryNode(
+            node,
+            exprName,
+            visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode)
+          );
+        }
+        if (isComputedPropertyName(node) && isEntityNameExpression(node.expression)) {
+          const { node: result, introducesError } = trackExistingEntityName(node.expression, context);
+          if (!introducesError) {
+            return factory.updateComputedPropertyName(node, result);
+          } else {
+            const type = getWidenedType(getRegularTypeOfExpression(node.expression));
+            const computedPropertyNameType = typeToTypeNodeHelper(type, context);
+            Debug.assertNode(computedPropertyNameType, isLiteralTypeNode);
+            const literal = computedPropertyNameType.literal;
+            if (literal.kind === 11 /* StringLiteral */ && isIdentifierText(literal.text, getEmitScriptTarget(compilerOptions))) {
+              return factory.createIdentifier(literal.text);
+            }
+            if (literal.kind === 9 /* NumericLiteral */ && !literal.text.startsWith("-")) {
+              return literal;
+            }
+            return factory.updateComputedPropertyName(node, literal);
+          }
+        }
+        if (isTypePredicateNode(node) && isIdentifier(node.parameterName)) {
+          const { node: result, introducesError } = trackExistingEntityName(node.parameterName, context);
           hadError = hadError || introducesError;
-          return result;
+          return factory.updateTypePredicateNode(node, node.assertsModifier, result, visitNode(node.type, visitExistingNodeTreeSymbols, isTypeNode));
         }
         if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
           const visited = visitEachChild(
@@ -56280,6 +56388,11 @@ function createTypeChecker(host) {
             falseType2
           );
         }
+        if (isTypeOperatorNode(node) && node.operator === 158 /* UniqueKeyword */ && node.type.kind === 155 /* SymbolKeyword */) {
+          if (!canReuseTypeNode(context, node)) {
+            return serializeExistingTypeNode(context, node);
+          }
+        }
         return visitEachChild(
           node,
           visitExistingNodeTreeSymbols,
@@ -62066,10 +62179,14 @@ function createTypeChecker(host) {
         }
         if (type || jsdocPredicate) {
           signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
-        } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType.flags & 16 /* Boolean */) && getParameterCount(signature) > 0) {
+        } else if (signature.declaration && isFunctionLikeDeclaration(signature.declaration) && (!signature.resolvedReturnType || signature.resolvedReturnType.flags & (16 /* Boolean */ | 49152 /* VoidLike */)) && getParameterCount(signature) > 0) {
           const { declaration } = signature;
           signature.resolvedTypePredicate = noTypePredicate;
-          signature.resolvedTypePredicate = getTypePredicateFromBody(declaration) || noTypePredicate;
+          if (!signature.resolvedReturnType || signature.resolvedReturnType.flags & 16 /* Boolean */) {
+            signature.resolvedTypePredicate = getTypePredicateFromBody(declaration) || noTypePredicate;
+          } else if (!signature.resolvedReturnType || signature.resolvedReturnType.flags & 49152 /* VoidLike */) {
+            signature.resolvedTypePredicate = getTypeAssertionFromBody(declaration) || noTypePredicate;
+          }
         } else {
           signature.resolvedTypePredicate = noTypePredicate;
         }
@@ -80867,6 +80984,48 @@ function createTypeChecker(host) {
     const falseSubtype = getFlowTypeOfReference(param.name, initType, trueType2, func, falseCondition);
     return falseSubtype.flags & 131072 /* Never */ ? trueType2 : void 0;
   }
+  function getTypeAssertionFromBody(func) {
+    switch (func.kind) {
+      case 176 /* Constructor */:
+      case 177 /* GetAccessor */:
+      case 178 /* SetAccessor */:
+      case 219 /* ArrowFunction */:
+      case 218 /* FunctionExpression */:
+      case 174 /* MethodDeclaration */:
+        return void 0;
+    }
+    const functionFlags = getFunctionFlags(func);
+    if (functionFlags !== 0 /* Normal */ || !func.body) return void 0;
+    const returnFlowNodes = [];
+    const bailedEarly = forEachReturnStatement(func.body, (returnStatement) => {
+      if (!returnStatement.flowNode) {
+        return true;
+      }
+      returnFlowNodes.push(returnStatement.flowNode);
+    });
+    if (bailedEarly) return void 0;
+    if (functionHasImplicitReturn(func)) {
+      returnFlowNodes.push(func.endFlowNode);
+    }
+    if (!returnFlowNodes.length) return void 0;
+    return forEach(func.parameters, (param, i) => {
+      const initType = getTypeOfSymbol(param.symbol);
+      if (!initType || !isIdentifier(param.name) || isSymbolAssigned(param.symbol) || isRestParameter(param)) {
+        return;
+      }
+      const typesAtReturn = [];
+      const bailedEarly2 = forEach(returnFlowNodes, (flowNode) => {
+        const type = getFlowTypeOfReference(param.name, initType, initType, func, flowNode);
+        if (type === initType) return true;
+        typesAtReturn.push(type);
+      });
+      if (bailedEarly2) return;
+      const assertedType = getUnionType(typesAtReturn, 2 /* Subtype */);
+      const patchedInitType = mapType(initType, (t) => t.flags & 16384 /* Void */ ? undefinedType : t.flags & 1 /* Any */ ? unknownType : t);
+      if (isTypeAssignableTo(patchedInitType, assertedType)) return;
+      return createTypePredicate(3 /* AssertsIdentifier */, unescapeLeadingUnderscores(param.name.escapedText), i, assertedType);
+    });
+  }
   function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
     addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
     return;
@@ -82245,6 +82404,10 @@ function createTypeChecker(host) {
       texts.push(span.literal.text);
       types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
     }
+    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node).value;
+    if (evaluated) {
+      return getFreshTypeOfLiteralType(getStringLiteralType(evaluated));
+    }
     if (isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType2(
       node,
       /*contextFlags*/
@@ -82252,8 +82415,7 @@ function createTypeChecker(host) {
     ) || unknownType, isTemplateLiteralContextualType)) {
       return getTemplateLiteralType(texts, types);
     }
-    const evaluated = node.parent.kind !== 215 /* TaggedTemplateExpression */ && evaluate(node).value;
-    return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
+    return stringType;
   }
   function isTemplateLiteralContextualType(type) {
     return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
@@ -115125,7 +115287,7 @@ function transformDeclarations(context) {
           }
         }
       }
-    } else {
+    } else if (symbolAccessibilityResult.accessibility !== 3 /* NotResolved */) {
       const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
       if (errorInfo) {
         if (errorInfo.typeName) {
@@ -123069,7 +123231,7 @@ function createModuleResolutionLoader(containingFile, redirectedReference, optio
   };
 }
 function getTypeReferenceResolutionName(entry) {
-  return !isString(entry) ? toFileNameLowerCase(entry.fileName) : entry;
+  return !isString(entry) ? entry.fileName : entry;
 }
 var typeReferenceResolutionNameAndModeGetter = {
   getName: getTypeReferenceResolutionName,
@@ -123825,7 +123987,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     return (_a2 = resolvedTypeReferenceDirectiveNames == null ? void 0 : resolvedTypeReferenceDirectiveNames.get(file.path)) == null ? void 0 : _a2.get(typeDirectiveName, mode);
   }
   function getResolvedTypeReferenceDirectiveFromTypeReferenceDirective(typeRef, sourceFile) {
-    return getResolvedTypeReferenceDirective(sourceFile, toFileNameLowerCase(typeRef.fileName), typeRef.resolutionMode || sourceFile.impliedNodeFormat);
+    return getResolvedTypeReferenceDirective(sourceFile, typeRef.fileName, typeRef.resolutionMode || sourceFile.impliedNodeFormat);
   }
   function forEachResolvedModule(callback, file) {
     forEachResolution(resolvedModules, callback, file);
@@ -125367,7 +125529,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     for (let index = 0; index < typeDirectives.length; index++) {
       const ref = file.typeReferenceDirectives[index];
       const resolvedTypeReferenceDirective = resolutions[index];
-      const fileName = toFileNameLowerCase(ref.fileName);
+      const fileName = ref.fileName;
       resolutionsInFile.set(fileName, getModeForFileReference(ref, file.impliedNodeFormat), resolvedTypeReferenceDirective);
       const mode = ref.resolutionMode || getDefaultResolutionModeForFile2(file);
       processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: 5 /* TypeReferenceDirective */, file: file.path, index });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.5.0-pr-58528-2",
+  "version": "5.5.0-pr-58495-31",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [