Merge pull request #17976 from DougGregor/evaluator-override-isobjc

[Type checker] Introduce requests for @objc, override, and 'dynamic' checking

Author: DougGregor

include/swift/AST/AnyRequest.h

@@ -136,9 +136,20 @@ class AnyRequest {
 
 public:
   AnyRequest(const AnyRequest &other) = default;
-  AnyRequest(AnyRequest &&other) = default;
   AnyRequest &operator=(const AnyRequest &other) = default;
-  AnyRequest &operator=(AnyRequest &&other) = default;
+
+  AnyRequest(AnyRequest &&other)
+      : storageKind(other.storageKind), stored(std::move(other.stored)) {
+    other.storageKind = StorageKind::Empty;
+  }
+
+  AnyRequest &operator=(AnyRequest &&other) {
+    storageKind = other.storageKind;
+    stored = std::move(other.stored);
+    other.storageKind = StorageKind::Empty;
+    other.stored = nullptr;
+    return *this;
+  }
 
   AnyRequest(AnyRequest &other)
     : storageKind(other.storageKind), stored(other.stored) { }

include/swift/AST/Decl.h

@@ -2242,8 +2242,20 @@ class ValueDecl : public Decl {
     /// Whether there are any "overridden" declarations. The actual overridden
     /// declarations are kept in a side table in the ASTContext.
     unsigned hasOverridden : 1;
+
+    /// Whether the "isDynamic" bit has been computed yet.
+    unsigned isDynamicComputed : 1;
+
+    /// Whether this declaration is 'dynamic', meaning that all uses of
+    /// the declaration will go through an extra level of indirection that
+    /// allows the entity to be replaced at runtime.
+    unsigned isDynamic : 1;
   } LazySemanticInfo;
 
+  friend class OverriddenDeclsRequest;
+  friend class IsObjCRequest;
+  friend class IsDynamicRequest;
+
 protected:
   ValueDecl(DeclKind K,
             llvm::PointerUnion<DeclContext *, ASTContext *> context,
@@ -2256,6 +2268,8 @@ class ValueDecl : public Decl {
     LazySemanticInfo.isObjC = false;
     LazySemanticInfo.hasOverriddenComputed = false;
     LazySemanticInfo.hasOverridden = false;
+    LazySemanticInfo.isDynamicComputed = false;
+    LazySemanticInfo.isDynamic = false;
   }
 
   // MemberLookupTable borrows a bit from this type
@@ -2468,18 +2482,15 @@ class ValueDecl : public Decl {
   ValueDecl *getOverriddenDecl() const;
 
   /// Retrieve the declarations that this declaration overrides, if any.
-  ArrayRef<ValueDecl *> getOverriddenDecls() const;
+  llvm::TinyPtrVector<ValueDecl *> 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;
@@ -2507,8 +2518,14 @@ class ValueDecl : public Decl {
   }
 
   /// Is this declaration marked with 'dynamic'?
-  bool isDynamic() const {
-    return getAttrs().hasAttribute<DynamicAttr>();
+  bool isDynamic() const;
+
+  /// Set whether this type is 'dynamic' or not.
+  void setIsDynamic(bool value);
+
+  /// Whether the 'dynamic' bit has been computed already.
+  bool isDynamicComputed() const {
+    return LazySemanticInfo.isDynamicComputed;
   }
 
   /// Returns true if this decl can be found by id-style dynamic lookup.
@@ -2884,11 +2901,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());
-  }
+  llvm::TinyPtrVector<AssociatedTypeDecl *> getOverriddenDecls() const;
 
   SourceLoc getStartLoc() const { return KeywordLoc; }
   SourceRange getSourceRange() const;

include/swift/AST/LazyResolver.h

@@ -60,12 +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;
-
   /// Resolve the trailing where clause of the given protocol in-place.
   virtual void resolveTrailingWhereClause(ProtocolDecl *proto) = 0;
 

include/swift/AST/NameLookup.h

@@ -287,12 +287,10 @@ bool removeOverriddenDecls(SmallVectorImpl<ValueDecl*> &decls);
 ///
 /// \param decls The set of declarations being considered.
 /// \param curModule The current module.
-/// \param typeResolver Used to resolve overload types.
 ///
 /// \returns true if any shadowed declarations were removed.
 bool removeShadowedDecls(SmallVectorImpl<ValueDecl*> &decls,
-                         const ModuleDecl *curModule,
-                         LazyResolver *typeResolver);
+                         const ModuleDecl *curModule);
 
 /// Finds decls visible in the given context and feeds them to the given
 /// VisibleDeclConsumer.  If the current DeclContext is nested in a function,

include/swift/AST/TypeCheckRequests.h

@@ -21,6 +21,7 @@
 #include "swift/AST/SimpleRequest.h"
 #include "swift/Basic/Statistic.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/TinyPtrVector.h"
 
 namespace swift {
 
@@ -121,6 +122,89 @@ 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,
+                         llvm::TinyPtrVector<ValueDecl *>,
+                         ValueDecl *> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend class SimpleRequest;
+
+  // Evaluation.
+  llvm::TinyPtrVector<ValueDecl *> evaluate(Evaluator &evaluator,
+                                            ValueDecl *decl) const;
+
+public:
+  // Cycle handling
+  llvm::TinyPtrVector<ValueDecl *> breakCycle() const { return { }; }
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<llvm::TinyPtrVector<ValueDecl *>> getCachedResult() const;
+  void cacheResult(llvm::TinyPtrVector<ValueDecl *> value) const;
+};
+
+/// Determine whether the given declaration is exposed to Objective-C.
+class IsObjCRequest :
+    public SimpleRequest<IsObjCRequest,
+                         CacheKind::SeparatelyCached,
+                         bool,
+                         ValueDecl *> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend class SimpleRequest;
+
+  // Evaluation.
+  bool evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+
+public:
+  // Cycle handling
+  bool breakCycle() const;
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
+};
+
+/// Determine whether the given declaration is 'dynamic''.
+class IsDynamicRequest :
+    public SimpleRequest<IsDynamicRequest,
+                         CacheKind::SeparatelyCached,
+                         bool,
+                         ValueDecl *> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend class SimpleRequest;
+
+  // Evaluation.
+  bool evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+
+public:
+  // Cycle handling
+  bool breakCycle() const;
+  void diagnoseCycle(DiagnosticEngine &diags) const;
+  void noteCycleStep(DiagnosticEngine &diags) const;
+
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool 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,6 @@
 SWIFT_TYPEID(InheritedTypeRequest)
 SWIFT_TYPEID(SuperclassTypeRequest)
 SWIFT_TYPEID(EnumRawTypeRequest)
+SWIFT_TYPEID(OverriddenDeclsRequest)
+SWIFT_TYPEID(IsObjCRequest)
+SWIFT_TYPEID(IsDynamicRequest)

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,47 @@ 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 { };
-
-    // Look up the overridden declarations in the ASTContext.
-    auto known = getASTContext().getImpl().Overrides.find(this);
-    assert(known != getASTContext().getImpl().Overrides.end());
-    return known->second;
-  }
+Optional<llvm::TinyPtrVector<ValueDecl *>>
+OverriddenDeclsRequest::getCachedResult() const {
+  auto decl = std::get<0>(getStorage());
+  if (!decl->LazySemanticInfo.hasOverriddenComputed)
+    return None;
 
-  ASTContext &ctx = getASTContext();
-  if (auto resolver = ctx.getLazyResolver()) {
-    resolver->resolveOverriddenDecl(const_cast<ValueDecl *>(this));
-    assert(LazySemanticInfo.hasOverriddenComputed);
-    return getOverriddenDecls();
-  }
+  // If there are no overridden declarations (the common case), return.
+  llvm::TinyPtrVector<ValueDecl *> overridden;
+  if (!decl->LazySemanticInfo.hasOverridden) return overridden;
 
-  // 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.insert(overridden.end(),
+                    known->second.begin(), known->second.end());
+  return overridden;
 }
 
-ArrayRef<ValueDecl *> ValueDecl::setOverriddenDecls(
-                                            ArrayRef<ValueDecl *> overridden) {
-  LazySemanticInfo.hasOverriddenComputed = true;
+void OverriddenDeclsRequest::cacheResult(
+                                llvm::TinyPtrVector<ValueDecl *> 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.operator ArrayRef<ValueDecl *>());
+  (void)ctx.getImpl().Overrides.insert({decl, overriddenCopy});
 }
 
 bool ASTContext::canImportModule(std::pair<Identifier, SourceLoc> ModulePath) {
@@ -2372,8 +2367,6 @@ void AbstractFunctionDecl::setForeignErrorConvention(
 
 Optional<ForeignErrorConvention>
 AbstractFunctionDecl::getForeignErrorConvention() const {
-  if (!isObjC() && !getAttrs().hasAttribute<CDeclAttr>())
-    return None;
   if (!hasThrows())
     return None;
   auto &conventionsMap = getASTContext().getImpl().ForeignErrorConventions;