typescript 5.5.0-dev.20240508 → 5.5.0-dev.20240510

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.20240508`;
+var version = `${versionMajorMinor}.0-dev.20240510`;
 
 // 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);
 }
@@ -45467,7 +45471,8 @@ function createTypeChecker(host) {
     getTypeOnlyAliasDeclaration,
     getMemberOverrideModifierStatus,
     isTypeParameterPossiblyReferenced,
-    typeHasCallOrConstructSignatures
+    typeHasCallOrConstructSignatures,
+    getSymbolFlags
   };
   function getCandidateSignaturesForStringLiteralCompletions(call, editingArgument) {
     const candidatesSet = /* @__PURE__ */ new Set();
@@ -47657,37 +47662,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;
@@ -51119,7 +51093,7 @@ function createTypeChecker(host) {
       var _a;
       const addUndefined = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
       const enclosingDeclaration = context.enclosingDeclaration;
-      if (!isErrorType(type) && enclosingDeclaration) {
+      if (enclosingDeclaration && (!isErrorType(type) || context.flags & 1 /* AllowUnresolvedNames */)) {
         const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration) ? declaration : getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
         if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
           const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation);
@@ -51408,7 +51382,7 @@ function createTypeChecker(host) {
           );
         }
         if (isNamedDeclaration(node) && node.name.kind === 167 /* ComputedPropertyName */ && !isLateBindableName(node.name)) {
-          if (!(context.flags & 1 /* AllowUnresolvedComputedNames */ && hasDynamicName(node) && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
+          if (!(context.flags & 1 /* AllowUnresolvedNames */ && hasDynamicName(node) && isEntityNameExpression(node.name.expression) && checkComputedPropertyName(node.name).flags & 1 /* Any */)) {
             return void 0;
           }
         }
@@ -68912,6 +68886,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;
@@ -68933,6 +69149,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);
@@ -69028,7 +69315,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);
@@ -71571,42 +71858,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);
@@ -72037,7 +72289,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;
       }
@@ -72050,9 +72308,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;
@@ -78985,7 +79241,7 @@ function createTypeChecker(host) {
         return;
       }
     } else {
-      markTypeNodeAsReferenced(returnTypeNode);
+      markLinkedReferences(node, 5 /* AsyncFunction */);
       if (isErrorType(returnType)) {
         return;
       }
@@ -79169,48 +79425,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) {
@@ -79290,42 +79504,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);
@@ -82666,9 +82845,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) {
@@ -82766,13 +82943,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") {
@@ -82814,8 +82985,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) {
@@ -109875,7 +110046,7 @@ function getDeclarationDiagnostics(host, resolver, file) {
   );
   return result.diagnostics;
 }
-var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 1 /* AllowUnresolvedComputedNames */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
+var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 1 /* AllowUnresolvedNames */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
 function transformDeclarations(context) {
   const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
   let getSymbolAccessibilityDiagnostic = throwDiagnostic;