[Type Checker] Introduce a request for “overridden declarations”.

Introduce a new request kind to capture the computation of the set of
overridden declarations of a given declaration, eliminating the
stateful “setOverriddenDecls()” calls from the type checker.

Author: DougGregor

include/swift/AST/Decl.h

@@ -2195,6 +2195,8 @@ class ValueDecl : public Decl {
     unsigned hasOverridden : 1;
   } LazySemanticInfo;
 
+  friend class OverriddenDeclsRequest;
+
 protected:
   ValueDecl(DeclKind K,
             llvm::PointerUnion<DeclContext *, ASTContext *> context,
@@ -2419,18 +2421,15 @@ class ValueDecl : public Decl {
   ValueDecl *getOverriddenDecl() const;
 
   /// Retrieve the declarations that this declaration overrides, if any.
-  ArrayRef<ValueDecl *> getOverriddenDecls() const;
+  SmallVector<ValueDecl *, 1> getOverriddenDecls() const;
 
   /// Set the declaration that this declaration overrides.
   void setOverriddenDecl(ValueDecl *overridden) {
-    (void)setOverriddenDecls(overridden);
+    setOverriddenDecls(overridden);
   }
 
   /// Set the declarations that this declaration overrides.
-  ///
-  /// \returns the ASTContext-allocated version of the array of overridden
-  /// declarations.
-  ArrayRef<ValueDecl *> setOverriddenDecls(ArrayRef<ValueDecl *> overridden);
+  void setOverriddenDecls(ArrayRef<ValueDecl *> overridden);
 
   /// Whether the overridden declarations have already been computed.
   bool overriddenDeclsComputed() const;
@@ -2835,11 +2834,7 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
 
   /// Retrieve the set of associated types overridden by this associated
   /// type.
-  CastArrayRefView<ValueDecl *, AssociatedTypeDecl>
-  getOverriddenDecls() const {
-    return CastArrayRefView<ValueDecl *, AssociatedTypeDecl>(
-        AbstractTypeParamDecl::getOverriddenDecls());
-  }
+  SmallVector<AssociatedTypeDecl *, 1> getOverriddenDecls() const;
 
   SourceLoc getStartLoc() const { return KeywordLoc; }
   SourceRange getSourceRange() const;

include/swift/AST/LazyResolver.h

@@ -60,9 +60,6 @@ class LazyResolver {
   /// consistency and provides the value a type.
   virtual void resolveDeclSignature(ValueDecl *VD) = 0;
 
-  /// Resolve the "overridden" declaration of the given declaration.
-  virtual void resolveOverriddenDecl(ValueDecl *VD) = 0;
-
   /// Resolve the "is Objective-C" bit for the given declaration.
   virtual void resolveIsObjC(ValueDecl *VD) = 0;
 

include/swift/AST/TypeCheckRequests.h

@@ -121,6 +121,35 @@ class EnumRawTypeRequest :
   void cacheResult(Type value) const;
 };
 
+/// Request to determine the set of declarations that were are overridden
+/// by the given declaration.
+class OverriddenDeclsRequest
+  : public SimpleRequest<OverriddenDeclsRequest,
+                         CacheKind::SeparatelyCached,
+                         SmallVector<ValueDecl *, 1>,
+                         ValueDecl *> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend class SimpleRequest;
+
+  // Evaluation.
+  SmallVector<ValueDecl *, 1> evaluate(Evaluator &evaluator,
+                                       ValueDecl *decl) const;
+
+public:
+  // Cycle handling
+  SmallVector<ValueDecl *, 1> breakCycle() const { return { }; }
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<SmallVector<ValueDecl *, 1>> getCachedResult() const;
+  void cacheResult(SmallVector<ValueDecl *, 1> value) const;
+};
+
 /// The zone number for the type checker.
 #define SWIFT_TYPE_CHECKER_REQUESTS_TYPEID_ZONE 10
 

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -17,3 +17,4 @@
 SWIFT_TYPEID(InheritedTypeRequest)
 SWIFT_TYPEID(SuperclassTypeRequest)
 SWIFT_TYPEID(EnumRawTypeRequest)
+SWIFT_TYPEID(OverriddenDeclsRequest)

lib/AST/ASTContext.cpp

@@ -35,6 +35,7 @@
 #include "swift/AST/RawComment.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/AST/SILLayout.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/TypeCheckerDebugConsumer.h"
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/SourceManager.h"
@@ -1594,53 +1595,45 @@ GenericEnvironment *ASTContext::getOrCreateCanonicalGenericEnvironment(
   return env;
 }
 
-ArrayRef<ValueDecl *> ValueDecl::getOverriddenDecls() const {
-  // Check whether the overrides have already been computed.
-  if (LazySemanticInfo.hasOverriddenComputed) {
-    // If there are no overridden declarations (the common case), return.
-    if (!LazySemanticInfo.hasOverridden) return { };
+Optional<SmallVector<ValueDecl *, 1>>
+OverriddenDeclsRequest::getCachedResult() const {
+  auto decl = std::get<0>(getStorage());
+  if (!decl->LazySemanticInfo.hasOverriddenComputed)
+    return None;
 
-    // Look up the overridden declarations in the ASTContext.
-    auto known = getASTContext().getImpl().Overrides.find(this);
-    assert(known != getASTContext().getImpl().Overrides.end());
-    return known->second;
-  }
+  // If there are no overridden declarations (the common case), return.
+  SmallVector<ValueDecl *, 1> overridden;
+  if (!decl->LazySemanticInfo.hasOverridden) return overridden;
 
-  ASTContext &ctx = getASTContext();
-  if (auto resolver = ctx.getLazyResolver()) {
-    resolver->resolveOverriddenDecl(const_cast<ValueDecl *>(this));
-    assert(LazySemanticInfo.hasOverriddenComputed);
-    return getOverriddenDecls();
-  }
-
-  // FIXME: Shouldn't need this fallback.
-  return { };
+  // Retrieve the set of overrides from the ASTContext.
+  ASTContext &ctx = decl->getASTContext();
+  auto known = ctx.getImpl().Overrides.find(decl);
+  assert(known != ctx.getImpl().Overrides.end());
+  overridden.assign(known->second.begin(), known->second.end());
+  return overridden;
 }
 
-ArrayRef<ValueDecl *> ValueDecl::setOverriddenDecls(
-                                            ArrayRef<ValueDecl *> overridden) {
-  LazySemanticInfo.hasOverriddenComputed = true;
+void OverriddenDeclsRequest::cacheResult(
+                                    SmallVector<ValueDecl *, 1> value) const {
+  auto decl = std::get<0>(getStorage());
+  decl->LazySemanticInfo.hasOverriddenComputed = true;
+  decl->LazySemanticInfo.hasOverridden = !value.empty();
 
-  // If the set of overridden declarations is empty, note that.
-  if (overridden.empty()) {
-    LazySemanticInfo.hasOverridden = false;
-    return { };
-  }
+  if (value.empty())
+    return;
 
   // Sanity-check the declarations we were given.
-  for (auto decl : overridden) {
-    assert(decl->getKind() == this->getKind() &&
+  for (auto overriddenDecl : value) {
+    assert(overriddenDecl->getKind() == decl->getKind() &&
            "Overridden decl kind mismatch");
-    if (auto func = dyn_cast<AbstractFunctionDecl>(decl))
+    if (auto func = dyn_cast<AbstractFunctionDecl>(overriddenDecl))
       func->setIsOverridden();
   }
 
   // Record the overrides in the context.
-  auto &ctx = getASTContext();
-  LazySemanticInfo.hasOverridden = true;
-  auto overriddenCopy = ctx.AllocateCopy(overridden);
-  (void)ctx.getImpl().Overrides.insert({this, overriddenCopy});
-  return overriddenCopy;
+  auto &ctx = decl->getASTContext();
+  auto overriddenCopy = ctx.AllocateCopy(value);
+  (void)ctx.getImpl().Overrides.insert({decl, overriddenCopy});
 }
 
 bool ASTContext::canImportModule(std::pair<Identifier, SourceLoc> ModulePath) {

lib/AST/Decl.cpp

@@ -2002,6 +2002,18 @@ CanType ValueDecl::getOverloadSignatureType() const {
   return CanType();
 }
 
+SmallVector<ValueDecl *, 1> ValueDecl::getOverriddenDecls() const {
+  ASTContext &ctx = getASTContext();
+  return ctx.evaluator(OverriddenDeclsRequest{const_cast<ValueDecl *>(this)});
+}
+
+void ValueDecl::setOverriddenDecls(ArrayRef<ValueDecl *> overridden) {
+  SmallVector<ValueDecl *, 1> overriddenVec(overridden.begin(),
+                                            overridden.end());
+  OverriddenDeclsRequest request{const_cast<ValueDecl *>(this)};
+  request.cacheResult(overriddenVec);
+}
+
 bool ValueDecl::isObjC() const {
   if (LazySemanticInfo.isObjCComputed)
     return LazySemanticInfo.isObjC;
@@ -2842,6 +2854,15 @@ SourceRange AssociatedTypeDecl::getSourceRange() const {
   return SourceRange(KeywordLoc, endLoc);
 }
 
+SmallVector<AssociatedTypeDecl *, 1>
+AssociatedTypeDecl::getOverriddenDecls() const {
+  SmallVector<AssociatedTypeDecl *, 1> assocTypes;
+  for (auto decl : AbstractTypeParamDecl::getOverriddenDecls()) {
+    assocTypes.push_back(cast<AssociatedTypeDecl>(decl));
+  }
+  return assocTypes;
+}
+
 AssociatedTypeDecl *AssociatedTypeDecl::getAssociatedTypeAnchor() const {
   auto overridden = getOverriddenDecls();
 

lib/AST/TypeCheckRequests.cpp

@@ -146,3 +146,16 @@ void EnumRawTypeRequest::cacheResult(Type value) const {
   auto enumDecl = std::get<0>(getStorage());
   enumDecl->LazySemanticInfo.RawType.setPointerAndInt(value, true);
 }
+
+//----------------------------------------------------------------------------//
+// Overridden decls computation.
+//----------------------------------------------------------------------------//
+void OverriddenDeclsRequest::diagnoseCycle(DiagnosticEngine &diags) const {
+  auto decl = std::get<0>(getStorage());
+  diags.diagnose(decl, diag::circular_reference);
+}
+
+void OverriddenDeclsRequest::noteCycleStep(DiagnosticEngine &diags) const {
+  auto decl = std::get<0>(getStorage());
+  diags.diagnose(decl, diag::circular_reference_through);
+}

lib/ClangImporter/ImportDecl.cpp

@@ -6389,7 +6389,7 @@ void SwiftDeclConverter::recordObjCOverride(AbstractFunctionDecl *decl) {
   // Make sure that we always set the overriden declarations.
   SWIFT_DEFER {
     if (!decl->overriddenDeclsComputed())
-      (void)decl->setOverriddenDecls({ });
+      decl->setOverriddenDecls({ });
   };
 
   // Figure out the class in which this method occurs.

lib/Sema/CodeSynthesis.h

@@ -98,7 +98,7 @@ void makeFinal(ASTContext &ctx, ValueDecl *D);
 void makeDynamic(ASTContext &ctx, ValueDecl *D);
 
 // Implemented in TypeCheckerOverride.cpp
-bool checkOverrides(TypeChecker &TC, ValueDecl *decl);
+bool checkOverrides(ValueDecl *decl);
 
 // These are implemented in CodeSynthesis.cpp.
 void maybeAddMaterializeForSet(AbstractStorageDecl *storage,

lib/Sema/TypeCheckDecl.cpp

@@ -2373,7 +2373,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       }
     }
 
-    if (!checkOverrides(TC, VD)) {
+    if (!checkOverrides(VD)) {
       // If a property has an override attribute but does not override
       // anything, complain.
       auto overridden = VD->getOverriddenDecl();
@@ -2531,7 +2531,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     AccessControlChecker::checkAccessControl(TC, SD);
     UsableFromInlineChecker::checkUsableFromInline(TC, SD);
 
-    if (!checkOverrides(TC, SD)) {
+    if (!checkOverrides(SD)) {
       // If a subscript has an override attribute but does not override
       // anything, complain.
       if (auto *OA = SD->getAttrs().getAttribute<OverrideAttr>()) {
@@ -3033,7 +3033,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     AccessControlChecker::checkAccessControl(TC, FD);
     UsableFromInlineChecker::checkUsableFromInline(TC, FD);
 
-    if (!checkOverrides(TC, FD)) {
+    if (!checkOverrides(FD)) {
       // If a method has an 'override' keyword but does not
       // override anything, complain.
       if (auto *OA = FD->getAttrs().getAttribute<OverrideAttr>()) {
@@ -3174,7 +3174,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     // Check whether this initializer overrides an initializer in its
     // superclass.
-    if (!checkOverrides(TC, CD)) {
+    if (!checkOverrides(CD)) {
       // If an initializer has an override attribute but does not override
       // anything or overrides something that doesn't need an 'override'
       // keyword (e.g., a convenience initializer), complain.