typescript 5.5.0-dev.20240509 → 5.5.0-dev.20240511

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.20240509`;
+var version = `${versionMajorMinor}.0-dev.20240511`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -11908,6 +11908,10 @@ function isPropertyAccessOrQualifiedNameOrImportTypeNode(node) {
   const kind = node.kind;
   return kind === 211 /* PropertyAccessExpression */ || kind === 166 /* QualifiedName */ || kind === 205 /* ImportType */;
 }
+function isPropertyAccessOrQualifiedName(node) {
+  const kind = node.kind;
+  return kind === 211 /* PropertyAccessExpression */ || kind === 166 /* QualifiedName */;
+}
 function isCallLikeOrFunctionLikeExpression(node) {
   return isCallLikeExpression(node) || isFunctionExpressionOrArrowFunction(node);
 }
@@ -12178,7 +12182,7 @@ function canHaveLocals(node) {
   }
 }
 function isDeclarationKind(kind) {
-  return kind === 219 /* ArrowFunction */ || kind === 208 /* BindingElement */ || kind === 263 /* ClassDeclaration */ || kind === 231 /* ClassExpression */ || kind === 175 /* ClassStaticBlockDeclaration */ || kind === 176 /* Constructor */ || kind === 266 /* EnumDeclaration */ || kind === 306 /* EnumMember */ || kind === 281 /* ExportSpecifier */ || kind === 262 /* FunctionDeclaration */ || kind === 218 /* FunctionExpression */ || kind === 177 /* GetAccessor */ || kind === 273 /* ImportClause */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 276 /* ImportSpecifier */ || kind === 264 /* InterfaceDeclaration */ || kind === 291 /* JsxAttribute */ || kind === 174 /* MethodDeclaration */ || kind === 173 /* MethodSignature */ || kind === 267 /* ModuleDeclaration */ || kind === 270 /* NamespaceExportDeclaration */ || kind === 274 /* NamespaceImport */ || kind === 280 /* NamespaceExport */ || kind === 169 /* Parameter */ || kind === 303 /* PropertyAssignment */ || kind === 172 /* PropertyDeclaration */ || kind === 171 /* PropertySignature */ || kind === 178 /* SetAccessor */ || kind === 304 /* ShorthandPropertyAssignment */ || kind === 265 /* TypeAliasDeclaration */ || kind === 168 /* TypeParameter */ || kind === 260 /* VariableDeclaration */ || kind === 346 /* JSDocTypedefTag */ || kind === 338 /* JSDocCallbackTag */ || kind === 348 /* JSDocPropertyTag */;
+  return kind === 219 /* ArrowFunction */ || kind === 208 /* BindingElement */ || kind === 263 /* ClassDeclaration */ || kind === 231 /* ClassExpression */ || kind === 175 /* ClassStaticBlockDeclaration */ || kind === 176 /* Constructor */ || kind === 266 /* EnumDeclaration */ || kind === 306 /* EnumMember */ || kind === 281 /* ExportSpecifier */ || kind === 262 /* FunctionDeclaration */ || kind === 218 /* FunctionExpression */ || kind === 177 /* GetAccessor */ || kind === 273 /* ImportClause */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 276 /* ImportSpecifier */ || kind === 264 /* InterfaceDeclaration */ || kind === 291 /* JsxAttribute */ || kind === 174 /* MethodDeclaration */ || kind === 173 /* MethodSignature */ || kind === 267 /* ModuleDeclaration */ || kind === 270 /* NamespaceExportDeclaration */ || kind === 274 /* NamespaceImport */ || kind === 280 /* NamespaceExport */ || kind === 169 /* Parameter */ || kind === 303 /* PropertyAssignment */ || kind === 172 /* PropertyDeclaration */ || kind === 171 /* PropertySignature */ || kind === 178 /* SetAccessor */ || kind === 304 /* ShorthandPropertyAssignment */ || kind === 265 /* TypeAliasDeclaration */ || kind === 168 /* TypeParameter */ || kind === 260 /* VariableDeclaration */ || kind === 346 /* JSDocTypedefTag */ || kind === 338 /* JSDocCallbackTag */ || kind === 348 /* JSDocPropertyTag */ || kind === 202 /* NamedTupleMember */;
 }
 function isDeclarationStatementKind(kind) {
   return kind === 262 /* FunctionDeclaration */ || kind === 282 /* MissingDeclaration */ || kind === 263 /* ClassDeclaration */ || kind === 264 /* InterfaceDeclaration */ || kind === 265 /* TypeAliasDeclaration */ || kind === 266 /* EnumDeclaration */ || kind === 267 /* ModuleDeclaration */ || kind === 272 /* ImportDeclaration */ || kind === 271 /* ImportEqualsDeclaration */ || kind === 278 /* ExportDeclaration */ || kind === 277 /* ExportAssignment */ || kind === 270 /* NamespaceExportDeclaration */;
@@ -18877,13 +18881,15 @@ function createNameResolver({
             let useResult = true;
             if (isFunctionLike(location) && lastLocation && lastLocation !== location.body) {
               if (meaning & result.flags & 788968 /* Type */ && lastLocation.kind !== 320 /* JSDoc */) {
-                useResult = result.flags & 262144 /* TypeParameter */ ? lastLocation === location.type || lastLocation.kind === 169 /* Parameter */ || lastLocation.kind === 341 /* JSDocParameterTag */ || lastLocation.kind === 342 /* JSDocReturnTag */ || lastLocation.kind === 168 /* TypeParameter */ : false;
+                useResult = result.flags & 262144 /* TypeParameter */ ? !!(lastLocation.flags & 16 /* Synthesized */) || // Synthetic fake scopes are added for signatures so type parameters are accessible from them
+                lastLocation === location.type || lastLocation.kind === 169 /* Parameter */ || lastLocation.kind === 341 /* JSDocParameterTag */ || lastLocation.kind === 342 /* JSDocReturnTag */ || lastLocation.kind === 168 /* TypeParameter */ : false;
               }
               if (meaning & result.flags & 3 /* Variable */) {
                 if (useOuterVariableScopeInParameter(result, location, lastLocation)) {
                   useResult = false;
                 } else if (result.flags & 1 /* FunctionScopedVariable */) {
-                  useResult = lastLocation.kind === 169 /* Parameter */ || lastLocation === location.type && !!findAncestor(result.valueDeclaration, isParameter);
+                  useResult = lastLocation.kind === 169 /* Parameter */ || !!(lastLocation.flags & 16 /* Synthesized */) || // Synthetic fake scopes are added for signatures so parameters are accessible from them
+                  lastLocation === location.type && !!findAncestor(result.valueDeclaration, isParameter);
                 }
               }
             } else if (location.kind === 194 /* ConditionalType */) {
@@ -46406,7 +46412,6 @@ function createTypeChecker(host) {
     if (meaning) {
       const symbol = getMergedSymbol(symbols.get(name));
       if (symbol) {
-        Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
         if (symbol.flags & meaning) {
           return symbol;
         }
@@ -47658,37 +47663,6 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function markExportAsReferenced(node) {
-    if (!canCollectSymbolAliasAccessabilityData) {
-      return;
-    }
-    const symbol = getSymbolOfDeclaration(node);
-    const target = resolveAlias(symbol);
-    if (target) {
-      const markAlias = target === unknownSymbol || getSymbolFlags(
-        symbol,
-        /*excludeTypeOnlyMeanings*/
-        true
-      ) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target);
-      if (markAlias) {
-        markAliasSymbolAsReferenced(symbol);
-      }
-    }
-  }
-  function markAliasSymbolAsReferenced(symbol) {
-    Debug.assert(canCollectSymbolAliasAccessabilityData);
-    const links = getSymbolLinks(symbol);
-    if (!links.referenced) {
-      links.referenced = true;
-      const node = getDeclarationOfAliasSymbol(symbol);
-      if (!node) return Debug.fail();
-      if (isInternalModuleImportEqualsDeclaration(node)) {
-        if (getSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
-          checkExpressionCached(node.moduleReference);
-        }
-      }
-    }
-  }
   function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) {
     if (entityName.kind === 80 /* Identifier */ && isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
       entityName = entityName.parent;
@@ -47841,7 +47815,6 @@ function createTypeChecker(host) {
     } else {
       Debug.assertNever(name, "Unknown entity name kind.");
     }
-    Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
     if (!nodeIsSynthesized(name) && isEntityName(name) && (symbol.flags & 2097152 /* Alias */ || name.parent.kind === 277 /* ExportAssignment */)) {
       markSymbolOfAliasDeclarationIfTypeOnly(
         getAliasDeclarationFromName(name),
@@ -49262,7 +49235,6 @@ function createTypeChecker(host) {
       return symbolToExpression(symbol, context, meaning);
     }
     function withContext(enclosingDeclaration, flags, tracker, cb) {
-      Debug.assert(enclosingDeclaration === void 0 || (enclosingDeclaration.flags & 16 /* Synthesized */) === 0);
       const moduleResolverHost = (tracker == null ? void 0 : tracker.trackSymbol) ? tracker.moduleResolverHost : flags & 134217728 /* DoNotIncludeSymbolChain */ ? createBasicNodeBuilderModuleSpecifierResolutionHost(host) : void 0;
       const context = {
         enclosingDeclaration,
@@ -49276,7 +49248,18 @@ function createTypeChecker(host) {
         inferTypeParameters: void 0,
         approximateLength: 0,
         trackedSymbols: void 0,
-        bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration))
+        bundled: !!compilerOptions.outFile && !!enclosingDeclaration && isExternalOrCommonJsModule(getSourceFileOfNode(enclosingDeclaration)),
+        truncating: false,
+        usedSymbolNames: void 0,
+        remappedSymbolNames: void 0,
+        remappedSymbolReferences: void 0,
+        reverseMappedStack: void 0,
+        mustCreateTypeParameterSymbolList: true,
+        typeParameterSymbolList: void 0,
+        mustCreateTypeParametersNamesLookups: true,
+        typeParameterNames: void 0,
+        typeParameterNamesByText: void 0,
+        typeParameterNamesByTextNextNameCount: void 0
       };
       context.tracker = new SymbolTrackerImpl(context, tracker, moduleResolverHost);
       const resultingNode = cb(context);
@@ -50271,22 +50254,22 @@ function createTypeChecker(host) {
     }
     function signatureToSignatureDeclarationHelper(signature, kind, context, options) {
       var _a;
-      const flags = context.flags;
-      context.flags &= ~256 /* SuppressAnyReturnType */;
-      context.approximateLength += 3;
       let typeParameters;
       let typeArguments;
-      if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
-        typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
-      } else {
-        typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
-      }
       const expandedParams = getExpandedParameters(
         signature,
         /*skipUnionExpanding*/
         true
       )[0];
-      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters);
+      const cleanup = enterNewScope(context, signature.declaration, expandedParams, signature.typeParameters, signature.parameters);
+      context.approximateLength += 3;
+      if (context.flags & 32 /* WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) {
+        typeArguments = signature.target.typeParameters.map((parameter) => typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context));
+      } else {
+        typeParameters = signature.typeParameters && signature.typeParameters.map((parameter) => typeParameterToDeclaration(parameter, context));
+      }
+      const flags = context.flags;
+      context.flags &= ~256 /* SuppressAnyReturnType */;
       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) {
@@ -50384,15 +50367,14 @@ function createTypeChecker(host) {
       return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).typeParameters : isConditionalTypeNode(node) ? getInferTypeParameters(node) : [getDeclaredTypeOfTypeParameter(getSymbolOfDeclaration(node.typeParameter))];
     }
     function getParametersInScope(node) {
-      return isFunctionLike(node) || isJSDocSignature(node) ? getExpandedParameters(
-        getSignatureFromDeclaration(node),
-        /*skipUnionExpanding*/
-        true
-      )[0] : void 0;
-    }
-    function enterNewScope(context, declaration, expandedParams, typeParameters) {
-      let cleanup;
-      if (context.enclosingDeclaration && declaration && declaration !== context.enclosingDeclaration && !isInJSFile(declaration) && (some(expandedParams) || some(typeParameters))) {
+      return isFunctionLike(node) || isJSDocSignature(node) ? getSignatureFromDeclaration(node).parameters : void 0;
+    }
+    function enterNewScope(context, declaration, expandedParams, typeParameters, originalParameters) {
+      const cleanupContext = cloneNodeBuilderContext(context);
+      let cleanupParams;
+      let cleanupTypeParams;
+      const oldEnclosingDecl = context.enclosingDeclaration;
+      if (context.enclosingDeclaration && declaration) {
         let pushFakeScope2 = function(kind, addAll) {
           Debug.assert(context.enclosingDeclaration);
           let existingFakeScope;
@@ -50404,39 +50386,45 @@ function createTypeChecker(host) {
           Debug.assertOptionalNode(existingFakeScope, isBlock);
           const locals = (existingFakeScope == null ? void 0 : existingFakeScope.locals) ?? createSymbolTable();
           let newLocals;
+          let oldLocals;
           addAll((name, symbol) => {
-            if (!locals.has(name)) {
-              newLocals = append(newLocals, name);
-              locals.set(name, symbol);
+            if (existingFakeScope) {
+              const oldSymbol = locals.get(name);
+              if (!oldSymbol) {
+                newLocals = append(newLocals, name);
+              } else {
+                oldLocals = append(oldLocals, { name, oldSymbol });
+              }
             }
+            locals.set(name, symbol);
           });
-          if (!newLocals) return;
-          const oldCleanup = cleanup;
-          function undo() {
-            forEach(newLocals, (s) => locals.delete(s));
-            oldCleanup == null ? void 0 : oldCleanup();
-          }
-          if (existingFakeScope) {
-            cleanup = undo;
-          } else {
-            const fakeScope = parseNodeFactory.createBlock(emptyArray);
+          if (!existingFakeScope) {
+            const fakeScope = factory.createBlock(emptyArray);
             getNodeLinks(fakeScope).fakeScopeForSignatureDeclaration = kind;
             fakeScope.locals = locals;
-            const saveEnclosingDeclaration = context.enclosingDeclaration;
-            setParent(fakeScope, saveEnclosingDeclaration);
+            setParent(fakeScope, context.enclosingDeclaration);
             context.enclosingDeclaration = fakeScope;
-            cleanup = () => {
-              context.enclosingDeclaration = saveEnclosingDeclaration;
-              undo();
+          } else {
+            return function undo() {
+              forEach(newLocals, (s) => locals.delete(s));
+              forEach(oldLocals, (s) => locals.set(s.name, s.oldSymbol));
             };
           }
         };
         var pushFakeScope = pushFakeScope2;
-        pushFakeScope2(
+        cleanupParams = !some(expandedParams) ? void 0 : pushFakeScope2(
           "params",
           (add) => {
-            for (const param of expandedParams ?? emptyArray) {
-              if (!forEach(param.declarations, (d) => {
+            if (!expandedParams) return;
+            for (let pIndex = 0; pIndex < expandedParams.length; pIndex++) {
+              const param = expandedParams[pIndex];
+              const originalParam = originalParameters == null ? void 0 : originalParameters[pIndex];
+              if (originalParameters && originalParam !== param) {
+                add(param.escapedName, unknownSymbol);
+                if (originalParam) {
+                  add(originalParam.escapedName, unknownSymbol);
+                }
+              } else if (!forEach(param.declarations, (d) => {
                 if (isParameter(d) && isBindingPattern(d.name)) {
                   bindPattern(d.name);
                   return true;
@@ -50467,8 +50455,8 @@ function createTypeChecker(host) {
             }
           }
         );
-        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */) {
-          pushFakeScope2(
+        if (context.flags & 4 /* GenerateNamesForShadowedTypeParams */ && some(typeParameters)) {
+          cleanupTypeParams = pushFakeScope2(
             "typeParams",
             (add) => {
               for (const typeParam of typeParameters ?? emptyArray) {
@@ -50478,8 +50466,13 @@ function createTypeChecker(host) {
             }
           );
         }
-        return cleanup;
       }
+      return () => {
+        cleanupParams == null ? void 0 : cleanupParams();
+        cleanupTypeParams == null ? void 0 : cleanupTypeParams();
+        cleanupContext();
+        context.enclosingDeclaration = oldEnclosingDecl;
+      };
     }
     function tryGetThisParameterDeclaration(signature, context) {
       if (signature.thisParameter) {
@@ -50697,7 +50690,11 @@ function createTypeChecker(host) {
       if ((_a = context.typeParameterSymbolList) == null ? void 0 : _a.has(symbolId)) {
         return void 0;
       }
-      (context.typeParameterSymbolList || (context.typeParameterSymbolList = /* @__PURE__ */ new Set())).add(symbolId);
+      if (context.mustCreateTypeParameterSymbolList) {
+        context.mustCreateTypeParameterSymbolList = false;
+        context.typeParameterSymbolList = new Set(context.typeParameterSymbolList);
+      }
+      context.typeParameterSymbolList.add(symbolId);
       let typeParameterNodes;
       if (context.flags & 512 /* WriteTypeParametersInQualifiedName */ && index < chain.length - 1) {
         const parentSymbol = symbol;
@@ -50958,9 +50955,15 @@ function createTypeChecker(host) {
           result = factory.createIdentifier(text);
           setIdentifierTypeArguments(result, typeArguments);
         }
-        (context.typeParameterNamesByTextNextNameCount || (context.typeParameterNamesByTextNextNameCount = /* @__PURE__ */ new Map())).set(rawtext, i);
-        (context.typeParameterNames || (context.typeParameterNames = /* @__PURE__ */ new Map())).set(getTypeId(type), result);
-        (context.typeParameterNamesByText || (context.typeParameterNamesByText = /* @__PURE__ */ new Set())).add(text);
+        if (context.mustCreateTypeParametersNamesLookups) {
+          context.mustCreateTypeParametersNamesLookups = false;
+          context.typeParameterNames = new Map(context.typeParameterNames);
+          context.typeParameterNamesByTextNextNameCount = new Map(context.typeParameterNamesByTextNextNameCount);
+          context.typeParameterNamesByText = new Set(context.typeParameterNamesByText);
+        }
+        context.typeParameterNamesByTextNextNameCount.set(rawtext, i);
+        context.typeParameterNames.set(getTypeId(type), result);
+        context.typeParameterNamesByText.add(text);
       }
       return result;
     }
@@ -51082,21 +51085,22 @@ function createTypeChecker(host) {
       }
     }
     function cloneNodeBuilderContext(context) {
-      const initial = { ...context };
-      if (initial.typeParameterNames) {
-        initial.typeParameterNames = new Map(initial.typeParameterNames);
-      }
-      if (initial.typeParameterNamesByText) {
-        initial.typeParameterNamesByText = new Set(initial.typeParameterNamesByText);
-      }
-      if (initial.typeParameterSymbolList) {
-        initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
-      }
-      if (initial.typeParameterNamesByTextNextNameCount) {
-        initial.typeParameterNamesByTextNextNameCount = new Map(initial.typeParameterNamesByTextNextNameCount);
-      }
-      initial.tracker = new SymbolTrackerImpl(initial, initial.tracker.inner, initial.tracker.moduleResolverHost);
-      return initial;
+      const oldMustCreateTypeParameterSymbolList = context.mustCreateTypeParameterSymbolList;
+      const oldMustCreateTypeParametersNamesLookups = context.mustCreateTypeParametersNamesLookups;
+      context.mustCreateTypeParameterSymbolList = true;
+      context.mustCreateTypeParametersNamesLookups = true;
+      const oldTypeParameterNames = context.typeParameterNames;
+      const oldTypeParameterNamesByText = context.typeParameterNamesByText;
+      const oldTypeParameterNamesByTextNextNameCount = context.typeParameterNamesByTextNextNameCount;
+      const oldTypeParameterSymbolList = context.typeParameterSymbolList;
+      return () => {
+        context.typeParameterNames = oldTypeParameterNames;
+        context.typeParameterNamesByText = oldTypeParameterNamesByText;
+        context.typeParameterNamesByTextNextNameCount = oldTypeParameterNamesByTextNextNameCount;
+        context.typeParameterSymbolList = oldTypeParameterSymbolList;
+        context.mustCreateTypeParameterSymbolList = oldMustCreateTypeParameterSymbolList;
+        context.mustCreateTypeParametersNamesLookups = oldMustCreateTypeParametersNamesLookups;
+      };
     }
     function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) {
       return symbol.declarations && find(symbol.declarations, (s) => !!getNonlocalEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!findAncestor(s, (n) => n === enclosingDeclaration)));
@@ -51229,13 +51233,34 @@ function createTypeChecker(host) {
         /*dontResolveAlias*/
         true
       );
+      if (context.enclosingDeclaration && (getNodeLinks(context.enclosingDeclaration).fakeScopeForSignatureDeclaration || !findAncestor(node, (n) => n === context.enclosingDeclaration)) && !(sym && sym.flags & 262144 /* TypeParameter */)) {
+        sym = getExportSymbolOfValueSymbolIfExported(sym);
+        const symAtLocation = resolveEntityName(
+          leftmost,
+          meaning,
+          /*ignoreErrors*/
+          true,
+          /*dontResolveAlias*/
+          true,
+          context.enclosingDeclaration
+        );
+        if (
+          // Check for unusable parameters symbols
+          symAtLocation === unknownSymbol || // If the symbol is not found, but was not found in the original scope either we probably have an error, don't reuse the node
+          symAtLocation === void 0 && sym !== void 0 || // If the symbol is found both in declaration scope and in current scope then it shoudl point to the same reference
+          symAtLocation && sym && !getSymbolIfSameReference(getExportSymbolOfValueSymbolIfExported(symAtLocation), sym)
+        ) {
+          introducesError = true;
+          return { introducesError, node, sym };
+        }
+      }
       if (sym) {
         if (sym.flags & 1 /* FunctionScopedVariable */ && sym.valueDeclaration) {
-          if (isPartOfParameterDeclaration(sym.valueDeclaration)) {
+          if (isPartOfParameterDeclaration(sym.valueDeclaration) || isJSDocParameterTag(sym.valueDeclaration)) {
             return { introducesError, node: attachSymbolToLeftmostIdentifier(node) };
           }
         }
-        if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the curent context if they are are resolvable
+        if (!(sym.flags & 262144 /* TypeParameter */) && // Type parameters are visible in the current context if they are are resolvable
         !isDeclarationName(node) && isSymbolAccessible(
           sym,
           context.enclosingDeclaration,
@@ -51286,14 +51311,7 @@ function createTypeChecker(host) {
         return result === node ? setTextRange2(context, factory.cloneNode(result), node) : result;
       }
       function onEnterNewScope(node) {
-        const oldContex = context;
-        context = cloneNodeBuilderContext(context);
-        const cleanup = enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
-        return onExitNewScope;
-        function onExitNewScope() {
-          cleanup == null ? void 0 : cleanup();
-          context = oldContex;
-        }
+        return enterNewScope(context, node, getParametersInScope(node), getTypeParametersInScope(node));
       }
       function visitExistingNodeTreeSymbolsWorker(node) {
         if (isJSDocAllType(node) || node.kind === 319 /* JSDocNamepathType */) {
@@ -51743,17 +51761,9 @@ function createTypeChecker(host) {
         visitedSymbols.add(getSymbolId(visitedSym));
         const skipMembershipCheck = !isPrivate;
         if (skipMembershipCheck || !!length(symbol.declarations) && some(symbol.declarations, (d) => !!findAncestor(d, (n) => n === enclosingDeclaration))) {
-          const oldContext = context;
-          context = cloneNodeBuilderContext(context);
+          const scopeCleanup = cloneNodeBuilderContext(context);
           serializeSymbolWorker(symbol, isPrivate, propertyAsAlias);
-          if (context.reportedDiagnostic) {
-            oldcontext.reportedDiagnostic = context.reportedDiagnostic;
-          }
-          if (context.trackedSymbols) {
-            if (!oldContext.trackedSymbols) oldContext.trackedSymbols = context.trackedSymbols;
-            else Debug.assert(context.trackedSymbols === oldContext.trackedSymbols);
-          }
-          context = oldContext;
+          scopeCleanup();
         }
       }
       function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias, escapedSymbolName = symbol.escapedName) {
@@ -53320,8 +53330,6 @@ function createTypeChecker(host) {
     switch (propertyName) {
       case 0 /* Type */:
         return !!getSymbolLinks(target).type;
-      case 5 /* EnumTagType */:
-        return !!getNodeLinks(target).resolvedEnumType;
       case 2 /* DeclaredType */:
         return !!getSymbolLinks(target).declaredType;
       case 1 /* ResolvedBaseConstructorType */:
@@ -53330,13 +53338,13 @@ function createTypeChecker(host) {
         return !!target.resolvedReturnType;
       case 4 /* ImmediateBaseConstraint */:
         return !!target.immediateBaseConstraint;
-      case 6 /* ResolvedTypeArguments */:
+      case 5 /* ResolvedTypeArguments */:
         return !!target.resolvedTypeArguments;
-      case 7 /* ResolvedBaseTypes */:
+      case 6 /* ResolvedBaseTypes */:
         return !!target.baseTypesResolved;
-      case 8 /* WriteType */:
+      case 7 /* WriteType */:
         return !!getSymbolLinks(target).writeType;
-      case 9 /* ParameterInitializerContainsUndefined */:
+      case 8 /* ParameterInitializerContainsUndefined */:
         return getNodeLinks(target).parameterInitializerContainsUndefined !== void 0;
     }
     return Debug.assertNever(propertyName);
@@ -54355,7 +54363,7 @@ function createTypeChecker(host) {
   function getWriteTypeOfAccessors(symbol) {
     const links = getSymbolLinks(symbol);
     if (!links.writeType) {
-      if (!pushTypeResolution(symbol, 8 /* WriteType */)) {
+      if (!pushTypeResolution(symbol, 7 /* WriteType */)) {
         return errorType;
       }
       const setter = getDeclarationOfKind(symbol, 178 /* SetAccessor */) ?? tryCast(getDeclarationOfKind(symbol, 172 /* PropertyDeclaration */), isAutoAccessorPropertyDeclaration);
@@ -54765,7 +54773,7 @@ function createTypeChecker(host) {
   }
   function getBaseTypes(type) {
     if (!type.baseTypesResolved) {
-      if (pushTypeResolution(type, 7 /* ResolvedBaseTypes */)) {
+      if (pushTypeResolution(type, 6 /* ResolvedBaseTypes */)) {
         if (type.objectFlags & 8 /* Tuple */) {
           type.resolvedBaseTypes = [getTupleBaseType(type)];
         } else if (type.symbol.flags & (32 /* Class */ | 64 /* Interface */)) {
@@ -57660,7 +57668,7 @@ function createTypeChecker(host) {
   function getTypeArguments(type) {
     var _a, _b;
     if (!type.resolvedTypeArguments) {
-      if (!pushTypeResolution(type, 6 /* ResolvedTypeArguments */)) {
+      if (!pushTypeResolution(type, 5 /* ResolvedTypeArguments */)) {
         return ((_a = type.target.localTypeParameters) == null ? void 0 : _a.map(() => errorType)) || emptyArray;
       }
       const node = type.node;
@@ -68859,7 +68867,7 @@ function createTypeChecker(host) {
   function parameterInitializerContainsUndefined(declaration) {
     const links = getNodeLinks(declaration);
     if (links.parameterInitializerContainsUndefined === void 0) {
-      if (!pushTypeResolution(declaration, 9 /* ParameterInitializerContainsUndefined */)) {
+      if (!pushTypeResolution(declaration, 8 /* ParameterInitializerContainsUndefined */)) {
         reportCircularityError(declaration.symbol);
         return true;
       }
@@ -68913,6 +68921,248 @@ function createTypeChecker(host) {
       return false;
     });
   }
+  function markLinkedReferences(location, hint, propSymbol, parentType) {
+    if (!canCollectSymbolAliasAccessabilityData) {
+      return;
+    }
+    if (location.flags & 33554432 /* Ambient */) {
+      return;
+    }
+    switch (hint) {
+      case 1 /* Identifier */:
+        return markIdentifierAliasReferenced(location);
+      case 2 /* Property */:
+        return markPropertyAliasReferenced(location, propSymbol, parentType);
+      case 3 /* ExportAssignment */:
+        return markExportAssignmentAliasReferenced(location);
+      case 4 /* Jsx */:
+        return markJsxAliasReferenced(location);
+      case 5 /* AsyncFunction */:
+        return markAsyncFunctionAliasReferenced(location);
+      case 6 /* ExportImportEquals */:
+        return markImportEqualsAliasReferenced(location);
+      case 7 /* ExportSpecifier */:
+        return markExportSpecifierAliasReferenced(location);
+      case 8 /* Decorator */:
+        return markDecoratorAliasReferenced(location);
+      case 0 /* Unspecified */: {
+        if (isIdentifier(location) && (isExpressionNode(location) || isShorthandPropertyAssignment(location.parent) || isImportEqualsDeclaration(location.parent) && location.parent.moduleReference === location) && shouldMarkIdentifierAliasReferenced(location)) {
+          if (isPropertyAccessOrQualifiedName(location.parent)) {
+            const left = isPropertyAccessExpression(location.parent) ? location.parent.expression : location.parent.left;
+            if (left !== location) return;
+          }
+          markIdentifierAliasReferenced(location);
+          return;
+        }
+        if (isPropertyAccessOrQualifiedName(location)) {
+          let topProp = location;
+          while (isPropertyAccessOrQualifiedName(topProp)) {
+            if (isPartOfTypeNode(topProp)) return;
+            topProp = topProp.parent;
+          }
+          return markPropertyAliasReferenced(location);
+        }
+        if (isExportAssignment(location)) {
+          return markExportAssignmentAliasReferenced(location);
+        }
+        if (isJsxOpeningLikeElement(location) || isJsxOpeningFragment(location)) {
+          return markJsxAliasReferenced(location);
+        }
+        if (isFunctionLikeDeclaration(location) || isMethodSignature(location)) {
+          return markAsyncFunctionAliasReferenced(location);
+        }
+        if (isImportEqualsDeclaration(location)) {
+          if (isInternalModuleImportEqualsDeclaration(location) || checkExternalImportOrExportDeclaration(location)) {
+            return markImportEqualsAliasReferenced(location);
+          }
+          return;
+        }
+        if (isExportSpecifier(location)) {
+          return markExportSpecifierAliasReferenced(location);
+        }
+        if (!compilerOptions.emitDecoratorMetadata) {
+          return;
+        }
+        if (!canHaveDecorators(location) || !hasDecorators(location) || !location.modifiers || !nodeCanBeDecorated(legacyDecorators, location, location.parent, location.parent.parent)) {
+          return;
+        }
+        return markDecoratorAliasReferenced(location);
+      }
+      default:
+        Debug.assertNever(hint, `Unhandled reference hint: ${hint}`);
+    }
+  }
+  function markIdentifierAliasReferenced(location) {
+    const symbol = getResolvedSymbol(location);
+    if (symbol && symbol !== argumentsSymbol && symbol !== unknownSymbol && !isThisInTypeQuery(location)) {
+      markAliasReferenced(symbol, location);
+    }
+  }
+  function markPropertyAliasReferenced(location, propSymbol, parentType) {
+    const left = isPropertyAccessExpression(location) ? location.expression : location.left;
+    if (isThisIdentifier(left) || !isIdentifier(left)) {
+      return;
+    }
+    const parentSymbol = getResolvedSymbol(left);
+    if (!parentSymbol || parentSymbol === unknownSymbol) {
+      return;
+    }
+    if (getIsolatedModules(compilerOptions) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location)) {
+      markAliasReferenced(parentSymbol, location);
+      return;
+    }
+    const leftType = parentType || checkExpressionCached(left);
+    if (isTypeAny(leftType) || leftType === silentNeverType) {
+      markAliasReferenced(parentSymbol, location);
+      return;
+    }
+    let prop = propSymbol;
+    if (!prop && !parentType) {
+      const right = isPropertyAccessExpression(location) ? location.name : location.right;
+      const lexicallyScopedSymbol = isPrivateIdentifier(right) && lookupSymbolForPrivateIdentifierDeclaration(right.escapedText, right);
+      const assignmentKind = getAssignmentTargetKind(location);
+      const apparentType = getApparentType(assignmentKind !== 0 /* None */ || isMethodAccessForCall(location) ? getWidenedType(leftType) : leftType);
+      prop = isPrivateIdentifier(right) ? lexicallyScopedSymbol && getPrivateIdentifierPropertyOfType(apparentType, lexicallyScopedSymbol) || void 0 : getPropertyOfType(apparentType, right.escapedText);
+    }
+    if (!(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && location.parent.kind === 306 /* EnumMember */))) {
+      markAliasReferenced(parentSymbol, location);
+    }
+    return;
+  }
+  function markExportAssignmentAliasReferenced(location) {
+    if (isIdentifier(location.expression)) {
+      const id = location.expression;
+      const sym = getExportSymbolOfValueSymbolIfExported(resolveEntityName(
+        id,
+        -1 /* All */,
+        /*ignoreErrors*/
+        true,
+        /*dontResolveAlias*/
+        true,
+        location
+      ));
+      if (sym) {
+        markAliasReferenced(sym, id);
+      }
+    }
+  }
+  function markJsxAliasReferenced(node) {
+    if (!getJsxNamespaceContainerForImplicitImport(node)) {
+      const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0;
+      const jsxFactoryNamespace = getJsxNamespace(node);
+      const jsxFactoryLocation = isJsxOpeningLikeElement(node) ? node.tagName : node;
+      let jsxFactorySym;
+      if (!(isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) {
+        jsxFactorySym = resolveName(
+          jsxFactoryLocation,
+          jsxFactoryNamespace,
+          111551 /* Value */,
+          jsxFactoryRefErr,
+          /*isUse*/
+          true
+        );
+      }
+      if (jsxFactorySym) {
+        jsxFactorySym.isReferenced = -1 /* All */;
+        if (canCollectSymbolAliasAccessabilityData && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
+          markAliasSymbolAsReferenced(jsxFactorySym);
+        }
+      }
+      if (isJsxOpeningFragment(node)) {
+        const file = getSourceFileOfNode(node);
+        const localJsxNamespace = getLocalJsxNamespace(file);
+        if (localJsxNamespace) {
+          resolveName(
+            jsxFactoryLocation,
+            localJsxNamespace,
+            111551 /* Value */,
+            jsxFactoryRefErr,
+            /*isUse*/
+            true
+          );
+        }
+      }
+    }
+    return;
+  }
+  function markAsyncFunctionAliasReferenced(location) {
+    if (languageVersion < 2 /* ES2015 */) {
+      if (getFunctionFlags(location) & 2 /* Async */) {
+        const returnTypeNode = getEffectiveReturnTypeNode(location);
+        markTypeNodeAsReferenced(returnTypeNode);
+      }
+    }
+  }
+  function markImportEqualsAliasReferenced(location) {
+    if (hasSyntacticModifier(location, 32 /* Export */)) {
+      markExportAsReferenced(location);
+    }
+  }
+  function markExportSpecifierAliasReferenced(location) {
+    if (!location.parent.parent.moduleSpecifier && !location.isTypeOnly && !location.parent.parent.isTypeOnly) {
+      const exportedName = location.propertyName || location.name;
+      const symbol = resolveName(
+        exportedName,
+        exportedName.escapedText,
+        111551 /* Value */ | 788968 /* Type */ | 1920 /* Namespace */ | 2097152 /* Alias */,
+        /*nameNotFoundMessage*/
+        void 0,
+        /*isUse*/
+        true
+      );
+      if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || symbol.declarations && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
+      } else {
+        const target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
+        if (!target || getSymbolFlags(target) & 111551 /* Value */) {
+          markExportAsReferenced(location);
+          markIdentifierAliasReferenced(location.propertyName || location.name);
+        }
+      }
+      return;
+    }
+  }
+  function markDecoratorAliasReferenced(node) {
+    if (compilerOptions.emitDecoratorMetadata) {
+      const firstDecorator = find(node.modifiers, isDecorator);
+      if (!firstDecorator) {
+        return;
+      }
+      checkExternalEmitHelpers(firstDecorator, 16 /* Metadata */);
+      switch (node.kind) {
+        case 263 /* ClassDeclaration */:
+          const constructor = getFirstConstructorWithBody(node);
+          if (constructor) {
+            for (const parameter of constructor.parameters) {
+              markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
+            }
+          }
+          break;
+        case 177 /* GetAccessor */:
+        case 178 /* SetAccessor */:
+          const otherKind = node.kind === 177 /* GetAccessor */ ? 178 /* SetAccessor */ : 177 /* GetAccessor */;
+          const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(node), otherKind);
+          markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
+          break;
+        case 174 /* MethodDeclaration */:
+          for (const parameter of node.parameters) {
+            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
+          }
+          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(node));
+          break;
+        case 172 /* PropertyDeclaration */:
+          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveTypeAnnotationNode(node));
+          break;
+        case 169 /* Parameter */:
+          markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
+          const containingSignature = node.parent;
+          for (const parameter of containingSignature.parameters) {
+            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
+          }
+          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(containingSignature));
+          break;
+      }
+    }
+  }
   function markAliasReferenced(symbol, location) {
     if (!canCollectSymbolAliasAccessabilityData) {
       return;
@@ -68934,6 +69184,77 @@ function createTypeChecker(host) {
       }
     }
   }
+  function markAliasSymbolAsReferenced(symbol) {
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
+    const links = getSymbolLinks(symbol);
+    if (!links.referenced) {
+      links.referenced = true;
+      const node = getDeclarationOfAliasSymbol(symbol);
+      if (!node) return Debug.fail();
+      if (isInternalModuleImportEqualsDeclaration(node)) {
+        if (getSymbolFlags(resolveSymbol(symbol)) & 111551 /* Value */) {
+          const left = getFirstIdentifier(node.moduleReference);
+          markIdentifierAliasReferenced(left);
+        }
+      }
+    }
+  }
+  function markExportAsReferenced(node) {
+    const symbol = getSymbolOfDeclaration(node);
+    const target = resolveAlias(symbol);
+    if (target) {
+      const markAlias = target === unknownSymbol || getSymbolFlags(
+        symbol,
+        /*excludeTypeOnlyMeanings*/
+        true
+      ) & 111551 /* Value */ && !isConstEnumOrConstEnumOnlyModule(target);
+      if (markAlias) {
+        markAliasSymbolAsReferenced(symbol);
+      }
+    }
+  }
+  function markEntityNameOrEntityExpressionAsReference(typeName, forDecoratorMetadata) {
+    if (!typeName) return;
+    const rootName = getFirstIdentifier(typeName);
+    const meaning = (typeName.kind === 80 /* Identifier */ ? 788968 /* Type */ : 1920 /* Namespace */) | 2097152 /* Alias */;
+    const rootSymbol = resolveName(
+      rootName,
+      rootName.escapedText,
+      meaning,
+      /*nameNotFoundMessage*/
+      void 0,
+      /*isUse*/
+      true
+    );
+    if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
+      if (canCollectSymbolAliasAccessabilityData && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
+        markAliasSymbolAsReferenced(rootSymbol);
+      } else if (forDecoratorMetadata && getIsolatedModules(compilerOptions) && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
+        const diag2 = error(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
+        const aliasDeclaration = find(rootSymbol.declarations || emptyArray, isAliasSymbolDeclaration);
+        if (aliasDeclaration) {
+          addRelatedInfo(diag2, createDiagnosticForNode(aliasDeclaration, Diagnostics._0_was_imported_here, idText(rootName)));
+        }
+      }
+    }
+  }
+  function markTypeNodeAsReferenced(node) {
+    markEntityNameOrEntityExpressionAsReference(
+      node && getEntityNameFromTypeNode(node),
+      /*forDecoratorMetadata*/
+      false
+    );
+  }
+  function markDecoratorMedataDataTypeNodeAsReferenced(node) {
+    const entityName = getEntityNameForDecoratorMetadata(node);
+    if (entityName && isEntityName(entityName)) {
+      markEntityNameOrEntityExpressionAsReference(
+        entityName,
+        /*forDecoratorMetadata*/
+        true
+      );
+    }
+  }
   function getNarrowedTypeOfSymbol(symbol, location, checkMode) {
     var _a;
     const type = getTypeOfSymbol(symbol, checkMode);
@@ -69029,7 +69350,7 @@ function createTypeChecker(host) {
       return getTypeOfSymbol(symbol);
     }
     if (shouldMarkIdentifierAliasReferenced(node)) {
-      markAliasReferenced(symbol, node);
+      markLinkedReferences(node, 1 /* Identifier */);
     }
     const localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol);
     const targetSymbol = resolveAliasWithDeprecationCheck(localOrExportSymbol, node);
@@ -71572,42 +71893,7 @@ function createTypeChecker(host) {
       checkGrammarJsxElement(node);
     }
     checkJsxPreconditions(node);
-    if (!getJsxNamespaceContainerForImplicitImport(node)) {
-      const jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* React */ ? Diagnostics.Cannot_find_name_0 : void 0;
-      const jsxFactoryNamespace = getJsxNamespace(node);
-      const jsxFactoryLocation = isNodeOpeningLikeElement ? node.tagName : node;
-      let jsxFactorySym;
-      if (!(isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) {
-        jsxFactorySym = resolveName(
-          jsxFactoryLocation,
-          jsxFactoryNamespace,
-          111551 /* Value */,
-          jsxFactoryRefErr,
-          /*isUse*/
-          true
-        );
-      }
-      if (jsxFactorySym) {
-        jsxFactorySym.isReferenced = -1 /* All */;
-        if (canCollectSymbolAliasAccessabilityData && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
-          markAliasSymbolAsReferenced(jsxFactorySym);
-        }
-      }
-      if (isJsxOpeningFragment(node)) {
-        const file = getSourceFileOfNode(node);
-        const localJsxNamespace = getLocalJsxNamespace(file);
-        if (localJsxNamespace) {
-          resolveName(
-            jsxFactoryLocation,
-            localJsxNamespace,
-            111551 /* Value */,
-            jsxFactoryRefErr,
-            /*isUse*/
-            true
-          );
-        }
-      }
-    }
+    markLinkedReferences(node, 4 /* Jsx */);
     if (isNodeOpeningLikeElement) {
       const jsxOpeningLikeNode = node;
       const sig = getResolvedSignature(jsxOpeningLikeNode);
@@ -72038,7 +72324,13 @@ function createTypeChecker(host) {
     } else {
       if (isAnyLike) {
         if (isIdentifier(left) && parentSymbol) {
-          markAliasReferenced(parentSymbol, node);
+          markLinkedReferences(
+            node,
+            2 /* Property */,
+            /*propSymbol*/
+            void 0,
+            leftType
+          );
         }
         return isErrorType(apparentType) ? errorType : apparentType;
       }
@@ -72051,9 +72343,7 @@ function createTypeChecker(host) {
         node.kind === 166 /* QualifiedName */
       );
     }
-    if (isIdentifier(left) && parentSymbol && (getIsolatedModules(compilerOptions) || !(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* EnumMember */ && node.parent.kind === 306 /* EnumMember */)) || shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) {
-      markAliasReferenced(parentSymbol, node);
-    }
+    markLinkedReferences(node, 2 /* Property */, prop, leftType);
     let propType;
     if (!prop) {
       const indexInfo = !isPrivateIdentifier(right) && (assignmentKind === 0 /* None */ || !isGenericObjectType(leftType) || isThisTypeParameter(leftType)) ? getApplicableIndexInfoForName(apparentType, right.escapedText) : void 0;
@@ -78986,7 +79276,7 @@ function createTypeChecker(host) {
         return;
       }
     } else {
-      markTypeNodeAsReferenced(returnTypeNode);
+      markLinkedReferences(node, 5 /* AsyncFunction */);
       if (isErrorType(returnType)) {
         return;
       }
@@ -79170,48 +79460,6 @@ function createTypeChecker(host) {
       voidType
     );
   }
-  function markTypeNodeAsReferenced(node) {
-    markEntityNameOrEntityExpressionAsReference(
-      node && getEntityNameFromTypeNode(node),
-      /*forDecoratorMetadata*/
-      false
-    );
-  }
-  function markEntityNameOrEntityExpressionAsReference(typeName, forDecoratorMetadata) {
-    if (!typeName) return;
-    const rootName = getFirstIdentifier(typeName);
-    const meaning = (typeName.kind === 80 /* Identifier */ ? 788968 /* Type */ : 1920 /* Namespace */) | 2097152 /* Alias */;
-    const rootSymbol = resolveName(
-      rootName,
-      rootName.escapedText,
-      meaning,
-      /*nameNotFoundMessage*/
-      void 0,
-      /*isUse*/
-      true
-    );
-    if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
-      if (canCollectSymbolAliasAccessabilityData && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
-        markAliasSymbolAsReferenced(rootSymbol);
-      } else if (forDecoratorMetadata && getIsolatedModules(compilerOptions) && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
-        const diag2 = error(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
-        const aliasDeclaration = find(rootSymbol.declarations || emptyArray, isAliasSymbolDeclaration);
-        if (aliasDeclaration) {
-          addRelatedInfo(diag2, createDiagnosticForNode(aliasDeclaration, Diagnostics._0_was_imported_here, idText(rootName)));
-        }
-      }
-    }
-  }
-  function markDecoratorMedataDataTypeNodeAsReferenced(node) {
-    const entityName = getEntityNameForDecoratorMetadata(node);
-    if (entityName && isEntityName(entityName)) {
-      markEntityNameOrEntityExpressionAsReference(
-        entityName,
-        /*forDecoratorMetadata*/
-        true
-      );
-    }
-  }
   function getEntityNameForDecoratorMetadata(node) {
     if (node) {
       switch (node.kind) {
@@ -79291,42 +79539,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    if (compilerOptions.emitDecoratorMetadata) {
-      checkExternalEmitHelpers(firstDecorator, 16 /* Metadata */);
-      switch (node.kind) {
-        case 263 /* ClassDeclaration */:
-          const constructor = getFirstConstructorWithBody(node);
-          if (constructor) {
-            for (const parameter of constructor.parameters) {
-              markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
-            }
-          }
-          break;
-        case 177 /* GetAccessor */:
-        case 178 /* SetAccessor */:
-          const otherKind = node.kind === 177 /* GetAccessor */ ? 178 /* SetAccessor */ : 177 /* GetAccessor */;
-          const otherAccessor = getDeclarationOfKind(getSymbolOfDeclaration(node), otherKind);
-          markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor));
-          break;
-        case 174 /* MethodDeclaration */:
-          for (const parameter of node.parameters) {
-            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
-          }
-          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(node));
-          break;
-        case 172 /* PropertyDeclaration */:
-          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveTypeAnnotationNode(node));
-          break;
-        case 169 /* Parameter */:
-          markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node));
-          const containingSignature = node.parent;
-          for (const parameter of containingSignature.parameters) {
-            markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter));
-          }
-          markDecoratorMedataDataTypeNodeAsReferenced(getEffectiveReturnTypeNode(containingSignature));
-          break;
-      }
-    }
+    markLinkedReferences(node, 8 /* Decorator */);
     for (const modifier of node.modifiers) {
       if (isDecorator(modifier)) {
         checkDecorator(modifier);
@@ -82667,9 +82880,7 @@ function createTypeChecker(host) {
     checkGrammarModifiers(node);
     if (isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) {
       checkImportBinding(node);
-      if (hasSyntacticModifier(node, 32 /* Export */)) {
-        markExportAsReferenced(node);
-      }
+      markLinkedReferences(node, 6 /* ExportImportEquals */);
       if (node.moduleReference.kind !== 283 /* ExternalModuleReference */) {
         const target = resolveAlias(getSymbolOfDeclaration(node));
         if (target !== unknownSymbol) {
@@ -82767,13 +82978,7 @@ function createTypeChecker(host) {
       if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || symbol.declarations && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) {
         error(exportedName, Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, idText(exportedName));
       } else {
-        if (!node.isTypeOnly && !node.parent.parent.isTypeOnly) {
-          markExportAsReferenced(node);
-        }
-        const target = symbol && (symbol.flags & 2097152 /* Alias */ ? resolveAlias(symbol) : symbol);
-        if (!target || getSymbolFlags(target) & 111551 /* Value */) {
-          checkExpressionCached(node.propertyName || node.name);
-        }
+        markLinkedReferences(node, 7 /* ExportSpecifier */);
       }
     } else {
       if (getESModuleInterop(compilerOptions) && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) < 4 /* System */ && idText(node.propertyName || node.name) === "default") {
@@ -82815,8 +83020,8 @@ function createTypeChecker(host) {
         node
       ));
       if (sym) {
+        markLinkedReferences(node, 3 /* ExportAssignment */);
         const typeOnlyDeclaration = getTypeOnlyAliasDeclaration(sym, 111551 /* Value */);
-        markAliasReferenced(sym, id);
         if (getSymbolFlags(sym) & 111551 /* Value */) {
           checkExpressionCached(id);
           if (!isIllegalExportDefaultInCJS && !(node.flags & 33554432 /* Ambient */) && compilerOptions.verbatimModuleSyntax && typeOnlyDeclaration) {