Switch the Subject of Dependency References to a DeclContext

Author: CodaFi

include/swift/AST/DependencyCollector.h

@@ -23,7 +23,7 @@
 
 namespace swift {
 
-class NominalTypeDecl;
+class DeclContext;
 
 namespace evaluator {
 
@@ -50,31 +50,31 @@ struct DependencyCollector {
       Dynamic,
     } kind;
 
-    NominalTypeDecl *subject;
+    DeclContext *subject;
     DeclBaseName name;
 
   private:
-    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name)
+    Reference(Kind kind, DeclContext *subject, DeclBaseName name)
         : kind(kind), subject(subject), name(name) {}
 
   public:
     static Reference empty() {
-      return {Kind::Empty, llvm::DenseMapInfo<NominalTypeDecl *>::getEmptyKey(),
+      return {Kind::Empty, llvm::DenseMapInfo<DeclContext *>::getEmptyKey(),
               llvm::DenseMapInfo<DeclBaseName>::getEmptyKey()};
     }
 
     static Reference tombstone() {
       return {Kind::Tombstone,
-              llvm::DenseMapInfo<NominalTypeDecl *>::getTombstoneKey(),
+              llvm::DenseMapInfo<DeclContext *>::getTombstoneKey(),
               llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey()};
     }
 
   public:
-    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name) {
+    static Reference usedMember(DeclContext *subject, DeclBaseName name) {
       return {Kind::UsedMember, subject, name};
     }
 
-    static Reference potentialMember(NominalTypeDecl *subject) {
+    static Reference potentialMember(DeclContext *subject) {
       return {Kind::PotentialMember, subject, DeclBaseName()};
     }
 
@@ -119,7 +119,7 @@ struct DependencyCollector {
   /// up front. A used member dependency causes the file to be rebuilt if the
   /// definition of that member changes in any way - via
   /// deletion, addition, or mutation of a member with that same name.
-  void addUsedMember(NominalTypeDecl *subject, DeclBaseName name);
+  void addUsedMember(DeclContext *subject, DeclBaseName name);
   /// Registers a reference from the current dependency scope to a
   /// "potential member" of the given \p subject type.
   ///
@@ -133,7 +133,7 @@ struct DependencyCollector {
   ///
   /// These dependencies are most appropriate for protocol conformances,
   /// superclass constraints, and other requirements involving entire types.
-  void addPotentialMember(NominalTypeDecl *subject);
+  void addPotentialMember(DeclContext *subject);
   /// Registers a reference from the current dependency scope to a given
   /// top-level \p name.
   ///

lib/AST/Evaluator.cpp

@@ -15,6 +15,7 @@
 //
 //===----------------------------------------------------------------------===//
 #include "swift/AST/Evaluator.h"
+#include "swift/AST/DeclContext.h"
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/Basic/LangOptions.h"
 #include "swift/Basic/Range.h"
@@ -112,13 +113,14 @@ evaluator::DependencyCollector::~DependencyCollector() {
 #endif
 }
 
-void evaluator::DependencyCollector::addUsedMember(NominalTypeDecl *subject,
+void evaluator::DependencyCollector::addUsedMember(DeclContext *subject,
                                                    DeclBaseName name) {
+  assert(subject->isTypeContext());
   return parent.recordDependency(Reference::usedMember(subject, name));
 }
 
-void evaluator::DependencyCollector::addPotentialMember(
-    NominalTypeDecl *subject) {
+void evaluator::DependencyCollector::addPotentialMember(DeclContext *subject) {
+  assert(subject->isTypeContext());
   return parent.recordDependency(Reference::potentialMember(subject));
 }
 

lib/AST/FrontendSourceFileDepGraphFactory.cpp

@@ -84,13 +84,13 @@ DependencyKey::Builder DependencyKey::Builder::fromReference(
   case Kind::Tombstone:
     llvm_unreachable("Cannot enumerate dead reference!");
   case Kind::PotentialMember:
-    return Builder{kind, aspect}.withContext(ref.subject);
+    return Builder{kind, aspect}.withContext(ref.subject->getAsDecl());
   case Kind::TopLevel:
   case Kind::Dynamic:
     return Builder{kind, aspect, nullptr, ref.name.userFacingName()};
   case Kind::UsedMember:
     return Builder{kind, aspect, nullptr, ref.name.userFacingName()}
-        .withContext(ref.subject);
+        .withContext(ref.subject->getAsDecl());
   }
 }
 
@@ -455,14 +455,14 @@ class UsedDeclEnumerator {
   void enumerateNominalUses(UseEnumerator enumerator) {
     auto &Ctx = SF->getASTContext();
     Ctx.evaluator.enumerateReferencesInFile(SF, [&](const auto &ref) {
-      const NominalTypeDecl *subject = ref.subject;
+      const DeclContext *subject = ref.subject;
       if (!subject) {
         return;
       }
 
       auto key =
           DependencyKey::Builder(NodeKind::nominal, DeclAspect::interface)
-              .withContext(subject)
+              .withContext(subject->getAsDecl())
               .build();
       enumerateUse(key, enumerator);
     });

lib/Frontend/DependencyVerifier.cpp

@@ -395,12 +395,12 @@ bool DependencyVerifier::constructObligations(const SourceFile *SF,
       llvm_unreachable("Cannot enumerate dead dependency!");
 
     case NodeKind::PotentialMember: {
-      auto key = copyQualifiedTypeName(Ctx, reference.subject);
+      auto key = copyQualifiedTypeName(Ctx, reference.subject->getSelfNominalTypeDecl());
       Obligations.insert({Obligation::Key::forPotentialMember(key),
                           {"", Expectation::Kind::PotentialMember}});
     } break;
     case NodeKind::UsedMember: {
-      auto demContext = copyQualifiedTypeName(Ctx, reference.subject);
+      auto demContext = copyQualifiedTypeName(Ctx, reference.subject->getSelfNominalTypeDecl());
       auto name = reference.name.userFacingName();
       auto key = Ctx.AllocateCopy((demContext + "." + name).str());
       Obligations.insert(