Revert "[SymbolGraphGen] synthesize child symbols for type aliases of private…" (#79062)

This reverts commit b1871fb.

Author: QuietMisdreavus

lib/SymbolGraphGen/Symbol.cpp

@@ -37,21 +37,19 @@ using namespace swift;
 using namespace symbolgraphgen;
 
 Symbol::Symbol(SymbolGraph *Graph, const ExtensionDecl *ED,
-               const ValueDecl *SynthesizedBaseTypeDecl, Type BaseType)
+               const NominalTypeDecl *SynthesizedBaseTypeDecl, Type BaseType)
     : Symbol::Symbol(Graph, nullptr, ED, SynthesizedBaseTypeDecl, BaseType) {}
 
 Symbol::Symbol(SymbolGraph *Graph, const ValueDecl *VD,
-               const ValueDecl *SynthesizedBaseTypeDecl, Type BaseType)
+               const NominalTypeDecl *SynthesizedBaseTypeDecl, Type BaseType)
     : Symbol::Symbol(Graph, VD, nullptr, SynthesizedBaseTypeDecl, BaseType) {}
 
 Symbol::Symbol(SymbolGraph *Graph, const ValueDecl *VD, const ExtensionDecl *ED,
-               const ValueDecl *SynthesizedBaseTypeDecl, Type BaseType)
+               const NominalTypeDecl *SynthesizedBaseTypeDecl, Type BaseType)
     : Graph(Graph), D(VD), BaseType(BaseType),
       SynthesizedBaseTypeDecl(SynthesizedBaseTypeDecl) {
-  if (!BaseType && SynthesizedBaseTypeDecl) {
-    if (const auto *NTD = dyn_cast<NominalTypeDecl>(SynthesizedBaseTypeDecl))
-      BaseType = NTD->getDeclaredInterfaceType();
-  }
+  if (!BaseType && SynthesizedBaseTypeDecl)
+    BaseType = SynthesizedBaseTypeDecl->getDeclaredInterfaceType();
   if (D == nullptr) {
     D = ED;
   }

lib/SymbolGraphGen/Symbol.h

@@ -35,10 +35,10 @@ class Symbol {
   /// Either a ValueDecl* or ExtensionDecl*.
   const Decl *D;
   Type BaseType;
-  const ValueDecl *SynthesizedBaseTypeDecl;
+  const NominalTypeDecl *SynthesizedBaseTypeDecl;
 
   Symbol(SymbolGraph *Graph, const ValueDecl *VD, const ExtensionDecl *ED,
-         const ValueDecl *SynthesizedBaseTypeDecl,
+         const NominalTypeDecl *SynthesizedBaseTypeDecl,
          Type BaseTypeForSubstitution = Type());
 
   swift::DeclName getName(const Decl *D) const;
@@ -87,11 +87,11 @@ class Symbol {
 
 public:
   Symbol(SymbolGraph *Graph, const ExtensionDecl *ED,
-         const ValueDecl *SynthesizedBaseTypeDecl,
+         const NominalTypeDecl *SynthesizedBaseTypeDecl,
          Type BaseTypeForSubstitution = Type());
 
   Symbol(SymbolGraph *Graph, const ValueDecl *VD,
-         const ValueDecl *SynthesizedBaseTypeDecl,
+         const NominalTypeDecl *SynthesizedBaseTypeDecl,
          Type BaseTypeForSubstitution = Type());
 
   void serialize(llvm::json::OStream &OS) const;
@@ -108,7 +108,7 @@ class Symbol {
     return BaseType;
   }
 
-  const ValueDecl *getSynthesizedBaseTypeDecl() const {
+  const NominalTypeDecl *getSynthesizedBaseTypeDecl() const {
     return SynthesizedBaseTypeDecl;
   }
 
@@ -175,28 +175,27 @@ using SymbolGraph = swift::symbolgraphgen::SymbolGraph;
 
 template <> struct DenseMapInfo<Symbol> {
   static inline Symbol getEmptyKey() {
-    return Symbol{
-        DenseMapInfo<SymbolGraph *>::getEmptyKey(),
-        DenseMapInfo<const swift::ValueDecl *>::getEmptyKey(),
-        DenseMapInfo<const swift::ValueDecl *>::getTombstoneKey(),
-        DenseMapInfo<swift::Type>::getEmptyKey(),
+    return Symbol {
+      DenseMapInfo<SymbolGraph *>::getEmptyKey(),
+      DenseMapInfo<const swift::ValueDecl *>::getEmptyKey(),
+      DenseMapInfo<const swift::NominalTypeDecl *>::getTombstoneKey(),
+      DenseMapInfo<swift::Type>::getEmptyKey(),
     };
   }
   static inline Symbol getTombstoneKey() {
-    return Symbol{
-        DenseMapInfo<SymbolGraph *>::getTombstoneKey(),
-        DenseMapInfo<const swift::ValueDecl *>::getTombstoneKey(),
-        DenseMapInfo<const swift::ValueDecl *>::getTombstoneKey(),
-        DenseMapInfo<swift::Type>::getTombstoneKey(),
+    return Symbol {
+      DenseMapInfo<SymbolGraph *>::getTombstoneKey(),
+      DenseMapInfo<const swift::ValueDecl *>::getTombstoneKey(),
+      DenseMapInfo<const swift::NominalTypeDecl *>::getTombstoneKey(),
+      DenseMapInfo<swift::Type>::getTombstoneKey(),
     };
   }
   static unsigned getHashValue(const Symbol S) {
     unsigned H = 0;
     H ^= DenseMapInfo<SymbolGraph *>::getHashValue(S.getGraph());
     H ^=
         DenseMapInfo<const swift::Decl *>::getHashValue(S.getLocalSymbolDecl());
-    H ^= DenseMapInfo<const swift::ValueDecl *>::getHashValue(
-        S.getSynthesizedBaseTypeDecl());
+    H ^= DenseMapInfo<const swift::NominalTypeDecl *>::getHashValue(S.getSynthesizedBaseTypeDecl());
     H ^= DenseMapInfo<swift::Type>::getHashValue(S.getBaseType());
     return H;
   }

lib/SymbolGraphGen/SymbolGraph.cpp

@@ -233,18 +233,6 @@ void SymbolGraph::recordEdge(Symbol Source,
 
 void SymbolGraph::recordMemberRelationship(Symbol S) {
   const auto *DC = S.getLocalSymbolDecl()->getDeclContext();
-  const ValueDecl *ParentDecl = DC->getSelfNominalTypeDecl();
-  if (!ParentDecl) {
-    // If we couldn't look up the type the member is declared on (e.g.
-    // because the member is declared in an extension whose extended type
-    // doesn't exist), don't record a memberOf relationship.
-    return;
-  }
-  if (const auto *PublicDecl = Walker.PublicPrivateTypeAliases[ParentDecl]) {
-    // If our member target is a private type that has a public type alias,
-    // point the membership to that type alias instead.
-    ParentDecl = PublicDecl;
-  }
   switch (DC->getContextKind()) {
     case DeclContextKind::GenericTypeDecl:
     case DeclContextKind::ExtensionDecl:
@@ -263,6 +251,13 @@ void SymbolGraph::recordMemberRelationship(Symbol S) {
         return;
       }
 
+      if (DC->getSelfNominalTypeDecl() == nullptr) {
+        // If we couldn't look up the type the member is declared on (e.g.
+        // because the member is declared in an extension whose extended type
+        // doesn't exist), don't record a memberOf relationship.
+        return;
+      }
+
       // If this is an extension to an external type, we use the extension
       // symbol itself as the target.
       if (auto const *Extension =
@@ -274,7 +269,8 @@ void SymbolGraph::recordMemberRelationship(Symbol S) {
         }
       }
 
-      return recordEdge(S, Symbol(this, ParentDecl, nullptr),
+      return recordEdge(S,
+                        Symbol(this, DC->getSelfNominalTypeDecl(), nullptr),
                         RelationshipKind::MemberOf());
     case swift::DeclContextKind::AbstractClosureExpr:
     case swift::DeclContextKind::SerializedAbstractClosure:
@@ -327,16 +323,7 @@ void SymbolGraph::recordConformanceSynthesizedMemberRelationships(Symbol S) {
   bool dropSynthesizedMembers = !Walker.Options.EmitSynthesizedMembers ||
                                 Walker.Options.SkipProtocolImplementations;
 
-  const auto *D = S.getLocalSymbolDecl();
-
-  // If this symbol is a public type alias to a private symbol, collect
-  // synthesized members for the underlying type.
-  if (const auto *TD = dyn_cast<TypeAliasDecl>(D)) {
-    const auto *NTD = TD->getUnderlyingType()->getAnyNominal();
-    if (NTD && Walker.PublicPrivateTypeAliases[NTD] == D)
-        D = NTD;
-  }
-
+  const auto D = S.getLocalSymbolDecl();
   const NominalTypeDecl *OwningNominal = nullptr;
   if (const auto *ThisNominal = dyn_cast<NominalTypeDecl>(D)) {
     OwningNominal = ThisNominal;
@@ -389,11 +376,9 @@ void SymbolGraph::recordConformanceSynthesizedMemberRelationships(Symbol S) {
           // that protocol would otherwise be hidden.
           if (auto *Nominal = Info.Ext->getExtendedNominal()) {
             if (dropSynthesizedMembers &&
-                !isImplicitlyPrivate(Nominal, /*IgnoreContext =*/
-                                     [&](const Decl *P) {
-                                       return Nominal->getModuleContext() ==
-                                              StdlibModule;
-                                     }))
+                !isImplicitlyPrivate(
+                    Nominal, /*IgnoreContext =*/Nominal->getModuleContext() ==
+                                 StdlibModule))
               continue;
           } else if (dropSynthesizedMembers) {
             continue;
@@ -408,12 +393,10 @@ void SymbolGraph::recordConformanceSynthesizedMemberRelationships(Symbol S) {
               // There can be synthesized members on effectively private
               // protocols or things that conform to them. We don't want to
               // include those.
-              if (isImplicitlyPrivate(
-                      SynthMember,
-                      /*IgnoreContext =*/
-                      [&](const Decl *P) {
-                        return SynthMember->getModuleContext() == StdlibModule;
-                      })) {
+              if (isImplicitlyPrivate(SynthMember,
+                                      /*IgnoreContext =*/
+                                      SynthMember->getModuleContext() ==
+                                          StdlibModule)) {
                 continue;
               }
 
@@ -422,29 +405,22 @@ void SymbolGraph::recordConformanceSynthesizedMemberRelationships(Symbol S) {
                 continue;
               }
 
-              const ValueDecl *BaseDecl = OwningNominal;
-              if (Walker.PublicPrivateTypeAliases.contains(BaseDecl))
-                BaseDecl = Walker.PublicPrivateTypeAliases[BaseDecl];
-
-              Symbol Source(this, SynthMember, BaseDecl);
+              Symbol Source(this, SynthMember, OwningNominal);
 
               if (auto *InheritedDecl = Source.getInheritedDecl()) {
                 if (auto *ParentDecl =
                         InheritedDecl->getDeclContext()->getAsDecl()) {
                   if (dropSynthesizedMembers &&
                       !isImplicitlyPrivate(
                           ParentDecl,
-                          /*IgnoreContext =*/
-                          [&](const Decl *P) {
-                            return ParentDecl->getModuleContext() ==
-                                   StdlibModule;
-                          })) {
+                          /*IgnoreContext =*/ParentDecl->getModuleContext() ==
+                              StdlibModule)) {
                     continue;
                   }
                 }
               }
 
-              auto ExtendedSG = Walker.getModuleSymbolGraph(BaseDecl);
+              auto ExtendedSG = Walker.getModuleSymbolGraph(OwningNominal);
 
               ExtendedSG->Nodes.insert(Source);
 
@@ -457,15 +433,7 @@ void SymbolGraph::recordConformanceSynthesizedMemberRelationships(Symbol S) {
 
 void
 SymbolGraph::recordInheritanceRelationships(Symbol S) {
-  const auto *D = S.getLocalSymbolDecl();
-
-  // If this is a public type alias for a private symbol, gather inheritance
-  // for the underlying type instead.
-  if (const auto *TD = dyn_cast<TypeAliasDecl>(D)) {
-    const auto *NTD = TD->getUnderlyingType()->getAnyNominal();
-    if (NTD && Walker.PublicPrivateTypeAliases[NTD] == D)
-      D = NTD;
-  }
+  const auto D = S.getLocalSymbolDecl();
 
   ClassDecl *Super = nullptr;
   if (auto *CD = dyn_cast<ClassDecl>(D))
@@ -474,7 +442,8 @@ SymbolGraph::recordInheritanceRelationships(Symbol S) {
     Super = PD->getSuperclassDecl();
 
   if (Super) {
-    recordEdge(S, Symbol(this, Super, nullptr),
+    recordEdge(Symbol(this, cast<ValueDecl>(D), nullptr),
+               Symbol(this, Super, nullptr),
                RelationshipKind::InheritsFrom());
   }
 }
@@ -553,16 +522,7 @@ void SymbolGraph::recordOptionalRequirementRelationships(Symbol S) {
 }
 
 void SymbolGraph::recordConformanceRelationships(Symbol S) {
-  const auto *D = S.getLocalSymbolDecl();
-
-  // If this is a public type alias for a private symbol, gather conformances
-  // for the underlying type instead.
-  if (const auto *TD = dyn_cast<TypeAliasDecl>(D)) {
-    const auto *NTD = TD->getUnderlyingType()->getAnyNominal();
-    if (NTD && Walker.PublicPrivateTypeAliases[NTD] == D)
-      D = NTD;
-  }
-
+  const auto D = S.getLocalSymbolDecl();
   if (const auto *NTD = dyn_cast<NominalTypeDecl>(D)) {
     if (auto *PD = dyn_cast<ProtocolDecl>(NTD)) {
       for (auto *inherited : PD->getAllInheritedProtocols()) {
@@ -740,8 +700,8 @@ const ValueDecl *getProtocolRequirement(const ValueDecl *VD) {
 
 }
 
-bool SymbolGraph::isImplicitlyPrivate(
-    const Decl *D, llvm::function_ref<bool(const Decl *)> IgnoreContext) const {
+bool SymbolGraph::isImplicitlyPrivate(const Decl *D,
+                                      bool IgnoreContext) const {
   // Don't record unconditionally private declarations
   if (D->isPrivateSystemDecl(/*treatNonBuiltinProtocolsAsPublic=*/false)) {
     return true;
@@ -849,15 +809,16 @@ bool SymbolGraph::isImplicitlyPrivate(
     if (IsGlobalSIMDType) {
       return true;
     }
+
+    if (IgnoreContext) {
+      return false;
+    }
   }
 
   // Check up the parent chain. Anything inside a privately named
   // thing is also private. We could be looking at the `B` of `_A.B`.
   if (const auto *DC = D->getDeclContext()) {
     if (const auto *Parent = DC->getAsDecl()) {
-      if (IgnoreContext && IgnoreContext(Parent))
-        return false;
-
       // Exception: Children of underscored protocols should be considered
       // public, even though the protocols themselves aren't. This way,
       // synthesized copies of those symbols are correctly added to the public
@@ -890,11 +851,7 @@ bool SymbolGraph::isUnconditionallyUnavailableOnAllPlatforms(const Decl *D) cons
 }
 
 /// Returns `true` if the symbol should be included as a node in the graph.
-bool SymbolGraph::canIncludeDeclAsNode(const Decl *D,
-                                       const Decl *PublicAncestorDecl) const {
-  if (PublicAncestorDecl && D == PublicAncestorDecl)
-    return true;
-
+bool SymbolGraph::canIncludeDeclAsNode(const Decl *D) const {
   // If this decl isn't in this module or module that this module imported with `@_exported`, don't record it,
   // as it will appear elsewhere in its module's symbol graph.
 
@@ -916,8 +873,6 @@ bool SymbolGraph::canIncludeDeclAsNode(const Decl *D,
   } else {
     return false;
   }
-  return !isImplicitlyPrivate(
-             cast<ValueDecl>(D), /*IgnoreContext=*/
-             [&](const Decl *P) { return P == PublicAncestorDecl; }) &&
-         !isUnconditionallyUnavailableOnAllPlatforms(cast<ValueDecl>(D));
+  return !isImplicitlyPrivate(cast<ValueDecl>(D)) 
+    && !isUnconditionallyUnavailableOnAllPlatforms(cast<ValueDecl>(D));
 }

lib/SymbolGraphGen/SymbolGraph.h

@@ -220,12 +220,10 @@ struct SymbolGraph {
   /// implicitly internal/private, such as underscore prefixes,
   /// and checking every named parent context as well.
   ///
-  /// \param IgnoreContext A function ref that receives the parent decl
-  /// and returns whether or not the context should be ignored when determining
-  /// privacy.
-  bool isImplicitlyPrivate(
-      const Decl *D,
-      llvm::function_ref<bool(const Decl *)> IgnoreContext = nullptr) const;
+  /// \param IgnoreContext If `true`, don't consider
+  /// the context of the declaration to determine whether it is implicitly private.
+  bool isImplicitlyPrivate(const Decl *D,
+                           bool IgnoreContext = false) const;
 
   /// Returns `true` if the declaration has an availability attribute
   /// that marks it as unconditionally unavailable on all platforms (i.e., where
@@ -234,11 +232,7 @@ struct SymbolGraph {
 
   /// Returns `true` if the declaration should be included as a node
   /// in the graph.
-  ///
-  /// If `PublicAncestorDecl` is set and is an ancestor of `D`, that declaration
-  /// is considered to be public, regardless of its surrounding context.
-  bool canIncludeDeclAsNode(const Decl *D,
-                            const Decl *PublicAncestorDecl = nullptr) const;
+  bool canIncludeDeclAsNode(const Decl *D) const;
 
   /// Returns `true` if the declaration is a requirement of a protocol
   /// or is a default implementation of a protocol