typescript 5.5.0-dev.20240318 → 5.5.0-dev.20240319

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-dev.20240318`;
+var version = `${versionMajorMinor}.0-dev.20240319`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -33758,6 +33758,7 @@ var libEntries = [
   ["esnext.weakref", "lib.es2021.weakref.d.ts"],
   ["esnext.decorators", "lib.esnext.decorators.d.ts"],
   ["esnext.object", "lib.esnext.object.d.ts"],
+  ["esnext.regexp", "lib.esnext.regexp.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -47781,6 +47782,18 @@ function createTypeChecker(host) {
     return {
       typeToTypeNode: (type, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeToTypeNodeHelper(type, context)),
       typePredicateToTypePredicateNode: (typePredicate, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
+      expressionOrTypeToTypeNode: (expr, type, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
+      serializeTypeForDeclaration: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(
+        context,
+        type,
+        symbol,
+        enclosingDeclaration,
+        /*includePrivateSymbol*/
+        void 0,
+        /*bundled*/
+        void 0,
+        addUndefined
+      )),
       indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
@@ -47802,6 +47815,50 @@ 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) {
+        if (addUndefined && !someType(getTypeFromTypeNode(typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
+          return factory.createUnionTypeNode([clone, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
+        }
+        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 = tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled);
+        if (result) {
+          return result;
+        }
+      }
+      return void 0;
+    }
     function symbolToNode(symbol, context, meaning) {
       if (context.flags & 1073741824 /* WriteComputedProps */) {
         if (symbol.valueDeclaration) {
@@ -48243,8 +48300,8 @@ function createTypeChecker(host) {
           if (isInstantiationExpressionType) {
             const instantiationExpressionType = type2;
             const existing = instantiationExpressionType.node;
-            if (isTypeQueryNode(existing) && getTypeFromTypeNode(existing) === type2) {
-              const typeNode = serializeExistingTypeNode(context, existing);
+            if (isTypeQueryNode(existing)) {
+              const typeNode = tryReuseExistingNonParameterTypeNode(context, existing, type2);
               if (typeNode) {
                 return typeNode;
               }
@@ -49050,11 +49107,9 @@ function createTypeChecker(host) {
     }
     function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
       const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
-      let parameterType = getTypeOfSymbol(parameterSymbol);
-      if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) {
-        parameterType = getOptionalType(parameterType);
-      }
-      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports);
+      const parameterType = getTypeOfSymbol(parameterSymbol);
+      const addUndefined = parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration);
+      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports, addUndefined);
       const modifiers = !(context.flags & 8192 /* OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : void 0;
       const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & 32768 /* RestParameter */;
       const dotDotDotToken = isRest ? factory.createToken(26 /* DotDotDotToken */) : void 0;
@@ -49644,16 +49699,15 @@ function createTypeChecker(host) {
       }
       return enclosingDeclaration;
     }
-    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) {
+    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled, addUndefined) {
+      var _a;
       if (!isErrorType(type) && enclosingDeclaration) {
         const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getEffectiveTypeAnnotationNode(declWithExistingAnnotation);
-          if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
-            const result2 = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled);
-            if (result2) {
-              return result2;
-            }
+          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined, includePrivateSymbol, bundled);
+          if (result2) {
+            return result2;
           }
         }
       }
@@ -49661,16 +49715,17 @@ 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 result = typeToTypeNodeHelper(type, context);
+      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);
       context.flags = oldFlags;
       return result;
     }
-    function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type) {
-      const typeFromTypeNode = getTypeFromTypeNode(typeNode);
+    function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type, typeFromTypeNode = getTypeFromTypeNode(typeNode)) {
       if (typeFromTypeNode === type) {
         return true;
       }
-      if (isParameter(annotatedDeclaration) && annotatedDeclaration.questionToken) {
+      if (annotatedDeclaration && (isParameter(annotatedDeclaration) || isPropertyDeclaration(annotatedDeclaration)) && annotatedDeclaration.questionToken) {
         return getTypeWithFacts(type, 524288 /* NEUndefined */) === typeFromTypeNode;
       }
       return false;
@@ -49682,11 +49737,9 @@ 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;
-          if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) {
-            const result = serializeExistingTypeNode(context, annotation, includePrivateSymbol, bundled);
-            if (result) {
-              return result;
-            }
+          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, includePrivateSymbol, bundled, thisInstantiated);
+          if (result) {
+            return result;
           }
         }
       }
@@ -49715,7 +49768,9 @@ function createTypeChecker(host) {
           /*shouldComputeAliasesToMakeVisible*/
           false
         ).accessibility !== 0 /* Accessible */) {
-          introducesError = true;
+          if (!isDeclarationName(node)) {
+            introducesError = true;
+          }
         } else {
           context.tracker.trackSymbol(sym, context.enclosingDeclaration, -1 /* All */);
           includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
@@ -49729,7 +49784,7 @@ function createTypeChecker(host) {
       }
       return { introducesError, node };
     }
-    function serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled) {
+    function tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled) {
       if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
         cancellationToken.throwIfCancellationRequested();
       }
@@ -49853,6 +49908,31 @@ 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;
@@ -49860,7 +49940,7 @@ function createTypeChecker(host) {
             return result;
           }
         }
-        if (file && isTupleTypeNode(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
+        if (file && isTupleTypeNode(node) && !nodeIsSynthesized(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
           setEmitFlags(node, 1 /* SingleLine */);
         }
         return visitEachChild(
@@ -50384,7 +50464,15 @@ function createTypeChecker(host) {
         context.flags |= 8388608 /* InTypeAlias */;
         const oldEnclosingDecl = context.enclosingDeclaration;
         context.enclosingDeclaration = jsdocAliasDecl;
-        const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && serializeExistingTypeNode(context, jsdocAliasDecl.typeExpression.type, includePrivateSymbol, bundled) || typeToTypeNodeHelper(aliasType, context);
+        const typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression && isJSDocTypeExpression(jsdocAliasDecl.typeExpression) && tryReuseExistingNonParameterTypeNode(
+          context,
+          jsdocAliasDecl.typeExpression.type,
+          aliasType,
+          /*host*/
+          void 0,
+          includePrivateSymbol,
+          bundled
+        ) || typeToTypeNodeHelper(aliasType, context);
         addResult(
           setSyntheticLeadingComments(
             factory.createTypeAliasDeclaration(
@@ -50617,7 +50705,15 @@ function createTypeChecker(host) {
           }
           return cleanup(factory.createExpressionWithTypeArguments(
             expr,
-            map(e.typeArguments, (a) => serializeExistingTypeNode(context, a, includePrivateSymbol, bundled) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
+            map(e.typeArguments, (a) => tryReuseExistingNonParameterTypeNode(
+              context,
+              a,
+              getTypeFromTypeNode(a),
+              /*host*/
+              void 0,
+              includePrivateSymbol,
+              bundled
+            ) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
           ));
           function cleanup(result2) {
             context.enclosingDeclaration = oldEnclosing;
@@ -51076,8 +51172,10 @@ function createTypeChecker(host) {
         }
       }
       function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, hostSymbol) {
+        var _a2;
         const ctxSrc = getSourceFileOfNode(context.enclosingDeclaration);
-        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
+        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
         !!(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)) {
@@ -54951,13 +55049,16 @@ function createTypeChecker(host) {
       const constraint = getConstraintTypeFromMappedType(type);
       if (constraint.flags & 4194304 /* Index */) {
         const baseConstraint = getBaseConstraintOfType(constraint.type);
-        if (baseConstraint && everyType(baseConstraint, isArrayOrTupleType)) {
+        if (baseConstraint && everyType(baseConstraint, (t) => isArrayOrTupleType(t) || isArrayOrTupleOrIntersection(t))) {
           return instantiateType(target, prependTypeMapping(typeVariable, baseConstraint, type.mapper));
         }
       }
     }
     return type;
   }
+  function isArrayOrTupleOrIntersection(type) {
+    return !!(type.flags & 2097152 /* Intersection */) && every(type.types, isArrayOrTupleType);
+  }
   function isMappedTypeGenericIndexedAccess(type) {
     let objectType;
     return !!(type.flags & 8388608 /* IndexedAccess */ && getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ && !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) && !(getMappedTypeModifiers(objectType) & 8 /* ExcludeOptional */) && !objectType.declaration.nameType);
@@ -59349,29 +59450,28 @@ function createTypeChecker(host) {
     if (typeVariable) {
       const mappedTypeVariable = instantiateType(typeVariable, mapper);
       if (typeVariable !== mappedTypeVariable) {
-        return mapTypeWithAlias(
-          getReducedType(mappedTypeVariable),
-          (t) => {
-            if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
-              if (!type.declaration.nameType) {
-                let constraint;
-                if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) {
-                  return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
-                }
-                if (isTupleType(t)) {
-                  return instantiateMappedTupleType(t, type, typeVariable, mapper);
-                }
-              }
-              return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
-            }
-            return t;
-          },
-          aliasSymbol,
-          aliasTypeArguments
-        );
+        return mapTypeWithAlias(getReducedType(mappedTypeVariable), instantiateConstituent, aliasSymbol, aliasTypeArguments);
       }
     }
     return instantiateType(getConstraintTypeFromMappedType(type), mapper) === wildcardType ? wildcardType : instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments);
+    function instantiateConstituent(t) {
+      if (t.flags & (3 /* AnyOrUnknown */ | 58982400 /* InstantiableNonPrimitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && t !== wildcardType && !isErrorType(t)) {
+        if (!type.declaration.nameType) {
+          let constraint;
+          if (isArrayType(t) || t.flags & 1 /* Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* ImmediateBaseConstraint */) < 0 && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) {
+            return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
+          }
+          if (isTupleType(t)) {
+            return instantiateMappedTupleType(t, type, typeVariable, mapper);
+          }
+          if (isArrayOrTupleOrIntersection(t)) {
+            return getIntersectionType(map(t.types, instantiateConstituent));
+          }
+        }
+        return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
+      }
+      return t;
+    }
   }
   function getModifiedReadonlyState(state, modifiers) {
     return modifiers & 1 /* IncludeReadonly */ ? true : modifiers & 2 /* ExcludeReadonly */ ? false : state;
@@ -64274,7 +64374,9 @@ function createTypeChecker(host) {
     return false;
   }
   function inferTypesFromTemplateLiteralType(source, target) {
-    return source.flags & 128 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arraysEqual(source.texts, target.texts) ? map(source.types, getStringLikeTypeForType) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
+    return source.flags & 128 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arraysEqual(source.texts, target.texts) ? map(source.types, (s, i) => {
+      return isTypeAssignableTo(getBaseConstraintOrType(s), getBaseConstraintOrType(target.types[i])) ? s : getStringLikeTypeForType(s);
+    }) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
   }
   function isTypeMatchedByTemplateLiteralType(source, target) {
     const inferences = inferTypesFromTemplateLiteralType(source, target);
@@ -82907,14 +83009,34 @@ function createTypeChecker(host) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const symbol = getSymbolOfDeclaration(declaration);
-    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);
+    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;
+      }
     }
-    return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return candidateExpr;
   }
   function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) {
     const signatureDeclaration = getParseTreeNode(signatureDeclarationIn, isFunctionLike);
@@ -82926,7 +83048,15 @@ function createTypeChecker(host) {
     if (typePredicate) {
       return nodeBuilder.typePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
     }
-    return nodeBuilder.typeToTypeNode(getReturnTypeOfSignature(signature), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.expressionOrTypeToTypeNode(
+      getPossibleTypeNodeReuseExpression(signatureDeclaration),
+      getReturnTypeOfSignature(signature),
+      /*addUndefined*/
+      void 0,
+      enclosingDeclaration,
+      flags | 1024 /* MultilineObjectLiterals */,
+      tracker
+    );
   }
   function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
@@ -82934,7 +83064,15 @@ function createTypeChecker(host) {
       return factory.createToken(133 /* AnyKeyword */);
     }
     const type = getWidenedType(getRegularTypeOfExpression(expr));
-    return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
+    return nodeBuilder.expressionOrTypeToTypeNode(
+      expr,
+      type,
+      /*addUndefined*/
+      void 0,
+      enclosingDeclaration,
+      flags | 1024 /* MultilineObjectLiterals */,
+      tracker
+    );
   }
   function hasGlobalName(name) {
     return globals.has(escapeLeadingUnderscores(name));
@@ -108454,10 +108592,10 @@ function transformDeclarations(context) {
             return newFile;
           }
           needsDeclare = true;
-          const updated2 = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
+          const updated = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
           return factory2.updateSourceFile(
             sourceFile,
-            transformAndReplaceLatePaintedStatements(updated2),
+            transformAndReplaceLatePaintedStatements(updated),
             /*isDeclarationFile*/
             true,
             /*referencedFiles*/
@@ -108521,7 +108659,7 @@ function transformDeclarations(context) {
         combinedStatements = setTextRange(factory2.createNodeArray([...combinedStatements, createEmptyExports(factory2)]), combinedStatements);
       }
     }
-    const updated = factory2.updateSourceFile(
+    return factory2.updateSourceFile(
       node,
       combinedStatements,
       /*isDeclarationFile*/
@@ -108531,8 +108669,6 @@ function transformDeclarations(context) {
       node.hasNoDefaultLib,
       getLibReferences()
     );
-    updated.exportedModulesFromDeclarationEmit = exportedModulesFromDeclarationEmit;
-    return updated;
     function getLibReferences() {
       return arrayFrom(libs2.keys(), (lib) => ({ fileName: lib, pos: -1, end: -1 }));
     }
@@ -119977,12 +120113,11 @@ var BuilderState;
   }
   BuilderState2.canReuseOldState = canReuseOldState;
   function create(newProgram, oldState, disableUseFileVersionAsSignature) {
-    var _a, _b, _c;
+    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 exportedModulesMap = referencedMap ? createManyToManyPathMap() : void 0;
     const useOldState = canReuseOldState(referencedMap, oldState);
     newProgram.getTypeChecker();
     for (const sourceFile of newProgram.getSourceFiles()) {
@@ -119994,13 +120129,6 @@ var BuilderState;
         if (newReferences) {
           referencedMap.set(sourceFile.resolvedPath, newReferences);
         }
-        if (useOldState) {
-          const oldUncommittedExportedModules = (_c = oldState.oldExportedModulesMap) == null ? void 0 : _c.get(sourceFile.resolvedPath);
-          const exportedModules = oldUncommittedExportedModules === void 0 ? oldState.exportedModulesMap.getValues(sourceFile.resolvedPath) : oldUncommittedExportedModules || void 0;
-          if (exportedModules) {
-            exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
-          }
-        }
       }
       fileInfos.set(sourceFile.resolvedPath, {
         version: version2,
@@ -120013,7 +120141,6 @@ var BuilderState;
     return {
       fileInfos,
       referencedMap,
-      exportedModulesMap,
       useFileVersionAsSignature: !disableUseFileVersionAsSignature && !useOldState
     };
   }
@@ -120024,7 +120151,7 @@ var BuilderState;
   }
   BuilderState2.releaseCache = releaseCache2;
   function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, host) {
-    var _a, _b;
+    var _a;
     const result = getFilesAffectedByWithOldState(
       state,
       programOfThisState,
@@ -120033,7 +120160,6 @@ var BuilderState;
       host
     );
     (_a = state.oldSignatures) == null ? void 0 : _a.clear();
-    (_b = state.oldExportedModulesMap) == null ? void 0 : _b.clear();
     return result;
   }
   BuilderState2.getFilesAffectedBy = getFilesAffectedBy;
@@ -120087,24 +120213,16 @@ var BuilderState;
     const prevSignature = info.signature;
     let latestSignature;
     if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
-      computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, (signature, sourceFiles) => {
+      computeDtsSignature(programOfThisState, sourceFile, cancellationToken, host, (signature) => {
         latestSignature = signature;
-        if (latestSignature !== prevSignature) {
-          updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit);
-        }
+        if (host.storeSignatureInfo)
+          (state.signatureInfo ?? (state.signatureInfo = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, 0 /* ComputedDts */);
       });
     }
     if (latestSignature === void 0) {
       latestSignature = sourceFile.version;
-      if (state.exportedModulesMap && latestSignature !== prevSignature) {
-        (state.oldExportedModulesMap || (state.oldExportedModulesMap = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
-        const references = state.referencedMap ? state.referencedMap.getValues(sourceFile.resolvedPath) : void 0;
-        if (references) {
-          state.exportedModulesMap.set(sourceFile.resolvedPath, references);
-        } else {
-          state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
-        }
-      }
+      if (host.storeSignatureInfo)
+        (state.signatureInfo ?? (state.signatureInfo = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, 2 /* UsedVersion */);
     }
     (state.oldSignatures || (state.oldSignatures = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, prevSignature || false);
     (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = /* @__PURE__ */ new Set())).add(sourceFile.resolvedPath);
@@ -120112,28 +120230,6 @@ var BuilderState;
     return latestSignature !== prevSignature;
   }
   BuilderState2.updateShapeSignature = updateShapeSignature;
-  function updateExportedModules(state, sourceFile, exportedModulesFromDeclarationEmit) {
-    if (!state.exportedModulesMap)
-      return;
-    (state.oldExportedModulesMap || (state.oldExportedModulesMap = /* @__PURE__ */ new Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false);
-    const exportedModules = getExportedModules(exportedModulesFromDeclarationEmit);
-    if (exportedModules) {
-      state.exportedModulesMap.set(sourceFile.resolvedPath, exportedModules);
-    } else {
-      state.exportedModulesMap.deleteKey(sourceFile.resolvedPath);
-    }
-  }
-  BuilderState2.updateExportedModules = updateExportedModules;
-  function getExportedModules(exportedModulesFromDeclarationEmit) {
-    let exportedModules;
-    exportedModulesFromDeclarationEmit == null ? void 0 : exportedModulesFromDeclarationEmit.forEach(
-      (symbol) => getReferencedFilesFromImportedModuleSymbol(symbol).forEach(
-        (path) => (exportedModules ?? (exportedModules = /* @__PURE__ */ new Set())).add(path)
-      )
-    );
-    return exportedModules;
-  }
-  BuilderState2.getExportedModules = getExportedModules;
   function getAllDependencies(state, programOfThisState, sourceFile) {
     const compilerOptions = programOfThisState.getCompilerOptions();
     if (compilerOptions.outFile) {
@@ -120496,7 +120592,7 @@ function assertSourceFileOkWithoutNextAffectedCall(state, sourceFile) {
   Debug.assert(!sourceFile || !state.affectedFiles || state.affectedFiles[state.affectedFilesIndex - 1] !== sourceFile || !state.semanticDiagnosticsPerFile.has(sourceFile.resolvedPath));
 }
 function getNextAffectedFile(state, cancellationToken, host) {
-  var _a, _b;
+  var _a;
   while (true) {
     const { affectedFiles } = state;
     if (affectedFiles) {
@@ -120520,7 +120616,6 @@ function getNextAffectedFile(state, cancellationToken, host) {
       state.changedFilesSet.delete(state.currentChangedFilePath);
       state.currentChangedFilePath = void 0;
       (_a = state.oldSignatures) == null ? void 0 : _a.clear();
-      (_b = state.oldExportedModulesMap) == null ? void 0 : _b.clear();
       state.affectedFiles = void 0;
     }
     const nextKey = state.changedFilesSet.keys().next();
@@ -120681,7 +120776,7 @@ function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, hos
 }
 function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, host) {
   var _a;
-  if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
+  if (!state.referencedMap || !state.changedFilesSet.has(affectedFile.resolvedPath))
     return;
   if (!isChangedSignature(state, affectedFile.resolvedPath))
     return;
@@ -120704,7 +120799,7 @@ function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile
     }
   }
   const seenFileAndExportsOfFile = /* @__PURE__ */ new Set();
-  (_a = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) == null ? void 0 : _a.forEach((exportedFromPath) => {
+  (_a = state.referencedMap.getKeys(affectedFile.resolvedPath)) == null ? void 0 : _a.forEach((exportedFromPath) => {
     if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, host))
       return true;
     const references = state.referencedMap.getKeys(exportedFromPath);
@@ -120718,27 +120813,17 @@ function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile
   });
 }
 function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, host) {
-  var _a, _b;
+  var _a;
   if (!tryAddToSet(seenFileAndExportsOfFile, filePath))
     return void 0;
   if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, host))
     return true;
   handleDtsMayChangeOf(state, filePath, cancellationToken, host);
-  (_a = state.exportedModulesMap.getKeys(filePath)) == null ? void 0 : _a.forEach(
-    (exportedFromPath) => handleDtsMayChangeOfFileAndExportsOfFile(
-      state,
-      exportedFromPath,
-      seenFileAndExportsOfFile,
-      cancellationToken,
-      host
-    )
-  );
-  (_b = state.referencedMap.getKeys(filePath)) == null ? void 0 : _b.forEach(
-    (referencingFilePath) => !seenFileAndExportsOfFile.has(referencingFilePath) && // Not already removed diagnostic file
-    handleDtsMayChangeOf(
-      // Dont add to seen since this is not yet done with the export removal
+  (_a = state.referencedMap.getKeys(filePath)) == null ? void 0 : _a.forEach(
+    (referencingFilePath) => handleDtsMayChangeOfFileAndExportsOfFile(
       state,
       referencingFilePath,
+      seenFileAndExportsOfFile,
       cancellationToken,
       host
     )
@@ -120853,18 +120938,6 @@ function getBuildInfo2(state) {
       toFileIdListId(state.referencedMap.getValues(key))
     ]);
   }
-  let exportedModulesMap;
-  if (state.exportedModulesMap) {
-    exportedModulesMap = mapDefined(arrayFrom(state.exportedModulesMap.keys()).sort(compareStringsCaseSensitive), (key) => {
-      var _a2;
-      const oldValue = (_a2 = state.oldExportedModulesMap) == null ? void 0 : _a2.get(key);
-      if (oldValue === void 0)
-        return [toFileId(key), toFileIdListId(state.exportedModulesMap.getValues(key))];
-      if (oldValue)
-        return [toFileId(key), toFileIdListId(oldValue)];
-      return void 0;
-    });
-  }
   const semanticDiagnosticsPerFile = convertToProgramBuildInfoDiagnostics(state.semanticDiagnosticsPerFile);
   let affectedFilesPendingEmit;
   if ((_a = state.affectedFilesPendingEmit) == null ? void 0 : _a.size) {
@@ -120903,7 +120976,6 @@ function getBuildInfo2(state) {
     options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions),
     fileIdsList,
     referencedMap,
-    exportedModulesMap,
     semanticDiagnosticsPerFile,
     emitDiagnosticsPerFile,
     affectedFilesPendingEmit,
@@ -121218,7 +121290,7 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
     if (!getEmitDeclarations(state.compilerOptions))
       return writeFile2 || maybeBind(host, host.writeFile);
     return (fileName, text, writeByteOrderMark, onError, sourceFiles, data) => {
-      var _a, _b, _c, _d;
+      var _a, _b, _c;
       if (isDeclarationFileName(fileName)) {
         if (!state.compilerOptions.outFile) {
           Debug.assert((sourceFiles == null ? void 0 : sourceFiles.length) === 1);
@@ -121237,10 +121309,8 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
               if (!((_a = data == null ? void 0 : data.diagnostics) == null ? void 0 : _a.length))
                 emitSignature = signature;
               if (signature !== file.version) {
-                if (host.storeFilesChangingSignatureDuringEmit)
-                  (state.filesChangingSignature ?? (state.filesChangingSignature = /* @__PURE__ */ new Set())).add(file.resolvedPath);
-                if (state.exportedModulesMap)
-                  BuilderState.updateExportedModules(state, file, file.exportedModulesFromDeclarationEmit);
+                if (host.storeSignatureInfo)
+                  (state.signatureInfo ?? (state.signatureInfo = /* @__PURE__ */ new Map())).set(file.resolvedPath, 1 /* StoredSignatureAtEmit */);
                 if (state.affectedFiles) {
                   const existing = (_b = state.oldSignatures) == null ? void 0 : _b.get(file.resolvedPath);
                   if (existing === void 0)
@@ -121248,14 +121318,13 @@ function createBuilderProgram(kind, { newProgram, host, oldProgram, configFilePa
                   info.signature = signature;
                 } else {
                   info.signature = signature;
-                  (_c = state.oldExportedModulesMap) == null ? void 0 : _c.clear();
                 }
               }
             }
           }
           if (state.compilerOptions.composite) {
             const filePath = sourceFiles[0].resolvedPath;
-            emitSignature = handleNewSignature((_d = state.emitSignatures) == null ? void 0 : _d.get(filePath), emitSignature);
+            emitSignature = handleNewSignature((_c = state.emitSignatures) == null ? void 0 : _c.get(filePath), emitSignature);
             if (!emitSignature)
               return;
             (state.emitSignatures ?? (state.emitSignatures = /* @__PURE__ */ new Map())).set(filePath, emitSignature);
@@ -121447,7 +121516,6 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
       fileInfos,
       compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
       referencedMap: toManyToManyPathMap(program.referencedMap),
-      exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap),
       semanticDiagnosticsPerFile: toPerFileDiagnostics(program.semanticDiagnosticsPerFile),
       emitDiagnosticsPerFile: toPerFileDiagnostics(program.emitDiagnosticsPerFile),
       hasReusableDiagnostic: true,
@@ -123107,7 +123175,7 @@ function createCompilerHostFromProgramHost(host, getCompilerOptions, directorySt
     getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
     createHash: maybeBind(host, host.createHash),
     readDirectory: maybeBind(host, host.readDirectory),
-    storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
+    storeSignatureInfo: host.storeSignatureInfo,
     jsDocParsingMode: host.jsDocParsingMode
   };
   return compilerHost;
@@ -123174,7 +123242,7 @@ function createProgramHost(system, createProgram2) {
     writeFile: (path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),
     createHash: maybeBind(system, system.createHash),
     createProgram: createProgram2 || createEmitAndSemanticDiagnosticsBuilderProgram,
-    storeFilesChangingSignatureDuringEmit: system.storeFilesChangingSignatureDuringEmit,
+    storeSignatureInfo: system.storeSignatureInfo,
     now: maybeBind(system, system.now)
   };
 }
@@ -123280,7 +123348,7 @@ function createIncrementalCompilerHost(options, system = sys) {
     system
   );
   host.createHash = maybeBind(system, system.createHash);
-  host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
+  host.storeSignatureInfo = system.storeSignatureInfo;
   setGetSourceFileAsHashVersioned(host);
   changeCompilerHostLikeToUseCache(host, (fileName) => toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName));
   return host;