@typescript-deploys/pr-build 5.5.0-pr-57772-2 → 5.5.0-pr-57465-110

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.20240314`;
+var version = `${versionMajorMinor}.0-insiders.20240315`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -39813,7 +39813,7 @@ function createBinder() {
       inAssignmentPattern = saveInAssignmentPattern;
       return;
     }
-    if (node.kind >= 243 /* FirstStatement */ && node.kind <= 259 /* LastStatement */ && !options.allowUnreachableCode) {
+    if (node.kind >= 243 /* FirstStatement */ && node.kind <= 259 /* LastStatement */ && (!options.allowUnreachableCode || node.kind === 253 /* ReturnStatement */)) {
       node.flowNode = currentFlow;
     }
     switch (node.kind) {
@@ -47787,18 +47787,7 @@ function createTypeChecker(host) {
   function createNodeBuilder() {
     return {
       typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
-      expressionOrTypeToTypeNode: (type, expr, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
-      serializeTypeForDeclaration: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(
-        context,
-        type,
-        symbol,
-        enclosingDeclaration,
-        /*includePrivateSymbol*/
-        void 0,
-        /*bundled*/
-        void 0,
-        addUndefined
-      )),
+      typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
       indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
@@ -47820,47 +47809,6 @@ function createTypeChecker(host) {
       symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker, bundled) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context, bundled)),
       symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
-    function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
-      if (expr) {
-        const typeNode = isAssertionExpression(expr) ? expr.type : isJSDocTypeAssertion(expr) ? getJSDocTypeAssertionType(expr) : void 0;
-        if (typeNode && !isConstTypeReference(typeNode)) {
-          const result = tryReuseExistingTypeNode(context, typeNode, type, expr.parent, addUndefined);
-          if (result) {
-            return result;
-          }
-        }
-      }
-      if (addUndefined) {
-        type = getOptionalType(type);
-      }
-      return typeToTypeNodeHelper(type, context);
-    }
-    function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined, includePrivateSymbol, bundled) {
-      const originalType = type;
-      if (addUndefined) {
-        type = getOptionalType(type);
-      }
-      const clone = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2, includePrivateSymbol, bundled);
-      if (clone) {
-        return clone;
-      }
-      if (addUndefined && originalType !== type) {
-        const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2, includePrivateSymbol, bundled);
-        if (cloneMissingUndefined) {
-          return factory.createUnionTypeNode([cloneMissingUndefined, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
-        }
-      }
-      return void 0;
-    }
-    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, includePrivateSymbol, bundled, annotationType) {
-      if (typeNodeIsEquivalentToType(existing, host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
-        const result = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
-        if (result) {
-          return result;
-        }
-      }
-      return void 0;
-    }
     function symbolToNode(symbol, context, meaning) {
       if (context.flags & 1073741824 /* WriteComputedProps */) {
         if (symbol.valueDeclaration) {
@@ -48302,8 +48250,8 @@ function createTypeChecker(host) {
           if (isInstantiationExpressionType) {
             const instantiationExpressionType = type2;
             const existing = instantiationExpressionType.node;
-            if (isTypeQueryNode(existing)) {
-              const typeNode = tryReuseExistingNonParameterTypeNode(context, existing, type2);
+            if (isTypeQueryNode(existing) && getTypeFromTypeNode(existing) === type2) {
+              const typeNode = serializeExistingTypeNode(context, existing);
               if (typeNode) {
                 return typeNode;
               }
@@ -48966,10 +48914,7 @@ function createTypeChecker(host) {
       let returnTypeNode;
       const typePredicate = getTypePredicateOfSignature(signature);
       if (typePredicate) {
-        const assertsModifier = typePredicate.kind === 2 /* AssertsThis */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createToken(131 /* AssertsKeyword */) : void 0;
-        const parameterName = typePredicate.kind === 1 /* Identifier */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? setEmitFlags(factory.createIdentifier(typePredicate.parameterName), 16777216 /* NoAsciiEscaping */) : factory.createThisTypeNode();
-        const typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context);
-        returnTypeNode = factory.createTypePredicateNode(assertsModifier, parameterName, typeNode);
+        returnTypeNode = typePredicateToTypePredicateNodeHelper(typePredicate, context);
       } else {
         const returnType = getReturnTypeOfSignature(signature);
         if (returnType && !(suppressAny && isTypeAny(returnType))) {
@@ -49095,6 +49040,12 @@ function createTypeChecker(host) {
       const constraintNode = constraint && typeToTypeNodeHelper(constraint, context);
       return typeParameterToDeclarationWithConstraint(type, context, constraintNode);
     }
+    function typePredicateToTypePredicateNodeHelper(typePredicate, context) {
+      const assertsModifier = typePredicate.kind === 2 /* AssertsThis */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createToken(131 /* AssertsKeyword */) : void 0;
+      const parameterName = typePredicate.kind === 1 /* Identifier */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? setEmitFlags(factory.createIdentifier(typePredicate.parameterName), 16777216 /* NoAsciiEscaping */) : factory.createThisTypeNode();
+      const typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context);
+      return factory.createTypePredicateNode(assertsModifier, parameterName, typeNode);
+    }
     function getEffectiveParameterDeclaration(parameterSymbol) {
       const parameterDeclaration = getDeclarationOfKind(parameterSymbol, 169 /* Parameter */);
       if (parameterDeclaration) {
@@ -49106,9 +49057,11 @@ function createTypeChecker(host) {
     }
     function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
       const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
-      const parameterType = getTypeOfSymbol(parameterSymbol);
-      const addUndefined = parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration);
-      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports, addUndefined);
+      let parameterType = getTypeOfSymbol(parameterSymbol);
+      if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
+        parameterType = getOptionalType(parameterType);
+      }
+      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports);
       const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
       const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
       const dotDotDotToken = isRest ? factory.createToken(26 /* DotDotDotToken */) : void 0;
@@ -49698,15 +49651,16 @@ function createTypeChecker(host) {
       }
       return enclosingDeclaration;
     }
-    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled, addUndefined) {
-      var _a;
+    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
       if (!isErrorType(type) && enclosingDeclaration) {
         const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
-          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined, includePrivateSymbol, bundled);
-          if (result2) {
-            return result2;
+          if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
+            const result2 = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
+            if (result2) {
+              return result2;
+            }
           }
         }
       }
@@ -49714,17 +49668,16 @@ function createTypeChecker(host) {
       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 = symbol.valueDeclaration || ((_a = symbol.declarations) == null ? void 0 : _a[0]);
-      const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : void 0;
-      const result = expressionOrTypeToTypeNode(context, expr, type, addUndefined);
+      const result = typeToTypeNodeHelper(type, context);
       context.flags = oldFlags;
       return result;
     }
-    function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type, typeFromTypeNode = getTypeFromTypeNode(typeNode)) {
+    function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type) {
+      const typeFromTypeNode = getTypeFromTypeNode(typeNode);
       if (typeFromTypeNode === type) {
         return true;
       }
-      if (annotatedDeclaration && (isParameter(annotatedDeclaration) || isPropertyDeclaration(annotatedDeclaration)) && annotatedDeclaration.questionToken) {
+      if (isParameter(annotatedDeclaration) && annotatedDeclaration.questionToken) {
         return getTypeWithFacts(type, 524288 /* NEUndefined */) === typeFromTypeNode;
       }
       return false;
@@ -49736,9 +49689,11 @@ function createTypeChecker(host) {
         if (!!findAncestor(annotation, (n) => n === enclosingDeclarationIgnoringFakeScope) && annotation) {
           const annotated = getTypeFromTypeNode(annotation);
           const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
-          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, includePrivateSymbol, bundled, thisInstantiated);
-          if (result) {
-            return result;
+          if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
+            const result = serializeExistingTypeNode(context, annotation, includePrivateSymbol, bundled);
+            if (result) {
+              return result;
+            }
           }
         }
       }
@@ -49767,9 +49722,7 @@ function createTypeChecker(host) {
           /*shouldComputeAliasesToMakeVisible*/
           false
         ).accessibility !== 0 /* Accessible */) {
-          if (!isDeclarationName(node)) {
-            introducesError = true;
-          }
+          introducesError = true;
         } else {
           context.tracker.trackSymbol(sym, context.enclosingDeclaration, -1 /* All */);
           includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
@@ -49907,31 +49860,6 @@ function createTypeChecker(host) {
             node.isTypeOf
           );
         }
-        if (isParameter(node)) {
-          if (!node.type && !node.initializer) {
-            return factory.updateParameterDeclaration(
-              node,
-              /*modifiers*/
-              void 0,
-              node.dotDotDotToken,
-              visitEachChild(
-                node.name,
-                visitExistingNodeTreeSymbols,
-                /*context*/
-                void 0
-              ),
-              node.questionToken,
-              factory.createKeywordTypeNode(133 /* AnyKeyword */),
-              /*initializer*/
-              void 0
-            );
-          }
-        }
-        if (isPropertySignature(node)) {
-          if (!node.type && !node.initializer) {
-            return factory.updatePropertySignature(node, node.modifiers, node.name, node.questionToken, factory.createKeywordTypeNode(133 /* AnyKeyword */));
-          }
-        }
         if (isEntityName(node) || isEntityNameExpression(node)) {
           const { introducesError, node: result } = trackExistingEntityName(node, context, includePrivateSymbol);
           hadError = hadError || introducesError;
@@ -49939,7 +49867,7 @@ function createTypeChecker(host) {
             return result;
           }
         }
-        if (file && isTupleTypeNode(node) && !nodeIsSynthesized(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
+        if (file && isTupleTypeNode(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
           setEmitFlags(node, 1 /* SingleLine */);
         }
         return visitEachChild(
@@ -50463,15 +50391,7 @@ function createTypeChecker(host) {
         context.flags |= 8388608 /* InTypeAlias */;
         const oldEnclosingDecl = context.enclosingDeclaration;
         context.enclosingDeclaration = jsdocAliasDecl;
-        const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && tryReuseExistingNonParameterTypeNode(
-          context,
-          jsdocAliasDecl.typeExpression.type,
-          aliasType,
-          /*host*/
-          void 0,
-          includePrivateSymbol,
-          bundled
-        ) || typeToTypeNodeHelper(aliasType, context);
+        const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && serializeExistingTypeNode(context, jsdocAliasDecl.typeExpression.type, includePrivateSymbol, bundled) || typeToTypeNodeHelper(aliasType, context);
         addResult(
           setSyntheticLeadingComments(
             factory.createTypeAliasDeclaration(
@@ -50704,15 +50624,7 @@ function createTypeChecker(host) {
           }
           return cleanup(factory.createExpressionWithTypeArguments(
             expr,
-            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(
-              context,
-              a,
-              getTypeFromTypeNode(a),
-              /*host*/
-              void 0,
-              includePrivateSymbol,
-              bundled
-            ) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
+            map(e.typeArguments, (a) => serializeExistingTypeNode(context, a, includePrivateSymbol, bundled) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
           ));
           function cleanup(result2) {
             context.enclosingDeclaration = oldEnclosing;
@@ -51171,10 +51083,8 @@ function createTypeChecker(host) {
         }
       }
       function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, hostSymbol) {
-        var _a2;
         const ctxSrc = getSourceFileOfNode(context.enclosingDeclaration);
-        return getObjectFlags(typeToSerialize) & (16 /* Anonymous */ | 32 /* Mapped */) && !some((_a2 = typeToSerialize.symbol) == null ? void 0 : _a2.declarations, isTypeNode) && // If the type comes straight from a type node, we shouldn't try to break it up
-        !length(getIndexInfosOfType(typeToSerialize)) && !isClassInstanceSide(typeToSerialize) && // While a class instance is potentially representable as a NS, prefer printing a reference to the instance type and serializing the class
+        return getObjectFlags(typeToSerialize) & (16 /* Anonymous */ | 32 /* Mapped */) && !length(getIndexInfosOfType(typeToSerialize)) && !isClassInstanceSide(typeToSerialize) && // While a class instance is potentially representable as a NS, prefer printing a reference to the instance type and serializing the class
         !!(length(filter(getPropertiesOfType(typeToSerialize), isNamespaceMember)) || length(getSignaturesOfType(typeToSerialize, 0 /* Call */))) && !length(getSignaturesOfType(typeToSerialize, 1 /* Construct */)) && // TODO: could probably serialize as function + ns + class, now that that's OK
         !getDeclarationWithTypeAnnotation(hostSymbol, enclosingDeclaration) && !(typeToSerialize.symbol && some(typeToSerialize.symbol.declarations, (d) => getSourceFileOfNode(d) !== ctxSrc)) && !some(getPropertiesOfType(typeToSerialize), (p) => isLateBoundName(p.escapedName)) && !some(getPropertiesOfType(typeToSerialize), (p) => some(p.declarations, (d) => getSourceFileOfNode(d) !== ctxSrc)) && every(getPropertiesOfType(typeToSerialize), (p) => {
           if (!isIdentifierText(symbolName(p), languageVersion)) {
@@ -51497,12 +51407,8 @@ function createTypeChecker(host) {
   function typePredicateToString(typePredicate, enclosingDeclaration, flags = 16384 /* UseAliasDefinedOutsideCurrentScope */, writer) {
     return writer ? typePredicateToStringWorker(writer).getText() : usingSingleLineStringWriter(typePredicateToStringWorker);
     function typePredicateToStringWorker(writer2) {
-      const predicate = factory.createTypePredicateNode(
-        typePredicate.kind === 2 /* AssertsThis */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createToken(131 /* AssertsKeyword */) : void 0,
-        typePredicate.kind === 1 /* Identifier */ || typePredicate.kind === 3 /* AssertsIdentifier */ ? factory.createIdentifier(typePredicate.parameterName) : factory.createThisTypeNode(),
-        typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | 512 /* WriteTypeParametersInQualifiedName */)
-        // TODO: GH#18217
-      );
+      const nodeBuilderFlags = toNodeBuilderFlags(flags) | 70221824 /* IgnoreErrors */ | 512 /* WriteTypeParametersInQualifiedName */;
+      const predicate = nodeBuilder.typePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, nodeBuilderFlags);
       const printer = createPrinterWithRemoveComments();
       const sourceFile = enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration);
       printer.writeNode(
@@ -55753,7 +55659,15 @@ function createTypeChecker(host) {
             jsdocPredicate = getTypePredicateOfSignature(jsdocSignature);
           }
         }
-        signature.resolvedTypePredicate = type && isTypePredicateNode(type) ? createTypePredicateFromTypePredicateNode(type, signature) : jsdocPredicate || noTypePredicate;
+        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) {
+          const { declaration } = signature;
+          signature.resolvedTypePredicate = noTypePredicate;
+          signature.resolvedTypePredicate = getTypePredicateFromBody(declaration) || noTypePredicate;
+        } else {
+          signature.resolvedTypePredicate = noTypePredicate;
+        }
       }
       Debug.assert(!!signature.resolvedTypePredicate);
     }
@@ -57941,6 +57855,7 @@ function createTypeChecker(host) {
     return links.resolvedType;
   }
   function getTemplateLiteralType(texts, types) {
+    var _a, _b;
     const unionIndex = findIndex(types, (t) => !!(t.flags & (131072 /* Never */ | 1048576 /* Union */)));
     if (unionIndex >= 0) {
       return checkCrossProductUnion(types) ? mapType(types[unionIndex], (t) => getTemplateLiteralType(texts, replaceElement(types, unionIndex, t))) : errorType;
@@ -57948,6 +57863,9 @@ function createTypeChecker(host) {
     if (contains(types, wildcardType)) {
       return wildcardType;
     }
+    if (texts.length === 2 && texts[0] === "" && texts[1] === "" && !(types[0].flags & 2944 /* Literal */) && !((_b = (_a = types[0].symbol) == null ? void 0 : _a.declarations) == null ? void 0 : _b.some((d) => d.parent.kind === 195 /* InferType */)) && isTypeAssignableTo(types[0], stringType)) {
+      return types[0];
+    }
     const newTypes = [];
     const newTexts = [];
     let text = texts[0];
@@ -74183,6 +74101,67 @@ function createTypeChecker(host) {
         return false;
     }
   }
+  function getTypePredicateFromBody(func) {
+    switch (func.kind) {
+      case 176 /* Constructor */:
+      case 177 /* GetAccessor */:
+      case 178 /* SetAccessor */:
+        return void 0;
+    }
+    const functionFlags = getFunctionFlags(func);
+    if (functionFlags !== 0 /* Normal */)
+      return void 0;
+    let singleReturn;
+    if (func.body && func.body.kind !== 241 /* Block */) {
+      singleReturn = func.body;
+    } else {
+      const bailedEarly = forEachReturnStatement(func.body, (returnStatement) => {
+        if (singleReturn || !returnStatement.expression)
+          return true;
+        singleReturn = returnStatement.expression;
+      });
+      if (bailedEarly || !singleReturn || functionHasImplicitReturn(func))
+        return void 0;
+    }
+    return checkIfExpressionRefinesAnyParameter(func, singleReturn);
+  }
+  function checkIfExpressionRefinesAnyParameter(func, expr) {
+    expr = skipParentheses(
+      expr,
+      /*excludeJSDocTypeAssertions*/
+      true
+    );
+    const returnType = checkExpressionCached(expr);
+    if (!(returnType.flags & 16 /* Boolean */))
+      return void 0;
+    return forEach(func.parameters, (param, i) => {
+      const initType = getTypeOfSymbol(param.symbol);
+      if (!initType || initType.flags & 16 /* Boolean */ || !isIdentifier(param.name) || isSymbolAssigned(param.symbol) || isRestParameter(param)) {
+        return;
+      }
+      const trueType2 = checkIfExpressionRefinesParameter(func, expr, param, initType);
+      if (trueType2) {
+        return createTypePredicate(1 /* Identifier */, unescapeLeadingUnderscores(param.name.escapedText), i, trueType2);
+      }
+    });
+  }
+  function checkIfExpressionRefinesParameter(func, expr, param, initType) {
+    const antecedent = expr.flowNode || expr.parent.kind === 253 /* ReturnStatement */ && expr.parent.flowNode || { flags: 2 /* Start */ };
+    const trueCondition = {
+      flags: 32 /* TrueCondition */,
+      node: expr,
+      antecedent
+    };
+    const trueType2 = getFlowTypeOfReference(param.name, initType, initType, func, trueCondition);
+    if (trueType2 === initType)
+      return void 0;
+    const falseCondition = {
+      ...trueCondition,
+      flags: 64 /* FalseCondition */
+    };
+    const falseSubtype = getFlowTypeOfReference(param.name, trueType2, trueType2, func, falseCondition);
+    return falseSubtype.flags & 131072 /* Never */ ? trueType2 : void 0;
+  }
   function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
     addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics);
     return;
@@ -82935,34 +82914,14 @@ function createTypeChecker(host) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const symbol = getSymbolOfDeclaration(declaration);
-    const type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
-    return nodeBuilder.serializeTypeForDeclaration(type, symbol, addUndefined, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
-  }
-  function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
-    return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
-  }
-  function getPossibleTypeNodeReuseExpression(declaration) {
-    var _a;
-    return isFunctionLike(declaration) && !isSetAccessor(declaration) ? getSingleReturnExpression(declaration) : isExportAssignment(declaration) ? declaration.expression : !!declaration.initializer ? declaration.initializer : isParameter(declaration) && isSetAccessor(declaration.parent) ? getSingleReturnExpression(getAllAccessorDeclarations((_a = getSymbolOfDeclaration(declaration.parent)) == null ? void 0 : _a.declarations, declaration.parent).getAccessor) : void 0;
-  }
-  function getSingleReturnExpression(declaration) {
-    let candidateExpr;
-    if (declaration && !nodeIsMissing(declaration.body)) {
-      const body = declaration.body;
-      if (body && isBlock(body)) {
-        forEachReturnStatement(body, (s) => {
-          if (!candidateExpr) {
-            candidateExpr = s.expression;
-          } else {
-            candidateExpr = void 0;
-            return true;
-          }
-        });
-      } else {
-        candidateExpr = body;
-      }
+    let type = symbol && !(symbol.flags & (2048 /* TypeLiteral */ | 131072 /* Signature */)) ? getWidenedLiteralType(getTypeOfSymbol(symbol)) : errorType;
+    if (type.flags & 8192 /* UniqueESSymbol */ && type.symbol === symbol) {
+      flags |= 1048576 /* AllowUniqueESSymbolType */;
+    }
+    if (addUndefined) {
+      type = getOptionalType(type);
     }
-    return candidateExpr;
+    return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
   }
   function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
     const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike);
@@ -82970,15 +82929,11 @@ function createTypeChecker(host) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const signature = getSignatureFromDeclaration(signatureDeclaration);
-    return nodeBuilder.expressionOrTypeToTypeNode(
-      getReturnTypeOfSignature(signature),
-      getPossibleTypeNodeReuseExpression(signatureDeclaration),
-      /*addUndefined*/
-      void 0,
-      enclosingDeclaration,
-      flags | 1024 /* MultilineObjectLiterals */,
-      tracker
-    );
+    const typePredicate = getTypePredicateOfSignature(signature);
+    if (typePredicate) {
+      return nodeBuilder.typePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    }
+    return nodeBuilder.typeToTypeNode(getReturnTypeOfSignature(signature), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
   }
   function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
@@ -82986,15 +82941,7 @@ function createTypeChecker(host) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const type = getWidenedType(getRegularTypeOfExpression(expr));
-    return nodeBuilder.expressionOrTypeToTypeNode(
-      type,
-      expr,
-      /*addUndefined*/
-      void 0,
-      enclosingDeclaration,
-      flags | 1024 /* MultilineObjectLiterals */,
-      tracker
-    );
+    return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
   }
   function hasGlobalName(name) {
     return globals.has(escapeLeadingUnderscores(name));