Merge pull request swiftlang#35205 from slavapestov/nfc-evaluator-cleanup

Small NFC request evaluator cleanup

Author: slavapestov

include/swift/AST/DependencyCollector.h

@@ -0,0 +1,159 @@
+//===--- DependencyCollector.h -------------------------------- -*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a class for recording incremental dependencies.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_DEPENDENCY_COLLECTOR_H
+#define SWIFT_AST_DEPENDENCY_COLLECTOR_H
+
+#include "swift/AST/Identifier.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
+
+namespace swift {
+
+class NominalTypeDecl;
+
+namespace evaluator {
+
+struct DependencyRecorder;
+
+/// A \c DependencyCollector defines an abstract write-only buffer of
+/// \c Reference objects. References are added to a collector during the write
+/// phase of request evaluation (in \c writeDependencySink) with the various
+/// \c add* functions below.
+///
+/// A \c DependencyCollector should not be created directly; instances are
+/// vended by the request evaluator infrastructure itself.
+struct DependencyCollector {
+  friend DependencyRecorder;
+
+  struct Reference {
+  public:
+    enum class Kind {
+      Empty,
+      Tombstone,
+      UsedMember,
+      PotentialMember,
+      TopLevel,
+      Dynamic,
+    } kind;
+
+    NominalTypeDecl *subject;
+    DeclBaseName name;
+
+  private:
+    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name)
+        : kind(kind), subject(subject), name(name) {}
+
+  public:
+    static Reference empty() {
+      return {Kind::Empty, llvm::DenseMapInfo<NominalTypeDecl *>::getEmptyKey(),
+              llvm::DenseMapInfo<DeclBaseName>::getEmptyKey()};
+    }
+
+    static Reference tombstone() {
+      return {Kind::Tombstone,
+              llvm::DenseMapInfo<NominalTypeDecl *>::getTombstoneKey(),
+              llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey()};
+    }
+
+  public:
+    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name) {
+      return {Kind::UsedMember, subject, name};
+    }
+
+    static Reference potentialMember(NominalTypeDecl *subject) {
+      return {Kind::PotentialMember, subject, DeclBaseName()};
+    }
+
+    static Reference topLevel(DeclBaseName name) {
+      return {Kind::TopLevel, nullptr, name};
+    }
+
+    static Reference dynamic(DeclBaseName name) {
+      return {Kind::Dynamic, nullptr, name};
+    }
+
+  public:
+    struct Info {
+      static inline Reference getEmptyKey() { return Reference::empty(); }
+      static inline Reference getTombstoneKey() {
+        return Reference::tombstone();
+      }
+      static inline unsigned getHashValue(const Reference &Val) {
+        return llvm::hash_combine(Val.kind, Val.subject,
+                                  Val.name.getAsOpaquePointer());
+      }
+      static bool isEqual(const Reference &LHS, const Reference &RHS) {
+        return LHS.kind == RHS.kind && LHS.subject == RHS.subject &&
+               LHS.name == RHS.name;
+      }
+    };
+  };
+
+private:
+  DependencyRecorder &parent;
+
+public:
+  explicit DependencyCollector(DependencyRecorder &parent);
+  ~DependencyCollector();
+
+public:
+  /// Registers a named reference from the current dependency scope to a member
+  /// defined in the given \p subject type.
+  ///
+  /// Used member constraints are typically the by-product of direct lookups,
+  /// where the name being looked up and the target of the lookup are known
+  /// 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);
+  /// Registers a reference from the current dependency scope to a
+  /// "potential member" of the given \p subject type.
+  ///
+  /// A single potential member dependency can be thought of as many used member
+  /// dependencies - one for each current member of the subject type, but also
+  /// one for every member that will be added or removed from the type in the
+  /// future. As such, these dependencies cause rebuilds when any members are
+  /// added, removed, or changed in the \p subject type. It also indicates a
+  /// dependency on the \p subject type's existence, so deleting the \p subject
+  /// type will also cause a rebuild.
+  ///
+  /// These dependencies are most appropriate for protocol conformances,
+  /// superclass constraints, and other requirements involving entire types.
+  void addPotentialMember(NominalTypeDecl *subject);
+  /// Registers a reference from the current dependency scope to a given
+  /// top-level \p name.
+  ///
+  /// A top level dependency causes a rebuild when another top-level entity with
+  /// that name is added, removed, or modified.
+  void addTopLevelName(DeclBaseName name);
+  /// Registers a reference from the current dependency scope to a given
+  /// dynamic member \p name.
+  ///
+  /// A dynamic lookup dependency is a special kind of member dependency on
+  /// a name that is found by \c AnyObject lookup.
+  void addDynamicLookupName(DeclBaseName name);
+
+public:
+  /// Retrieves the dependency recorder that created this dependency collector.
+  const DependencyRecorder &getRecorder() const { return parent; }
+};
+
+} // end namespace evaluator
+
+} // end namespace swift
+
+#endif // SWIFT_AST_DEPENDENCY_COLLECTOR_H

include/swift/AST/Evaluator.h

@@ -22,10 +22,9 @@
 #include "swift/AST/EvaluatorDependencies.h"
 #include "swift/Basic/AnyValue.h"
 #include "swift/Basic/Debug.h"
-#include "swift/Basic/Defer.h"
+#include "swift/Basic/LangOptions.h"
 #include "swift/Basic/Statistic.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/PrettyStackTrace.h"

include/swift/AST/EvaluatorDependencies.h

@@ -19,14 +19,16 @@
 #define SWIFT_AST_EVALUATOR_DEPENDENCIES_H
 
 #include "swift/AST/AnyRequest.h"
-#include "swift/AST/AttrKind.h"
-#include "swift/AST/SourceFile.h"
+#include "swift/AST/DependencyCollector.h"
 #include "swift/Basic/NullablePtr.h"
-#include "llvm/ADT/PointerIntPair.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
 #include <vector>
 
 namespace swift {
 
+class SourceFile;
+
 namespace evaluator {
 
 namespace detail {
@@ -42,160 +44,64 @@ template <typename...> using void_t = void;
 // of individual contexts.
 using DependencySource = swift::NullablePtr<SourceFile>;
 
-struct DependencyRecorder;
-
-/// A \c DependencyCollector defines an abstract write-only buffer of
-/// \c Reference objects. References are added to a collector during the write
-/// phase of request evaluation (in \c writeDependencySink) with the various
-/// \c add* functions below..
-///
-/// A \c DependencyCollector cannot be created directly. You must invoke
-/// \c DependencyRecorder::record, which will wire a dependency collector into
-/// the provided continuation block.
-struct DependencyCollector {
-  friend DependencyRecorder;
-
-  struct Reference {
-  public:
-    enum class Kind {
-      Empty,
-      Tombstone,
-      UsedMember,
-      PotentialMember,
-      TopLevel,
-      Dynamic,
-    } kind;
-
-    NominalTypeDecl *subject;
-    DeclBaseName name;
-
-  private:
-    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name)
-        : kind(kind), subject(subject), name(name) {}
-
-  public:
-    static Reference empty() {
-      return {Kind::Empty, llvm::DenseMapInfo<NominalTypeDecl *>::getEmptyKey(),
-              llvm::DenseMapInfo<DeclBaseName>::getEmptyKey()};
-    }
-
-    static Reference tombstone() {
-      return {Kind::Tombstone,
-              llvm::DenseMapInfo<NominalTypeDecl *>::getTombstoneKey(),
-              llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey()};
-    }
-
-  public:
-    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name) {
-      return {Kind::UsedMember, subject, name};
-    }
-
-    static Reference potentialMember(NominalTypeDecl *subject) {
-      return {Kind::PotentialMember, subject, DeclBaseName()};
-    }
-
-    static Reference topLevel(DeclBaseName name) {
-      return {Kind::TopLevel, nullptr, name};
-    }
-
-    static Reference dynamic(DeclBaseName name) {
-      return {Kind::Dynamic, nullptr, name};
-    }
-
-  public:
-    struct Info {
-      static inline Reference getEmptyKey() { return Reference::empty(); }
-      static inline Reference getTombstoneKey() {
-        return Reference::tombstone();
-      }
-      static inline unsigned getHashValue(const Reference &Val) {
-        return llvm::hash_combine(Val.kind, Val.subject,
-                                  Val.name.getAsOpaquePointer());
-      }
-      static bool isEqual(const Reference &LHS, const Reference &RHS) {
-        return LHS.kind == RHS.kind && LHS.subject == RHS.subject &&
-               LHS.name == RHS.name;
-      }
-    };
-  };
-
-private:
-  DependencyRecorder &parent;
-
-public:
-  explicit DependencyCollector(DependencyRecorder &parent);
-  ~DependencyCollector();
-
-public:
-  /// Registers a named reference from the current dependency scope to a member
-  /// defined in the given \p subject type.
-  ///
-  /// Used member constraints are typically the by-product of direct lookups,
-  /// where the name being looked up and the target of the lookup are known
-  /// 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);
-  /// Registers a reference from the current dependency scope to a
-  /// "potential member" of the given \p subject type.
-  ///
-  /// A single potential member dependency can be thought of as many used member
-  /// dependencies - one for each current member of the subject type, but also
-  /// one for every member that will be added or removed from the type in the
-  /// future. As such, these dependencies cause rebuilds when any members are
-  /// added, removed, or changed in the \p subject type. It also indicates a
-  /// dependency on the \p subject type's existence, so deleting the \p subject
-  /// type will also cause a rebuild.
-  ///
-  /// These dependencies are most appropriate for protocol conformances,
-  /// superclass constraints, and other requirements involving entire types.
-  void addPotentialMember(NominalTypeDecl *subject);
-  /// Registers a reference from the current dependency scope to a given
-  /// top-level \p name.
-  ///
-  /// A top level dependency causes a rebuild when another top-level entity with
-  /// that name is added, removed, or modified.
-  void addTopLevelName(DeclBaseName name);
-  /// Registers a reference from the current dependency scope to a given
-  /// dynamic member \p name.
-  ///
-  /// A dynamic lookup dependency is a special kind of member dependency on
-  /// a name that is found by \c AnyObject lookup.
-  void addDynamicLookupName(DeclBaseName name);
-
-public:
-  /// Retrieves the dependency recorder that created this dependency collector.
-  const DependencyRecorder &getRecorder() const { return parent; }
-};
-
 /// A \c DependencyRecorder is an aggregator of named references discovered in a
 /// particular \c DependencyScope during the course of request evaluation.
 struct DependencyRecorder {
   friend DependencyCollector;
 
 private:
+  /// References recorded while evaluating a dependency source request for each
+  /// source file. This map is updated upon completion of a dependency source
+  /// request, and includes all references from each downstream request as well.
   llvm::DenseMap<SourceFile *,
                  llvm::DenseSet<DependencyCollector::Reference,
                                 DependencyCollector::Reference::Info>>
       fileReferences;
+
+  /// References recorded while evaluating each request. This map is populated
+  /// upon completion of each request, and includes all references from each
+  /// downstream request as well. Note that uncached requests don't appear as
+  /// keys in this map; their references are charged to the innermost cached
+  /// active request.
   llvm::DenseMap<AnyRequest, std::vector<DependencyCollector::Reference>>
       requestReferences;
+
+  /// Stack of references from each cached active request. When evaluating a
+  /// dependency sink request, we update the innermost set of references.
+  /// Upon completion of a request, we union the completed request's references
+  /// with the next innermost active request.
   std::vector<llvm::DenseSet<DependencyCollector::Reference,
                              DependencyCollector::Reference::Info>>
       activeRequestReferences;
 
 #ifndef NDEBUG
+  /// Used to catch places where a request's writeDependencySink() method
+  /// kicks off another request, which would break invariants, so we
+  /// disallow this from happening.
   bool isRecording = false;
 #endif
 
 public:
+  /// Push a new empty set onto the activeRequestReferences stack.
   void beginRequest(const swift::ActiveRequest &req);
+
+  /// Pop the activeRequestReferences stack, and insert recorded references
+  /// into the requestReferences map, as well as the next innermost entry in
+  /// activeRequestReferences.
   void endRequest(const swift::ActiveRequest &req);
+
+  /// When replaying a request whose value has already been cached, we need
+  /// to update the innermost set in the activeRequestReferences stack.
   void replayCachedRequest(const swift::ActiveRequest &req);
+
+  /// Upon completion of a dependency source request, we update the
+  /// fileReferences map.
   void handleDependencySourceRequest(const swift::ActiveRequest &req,
                                      SourceFile *source);
 
 private:
+  /// Add an entry to the innermost set on the activeRequestReferences stack.
+  /// Called from the DependencyCollector.
   void recordDependency(const DependencyCollector::Reference &ref);
 
 public:
@@ -205,6 +111,10 @@ struct DependencyRecorder {
   /// Enumerates the set of references associated with a given source file,
   /// passing them to the given enumeration callback.
   ///
+  /// Only makes sense to call once all dependency sources associated with this
+  /// source file have already been evaluated, otherwise the map will obviously
+  /// be incomplete.
+  ///
   /// The order of enumeration is completely undefined. It is the responsibility
   /// of callers to ensure they are order-invariant or are sorting the result.
   void enumerateReferencesInFile(const SourceFile *SF,