typescript 5.5.0-dev.20240328 → 5.5.0-dev.20240329

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.20240328`;
+var version = `${versionMajorMinor}.0-dev.20240329`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -42684,13 +42684,21 @@ function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, im
     }
     const nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, getDirectoryPath(modulePath));
     const nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory);
-    if (nearestSourcePackageJson !== nearestTargetPackageJson) {
+    const ignoreCase = !hostUsesCaseSensitiveFileNames(host);
+    if (!packageJsonPathsAreEqual(nearestTargetPackageJson, nearestSourcePackageJson, ignoreCase)) {
       return maybeNonRelative;
     }
     return relativePath;
   }
   return isPathRelativeToParent(maybeNonRelative) || countPathComponents(relativePath) < countPathComponents(maybeNonRelative) ? relativePath : maybeNonRelative;
 }
+function packageJsonPathsAreEqual(a, b, ignoreCase) {
+  if (a === b)
+    return true;
+  if (a === void 0 || b === void 0)
+    return false;
+  return comparePaths(a, b, ignoreCase) === 0 /* EqualTo */;
+}
 function countPathComponents(path) {
   let count = 0;
   for (let i = startsWith(path, "./") ? 2 : 0; i < path.length; i++) {
@@ -47958,17 +47966,8 @@ function createTypeChecker(host) {
       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
-      )),
+      serializeTypeForDeclaration: (type, symbol, addUndefined, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined)),
+      serializeReturnTypeForSignature: (signature, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => serializeReturnTypeForSignature(context, signature)),
       indexInfoToIndexSignatureDeclaration: (indexInfo, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => indexInfoToIndexSignatureDeclarationHelper(
         indexInfo,
         context,
@@ -47987,7 +47986,7 @@ function createTypeChecker(host) {
       symbolToTypeParameterDeclarations: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParametersToTypeParameterDeclarations(symbol, context)),
       symbolToParameterDeclaration: (symbol, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToParameterDeclaration(symbol, context)),
       typeParameterToDeclaration: (parameter, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => typeParameterToDeclaration(parameter, context)),
-      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker, bundled) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context, bundled)),
+      symbolTableToDeclarationStatements: (symbolTable, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolTableToDeclarationStatements(symbolTable, context)),
       symbolToNode: (symbol, meaning, enclosingDeclaration, flags, tracker) => withContext(enclosingDeclaration, flags, tracker, (context) => symbolToNode(symbol, context, meaning))
     };
     function expressionOrTypeToTypeNode(context, expr, type, addUndefined) {
@@ -48005,12 +48004,12 @@ function createTypeChecker(host) {
       }
       return typeToTypeNodeHelper(type, context);
     }
-    function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined, includePrivateSymbol, bundled) {
+    function tryReuseExistingTypeNode(context, typeNode, type, host2, addUndefined) {
       const originalType = type;
       if (addUndefined) {
         type = getOptionalType(type);
       }
-      const clone = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2, includePrivateSymbol, bundled);
+      const clone = tryReuseExistingNonParameterTypeNode(context, typeNode, type, host2);
       if (clone) {
         if (addUndefined && !someType(getTypeFromTypeNode(typeNode), (t) => !!(t.flags & 32768 /* Undefined */))) {
           return factory.createUnionTypeNode([clone, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
@@ -48018,16 +48017,16 @@ function createTypeChecker(host) {
         return clone;
       }
       if (addUndefined && originalType !== type) {
-        const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2, includePrivateSymbol, bundled);
+        const cloneMissingUndefined = tryReuseExistingNonParameterTypeNode(context, typeNode, originalType, host2);
         if (cloneMissingUndefined) {
           return factory.createUnionTypeNode([cloneMissingUndefined, factory.createKeywordTypeNode(157 /* UndefinedKeyword */)]);
         }
       }
       return void 0;
     }
-    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, includePrivateSymbol, bundled, annotationType) {
+    function tryReuseExistingNonParameterTypeNode(context, existing, type, host2 = context.enclosingDeclaration, annotationType) {
       if (typeNodeIsEquivalentToType(existing, host2, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) {
-        const result = tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled);
+        const result = tryReuseExistingTypeNodeHelper(context, existing);
         if (result) {
           return result;
         }
@@ -48062,7 +48061,8 @@ function createTypeChecker(host) {
         symbolDepth: void 0,
         inferTypeParameters: void 0,
         approximateLength: 0,
-        trackedSymbols: void 0
+        trackedSymbols: void 0,
+        bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration))
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -49053,9 +49053,8 @@ function createTypeChecker(host) {
     }
     function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
       var _a;
-      const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
-      if (suppressAny)
-        context.flags &= ~256 /* SuppressAnyReturnType */;
+      const flags = context.flags;
+      context.flags &= ~256 /* SuppressAnyReturnType */;
       context.approximateLength += 3;
       let typeParameters;
       let typeArguments;
@@ -49131,27 +49130,17 @@ function createTypeChecker(host) {
           );
         }
       }
-      const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports));
+      const parameters = (some(expandedParams, (p) => p !== expandedParams[expandedParams.length - 1] && !!(getCheckFlags(p) & 32768 /* RestParameter */)) ? signature.parameters : expandedParams).map((parameter) => symbolToParameterDeclaration(parameter, context, kind === 176 /* Constructor */));
       const thisParameter = context.flags & 33554432 /* OmitThisParameter */ ? void 0 : tryGetThisParameterDeclaration(signature, context);
       if (thisParameter) {
         parameters.unshift(thisParameter);
       }
-      let returnTypeNode;
-      const typePredicate = getTypePredicateOfSignature(signature);
-      if (typePredicate) {
-        returnTypeNode = typePredicateToTypePredicateNodeHelper(typePredicate, context);
-      } else {
-        const returnType = getReturnTypeOfSignature(signature);
-        if (returnType && !(suppressAny && isTypeAny(returnType))) {
-          returnTypeNode = serializeReturnTypeForSignature(context, returnType, signature, options == null ? void 0 : options.privateSymbolVisitor, options == null ? void 0 : options.bundledImports);
-        } else if (!suppressAny) {
-          returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
-        }
-      }
+      context.flags = flags;
+      const returnTypeNode = serializeReturnTypeForSignature(context, signature);
       let modifiers = options == null ? void 0 : options.modifiers;
       if (kind === 185 /* ConstructorType */ && signature.flags & 4 /* Abstract */) {
-        const flags = modifiersToFlags(modifiers);
-        modifiers = factory.createModifiersFromModifierFlags(flags | 64 /* Abstract */);
+        const flags2 = modifiersToFlags(modifiers);
+        modifiers = factory.createModifiersFromModifierFlags(flags2 | 64 /* Abstract */);
       }
       const node = kind === 179 /* CallSignature */ ? factory.createCallSignature(typeParameters, parameters, returnTypeNode) : kind === 180 /* ConstructSignature */ ? factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : kind === 173 /* MethodSignature */ ? factory.createMethodSignature(modifiers, (options == null ? void 0 : options.name) ?? factory.createIdentifier(""), options == null ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : kind === 174 /* MethodDeclaration */ ? factory.createMethodDeclaration(
         modifiers,
@@ -49280,11 +49269,11 @@ function createTypeChecker(host) {
         return getDeclarationOfKind(parameterSymbol, 341 /* JSDocParameterTag */);
       }
     }
-    function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) {
+    function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags) {
       const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
       const parameterType = getTypeOfSymbol(parameterSymbol);
       const addUndefined = parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration);
-      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports, addUndefined);
+      const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, 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;
@@ -49853,7 +49842,7 @@ function createTypeChecker(host) {
       return initial;
     }
     function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
-      return symbol.declarations && find(symbol.declarations, (s) => !!getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
+      return symbol.declarations && find(symbol.declarations, (s) => !!getNonlocalEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
     }
     function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) {
       return !(getObjectFlags(type) & 4 /* Reference */) || !isTypeReferenceNode(existing) || length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters);
@@ -49864,13 +49853,13 @@ function createTypeChecker(host) {
       }
       return enclosingDeclaration;
     }
-    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled, addUndefined) {
+    function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined) {
       var _a;
       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);
+          const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
+          const result2 = tryReuseExistingTypeNode(context, existing, type, declWithExistingAnnotation, addUndefined);
           if (result2) {
             return result2;
           }
@@ -49895,22 +49884,43 @@ function createTypeChecker(host) {
       }
       return false;
     }
-    function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) {
+    function serializeReturnTypeForSignature(context, signature) {
+      const suppressAny = context.flags & 256 /* SuppressAnyReturnType */;
+      const flags = context.flags;
+      if (suppressAny)
+        context.flags &= ~256 /* SuppressAnyReturnType */;
+      let returnTypeNode;
+      const returnType = getReturnTypeOfSignature(signature);
+      if (returnType && !(suppressAny && isTypeAny(returnType))) {
+        returnTypeNode = serializeReturnTypeForSignatureWorker(context, signature);
+      } else if (!suppressAny) {
+        returnTypeNode = factory.createKeywordTypeNode(133 /* AnyKeyword */);
+      }
+      context.flags = flags;
+      return returnTypeNode;
+    }
+    function serializeReturnTypeForSignatureWorker(context, signature) {
+      const typePredicate = getTypePredicateOfSignature(signature);
+      const type = getReturnTypeOfSignature(signature);
       if (!isErrorType(type) && context.enclosingDeclaration) {
-        const annotation = signature.declaration && getEffectiveReturnTypeNode(signature.declaration);
+        const annotation = signature.declaration && getNonlocalEffectiveReturnTypeAnnotationNode(signature.declaration);
         const enclosingDeclarationIgnoringFakeScope = getEnclosingDeclarationIgnoringFakeScope(context.enclosingDeclaration);
         if (!!findAncestor(annotation, (n) => n === enclosingDeclarationIgnoringFakeScope) && annotation) {
           const annotated = getTypeFromTypeNode(annotation);
           const thisInstantiated = annotated.flags & 262144 /* TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated;
-          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, includePrivateSymbol, bundled, thisInstantiated);
+          const result = tryReuseExistingNonParameterTypeNode(context, annotation, type, signature.declaration, thisInstantiated);
           if (result) {
             return result;
           }
         }
       }
-      return typeToTypeNodeHelper(type, context);
+      if (typePredicate) {
+        return typePredicateToTypePredicateNodeHelper(typePredicate, context);
+      }
+      const expr = signature.declaration && getPossibleTypeNodeReuseExpression(signature.declaration);
+      return expressionOrTypeToTypeNode(context, expr, type);
     }
-    function trackExistingEntityName(node, context, includePrivateSymbol) {
+    function trackExistingEntityName(node, context) {
       let introducesError = false;
       const leftmost = getFirstIdentifier(node);
       if (isInJSFile(node) && (isExportsIdentifier(leftmost) || isModuleExportsAccessExpression(leftmost.parent) || isQualifiedName(leftmost.parent) && isModuleIdentifier(leftmost.parent.left) && isExportsIdentifier(leftmost.parent.right))) {
@@ -49939,7 +49949,6 @@ function createTypeChecker(host) {
           }
         } else {
           context.tracker.trackSymbol(sym, context.enclosingDeclaration, meaning);
-          includePrivateSymbol == null ? void 0 : includePrivateSymbol(sym);
         }
         if (isIdentifier(node)) {
           const type = getDeclaredTypeOfSymbol(sym);
@@ -49950,7 +49959,7 @@ function createTypeChecker(host) {
       }
       return { introducesError, node };
     }
-    function tryReuseExistingTypeNodeHelper(context, existing, includePrivateSymbol, bundled) {
+    function tryReuseExistingTypeNodeHelper(context, existing) {
       if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
         cancellationToken.throwIfCancellationRequested();
       }
@@ -50073,33 +50082,27 @@ 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 (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !isLateBindableName(node.name)) {
+          return 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 (isFunctionLike(node) && !node.type || isPropertyDeclaration(node) && !node.type && !node.initializer || isPropertySignature(node) && !node.type && !node.initializer || isParameter(node) && !node.type && !node.initializer) {
+          let visited = visitEachChild(
+            node,
+            visitExistingNodeTreeSymbols,
+            /*context*/
+            void 0
+          );
+          if (visited === node) {
+            visited = setTextRange(factory.cloneNode(node), node);
           }
+          visited.type = factory.createKeywordTypeNode(133 /* AnyKeyword */);
+          if (isParameter(node)) {
+            visited.modifiers = void 0;
+          }
+          return visited;
         }
         if (isEntityName(node) || isEntityNameExpression(node)) {
-          const { introducesError, node: result } = trackExistingEntityName(node, context, includePrivateSymbol);
+          const { introducesError, node: result } = trackExistingEntityName(node, context);
           hadError = hadError || introducesError;
           if (result !== node) {
             return result;
@@ -50130,7 +50133,7 @@ function createTypeChecker(host) {
           return p.name && isIdentifier(p.name) && p.name.escapedText === "this" ? "this" : getEffectiveDotDotDotForParameter(p) ? `args` : `arg${index}`;
         }
         function rewriteModuleSpecifier(parent, lit) {
-          if (bundled) {
+          if (context.bundled) {
             if (context.tracker && context.tracker.moduleResolverHost) {
               const targetFile = getExternalModuleFileFromDeclaration(parent);
               if (targetFile) {
@@ -50149,7 +50152,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    function symbolTableToDeclarationStatements(symbolTable, context, bundled) {
+    function symbolTableToDeclarationStatements(symbolTable, context) {
       var _a;
       const serializePropertySymbolForClass = makeSerializePropertySymbol(
         factory.createPropertyDeclaration,
@@ -50208,7 +50211,7 @@ function createTypeChecker(host) {
         const baseName = unescapeLeadingUnderscores(name);
         void getInternalSymbolName(symbol, baseName);
       });
-      let addingDeclare = !bundled;
+      let addingDeclare = !context.bundled;
       const exportEquals = symbolTable.get("export=" /* ExportEquals */);
       if (exportEquals && symbolTable.size > 1 && exportEquals.flags & (2097152 /* Alias */ | 1536 /* Module */)) {
         symbolTable = createSymbolTable();
@@ -50489,7 +50492,7 @@ function createTypeChecker(host) {
                         name,
                         /*exclamationToken*/
                         void 0,
-                        serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled)
+                        serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration)
                       )
                     ], flags)
                   ),
@@ -50631,9 +50634,7 @@ function createTypeChecker(host) {
           jsdocAliasDecl.typeExpression.type,
           aliasType,
           /*host*/
-          void 0,
-          includePrivateSymbol,
-          bundled
+          void 0
         ) || typeToTypeNodeHelper(aliasType, context);
         addResult(
           setSyntheticLeadingComments(
@@ -50763,7 +50764,7 @@ function createTypeChecker(host) {
       function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) {
         const signatures = getSignaturesOfType(type, 0 /* Call */);
         for (const sig of signatures) {
-          const decl = signatureToSignatureDeclarationHelper(sig, 262 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName), privateSymbolVisitor: includePrivateSymbol, bundledImports: bundled });
+          const decl = signatureToSignatureDeclarationHelper(sig, 262 /* FunctionDeclaration */, context, { name: factory.createIdentifier(localName) });
           addResult(setTextRange(decl, getSignatureTextRangeLocation(sig)), modifierFlags);
         }
         if (!(symbol.flags & (512 /* ValueModule */ | 1024 /* NamespaceModule */) && !!symbol.exports && !!symbol.exports.size)) {
@@ -50857,7 +50858,7 @@ function createTypeChecker(host) {
               );
             }
             let introducesError;
-            ({ introducesError, node: expr } = trackExistingEntityName(expr, context, includePrivateSymbol));
+            ({ introducesError, node: expr } = trackExistingEntityName(expr, context));
             if (introducesError) {
               return cleanup(
                 /*result*/
@@ -50867,15 +50868,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) => tryReuseExistingNonParameterTypeNode(context, a, getTypeFromTypeNode(a)) || typeToTypeNodeHelper(getTypeFromTypeNode(a), context))
           ));
           function cleanup(result2) {
             context.enclosingDeclaration = oldEnclosing;
@@ -51100,7 +51093,7 @@ function createTypeChecker(host) {
             break;
           case 273 /* ImportClause */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
-            const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.moduleSpecifier;
+            const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.moduleSpecifier;
             const attributes = isImportDeclaration(node.parent) ? node.parent.attributes : void 0;
             const isTypeOnly = isJSDocImportTag(node.parent);
             addResult(
@@ -51122,7 +51115,7 @@ function createTypeChecker(host) {
           }
           case 274 /* NamespaceImport */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
-            const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.moduleSpecifier;
+            const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.moduleSpecifier;
             const isTypeOnly = isJSDocImportTag(node.parent.parent);
             addResult(
               factory.createImportDeclaration(
@@ -51156,7 +51149,7 @@ function createTypeChecker(host) {
             break;
           case 276 /* ImportSpecifier */: {
             const generatedSpecifier = getSpecifierForModuleSymbol(target.parent || target, context);
-            const specifier2 = bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.parent.moduleSpecifier;
+            const specifier2 = context.bundled ? factory.createStringLiteral(generatedSpecifier) : node.parent.parent.parent.moduleSpecifier;
             const isTypeOnly = isJSDocImportTag(node.parent.parent.parent);
             addResult(
               factory.createImportDeclaration(
@@ -51310,7 +51303,7 @@ function createTypeChecker(host) {
                   varName,
                   /*exclamationToken*/
                   void 0,
-                  serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration, includePrivateSymbol, bundled)
+                  serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration)
                 )
               ], flags)
             );
@@ -51394,7 +51387,7 @@ function createTypeChecker(host) {
                     paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
                     /*questionToken*/
                     void 0,
-                    isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled)
+                    isPrivate ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration)
                   )],
                   /*body*/
                   void 0
@@ -51409,7 +51402,7 @@ function createTypeChecker(host) {
                   factory.createModifiersFromModifierFlags(flag),
                   name,
                   [],
-                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
+                  isPrivate2 ? void 0 : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration),
                   /*body*/
                   void 0
                 ),
@@ -51423,7 +51416,7 @@ function createTypeChecker(host) {
                 factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 8 /* Readonly */ : 0) | flag),
                 name,
                 p.flags & 16777216 /* Optional */ ? factory.createToken(58 /* QuestionToken */) : void 0,
-                isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled),
+                isPrivate ? void 0 : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration),
                 // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357
                 // interface members can't have initializers, however class members _can_
                 /*initializer*/
@@ -83167,9 +83160,23 @@ function createTypeChecker(host) {
   function isDeclarationWithPossibleInnerTypeNodeReuse(declaration) {
     return isFunctionLike(declaration) || isExportAssignment(declaration) || isVariableLike(declaration);
   }
+  function getAllAccessorDeclarationsForDeclaration(accessor) {
+    accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration);
+    const otherKind = accessor.kind === 178 /* SetAccessor */ ? 177 /* GetAccessor */ : 178 /* SetAccessor */;
+    const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(accessor), otherKind);
+    const firstAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? otherAccessor : accessor;
+    const secondAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? accessor : otherAccessor;
+    const setAccessor = accessor.kind === 178 /* SetAccessor */ ? accessor : otherAccessor;
+    const getAccessor = accessor.kind === 177 /* GetAccessor */ ? accessor : otherAccessor;
+    return {
+      firstAccessor,
+      secondAccessor,
+      setAccessor,
+      getAccessor
+    };
+  }
   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;
+    return isFunctionLike(declaration) && !isSetAccessor(declaration) ? getSingleReturnExpression(declaration) : isExportAssignment(declaration) ? declaration.expression : !!declaration.initializer ? declaration.initializer : isParameter(declaration) && isSetAccessor(declaration.parent) ? getSingleReturnExpression(getAllAccessorDeclarationsForDeclaration(declaration.parent).getAccessor) : void 0;
   }
   function getSingleReturnExpression(declaration) {
     let candidateExpr;
@@ -83195,20 +83202,7 @@ function createTypeChecker(host) {
     if (!signatureDeclaration) {
       return factory.createToken(133 /* AnyKeyword */);
     }
-    const signature = getSignatureFromDeclaration(signatureDeclaration);
-    const typePredicate = getTypePredicateOfSignature(signature);
-    if (typePredicate) {
-      return nodeBuilder.typePredicateToTypePredicateNode(typePredicate, enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
-    }
-    return nodeBuilder.expressionOrTypeToTypeNode(
-      getPossibleTypeNodeReuseExpression(signatureDeclaration),
-      getReturnTypeOfSignature(signature),
-      /*addUndefined*/
-      void 0,
-      enclosingDeclaration,
-      flags | 1024 /* MultilineObjectLiterals */,
-      tracker
-    );
+    return nodeBuilder.serializeReturnTypeForSignature(getSignatureFromDeclaration(signatureDeclaration), enclosingDeclaration, flags | 1024 /* MultilineObjectLiterals */, tracker);
   }
   function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) {
     const expr = getParseTreeNode(exprIn, isExpression);
@@ -83367,6 +83361,35 @@ function createTypeChecker(host) {
       return parseIsolatedEntityName(compilerOptions.jsxFragmentFactory, languageVersion);
     }
   }
+  function getNonlocalEffectiveTypeAnnotationNode(node) {
+    const direct = getEffectiveTypeAnnotationNode(node);
+    if (direct) {
+      return direct;
+    }
+    if (node.kind === 169 /* Parameter */ && node.parent.kind === 178 /* SetAccessor */) {
+      const other = getAllAccessorDeclarationsForDeclaration(node.parent).getAccessor;
+      if (other) {
+        return getEffectiveReturnTypeNode(other);
+      }
+    }
+    return void 0;
+  }
+  function getNonlocalEffectiveReturnTypeAnnotationNode(node) {
+    const direct = getEffectiveReturnTypeNode(node);
+    if (direct) {
+      return direct;
+    }
+    if (node.kind === 177 /* GetAccessor */) {
+      const other = getAllAccessorDeclarationsForDeclaration(node).setAccessor;
+      if (other) {
+        const param = getSetAccessorValueParameter(other);
+        if (param) {
+          return getEffectiveTypeAnnotationNode(param);
+        }
+      }
+    }
+    return void 0;
+  }
   function createResolver() {
     return {
       getReferencedExportContainer,
@@ -83420,34 +83443,19 @@ function createTypeChecker(host) {
       },
       getJsxFactoryEntity,
       getJsxFragmentFactoryEntity,
-      getAllAccessorDeclarations(accessor) {
-        accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration);
-        const otherKind = accessor.kind === 178 /* SetAccessor */ ? 177 /* GetAccessor */ : 178 /* SetAccessor */;
-        const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(accessor), otherKind);
-        const firstAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? otherAccessor : accessor;
-        const secondAccessor = otherAccessor && otherAccessor.pos < accessor.pos ? accessor : otherAccessor;
-        const setAccessor = accessor.kind === 178 /* SetAccessor */ ? accessor : otherAccessor;
-        const getAccessor = accessor.kind === 177 /* GetAccessor */ ? accessor : otherAccessor;
-        return {
-          firstAccessor,
-          secondAccessor,
-          setAccessor,
-          getAccessor
-        };
-      },
       isBindingCapturedByNode: (node, decl) => {
         const parseNode = getParseTreeNode(node);
         const parseDecl = getParseTreeNode(decl);
         return !!parseNode && !!parseDecl && (isVariableDeclaration(parseDecl) || isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl);
       },
-      getDeclarationStatementsForSourceFile: (node, flags, tracker, bundled) => {
+      getDeclarationStatementsForSourceFile: (node, flags, tracker) => {
         const n = getParseTreeNode(node);
         Debug.assert(n && n.kind === 307 /* SourceFile */, "Non-sourcefile node passed into getDeclarationsForSourceFile");
         const sym = getSymbolOfDeclaration(node);
         if (!sym) {
-          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker, bundled);
+          return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker);
         }
-        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker, bundled);
+        return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker);
       },
       isImportRequiredByAugmentation
     };
@@ -83789,7 +83797,7 @@ function createTypeChecker(host) {
             return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here);
           }
         } else if (legacyDecorators && (node.kind === 177 /* GetAccessor */ || node.kind === 178 /* SetAccessor */)) {
-          const accessors = getAllAccessorDeclarations(node.parent.members, node);
+          const accessors = getAllAccessorDeclarationsForDeclaration(node);
           if (hasDecorators(accessors.firstAccessor) && node === accessors.secondAccessor) {
             return grammarErrorOnFirstToken(node, Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name);
           }
@@ -88980,7 +88988,7 @@ function transformTypeScript(context) {
     if (typeSerializer) {
       let decorators;
       if (shouldAddTypeMetadata(node)) {
-        const typeMetadata = emitHelpers().createMetadataHelper("design:type", typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node));
+        const typeMetadata = emitHelpers().createMetadataHelper("design:type", typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node, container));
         decorators = append(decorators, factory2.createDecorator(typeMetadata));
       }
       if (shouldAddParamTypesMetadata(node)) {
@@ -89007,7 +89015,7 @@ function transformTypeScript(context) {
           /*type*/
           void 0,
           factory2.createToken(39 /* EqualsGreaterThanToken */),
-          typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node)
+          typeSerializer.serializeTypeOfNode({ currentLexicalScope, currentNameScope: container }, node, container)
         ));
         properties = append(properties, typeProperty);
       }
@@ -92444,7 +92452,7 @@ function createRuntimeTypeSerializer(context) {
   let currentNameScope;
   return {
     serializeTypeNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeNode, node),
-    serializeTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeTypeOfNode, node),
+    serializeTypeOfNode: (serializerContext, node, container) => setSerializerContextAnd(serializerContext, serializeTypeOfNode, node, container),
     serializeParameterTypesOfNode: (serializerContext, node, container) => setSerializerContextAnd(serializerContext, serializeParameterTypesOfNode, node, container),
     serializeReturnTypeOfNode: (serializerContext, node) => setSerializerContextAnd(serializerContext, serializeReturnTypeOfNode, node)
   };
@@ -92458,18 +92466,18 @@ function createRuntimeTypeSerializer(context) {
     currentNameScope = savedCurrentNameScope;
     return result;
   }
-  function getAccessorTypeNode(node) {
-    const accessors = resolver.getAllAccessorDeclarations(node);
+  function getAccessorTypeNode(node, container) {
+    const accessors = getAllAccessorDeclarations(container.members, node);
     return accessors.setAccessor && getSetAccessorTypeAnnotationNode(accessors.setAccessor) || accessors.getAccessor && getEffectiveReturnTypeNode(accessors.getAccessor);
   }
-  function serializeTypeOfNode(node) {
+  function serializeTypeOfNode(node, container) {
     switch (node.kind) {
       case 172 /* PropertyDeclaration */:
       case 169 /* Parameter */:
         return serializeTypeNode(node.type);
       case 178 /* SetAccessor */:
       case 177 /* GetAccessor */:
-        return serializeTypeNode(getAccessorTypeNode(node));
+        return serializeTypeNode(getAccessorTypeNode(node, container));
       case 263 /* ClassDeclaration */:
       case 231 /* ClassExpression */:
       case 174 /* MethodDeclaration */:
@@ -92492,7 +92500,7 @@ function createRuntimeTypeSerializer(context) {
         if (parameter.dotDotDotToken) {
           expressions.push(serializeTypeNode(getRestParameterElementType(parameter.type)));
         } else {
-          expressions.push(serializeTypeOfNode(parameter));
+          expressions.push(serializeTypeOfNode(parameter, container));
         }
       }
     }
@@ -108519,13 +108527,13 @@ function transformDeclarations(context) {
       context.addDiagnostic(createDiagnosticForNode(errorNameNode || errorFallbackNode, Diagnostics.The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized, propertyName));
     }
   }
-  function transformDeclarationsForJS(sourceFile, bundled) {
+  function transformDeclarationsForJS(sourceFile) {
     const oldDiag = getSymbolAccessibilityDiagnostic;
     getSymbolAccessibilityDiagnostic = (s) => s.errorNode && canProduceDiagnostics(s.errorNode) ? createGetSymbolAccessibilityDiagnosticForNode(s.errorNode)(s) : {
       diagnosticMessage: s.errorModuleName ? Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit : Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit,
       errorNode: s.errorNode || sourceFile
     };
-    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker, bundled);
+    const result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker);
     getSymbolAccessibilityDiagnostic = oldDiag;
     return result;
   }
@@ -108556,11 +108564,7 @@ function transformDeclarations(context) {
           if (isExternalOrCommonJsModule(sourceFile) || isJsonSourceFile(sourceFile)) {
             resultHasExternalModuleIndicator = false;
             needsDeclare = false;
-            const statements = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(
-              sourceFile,
-              /*bundled*/
-              true
-            )) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
+            const statements = isSourceFileJS(sourceFile) ? factory2.createNodeArray(transformDeclarationsForJS(sourceFile)) : visitNodes2(sourceFile.statements, visitDeclarationStatements, isStatement);
             const newFile = factory2.updateSourceFile(
               sourceFile,
               [factory2.createModuleDeclaration(
@@ -108882,7 +108886,7 @@ function transformDeclarations(context) {
       if (!isPrivate) {
         const valueParameter = getSetAccessorValueParameter(input);
         if (valueParameter) {
-          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
+          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input));
           newValueParameter = ensureParameter(
             valueParameter,
             /*modifierMask*/
@@ -109168,7 +109172,7 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
+          const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, getAllAccessorDeclarations(isObjectLiteralExpression(input.parent) ? input.parent.properties : input.parent.members, input));
           return cleanup(factory2.updateGetAccessorDeclaration(
             input,
             ensureModifiers(input),
@@ -111016,7 +111020,6 @@ var notImplementedResolver = {
   isLiteralConstDeclaration: notImplemented,
   getJsxFactoryEntity: notImplemented,
   getJsxFragmentFactoryEntity: notImplemented,
-  getAllAccessorDeclarations: notImplemented,
   isBindingCapturedByNode: notImplemented,
   getDeclarationStatementsForSourceFile: notImplemented,
   isImportRequiredByAugmentation: notImplemented
@@ -121958,7 +121961,8 @@ function createResolutionCache(resolutionHost, rootDirForResolution, logChangesW
           impliedFormatPackageJsons.delete(newFile.resolvedPath);
       });
       impliedFormatPackageJsons.forEach((existing, path) => {
-        if (!(newProgram == null ? void 0 : newProgram.getSourceFileByPath(path))) {
+        const newFile = newProgram == null ? void 0 : newProgram.getSourceFileByPath(path);
+        if (!newFile || newFile.resolvedPath !== path) {
           existing.forEach((location) => fileWatchesOfAffectingLocations.get(location).files--);
           impliedFormatPackageJsons.delete(path);
         }