AST: Convert IsAsyncHandlerRequest to use separate caching

Author: slavapestov

include/swift/AST/Decl.h

@@ -418,7 +418,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasNestedTypeDeclarations : 1
   );
 
-  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2+1,
+  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2+1+1+1,
     /// Whether we've computed the 'static' flag yet.
     IsStaticComputed : 1,
 
@@ -437,21 +437,28 @@ class alignas(1 << DeclAlignInBits) Decl {
     /// Backing bits for 'self' access kind.
     SelfAccess : 2,
 
+    /// Whether we've computed the IsAsyncHandlerRequest.
+    IsAsyncHandlerComputed : 1,
+
+    /// The value of IsAsyncHandlerRequest.
+    IsAsyncHandler : 1,
+
     /// Whether this is a top-level function which should be treated
     /// as if it were in local context for the purposes of capture
     /// analysis.
     HasTopLevelLocalContextCaptures : 1
   );
 
   SWIFT_INLINE_BITFIELD(AccessorDecl, FuncDecl, 4 + 1 + 1,
-                        /// The kind of accessor this is.
-                        AccessorKind : 4,
+    /// The kind of accessor this is.
+    AccessorKind : 4,
 
-                        /// Whether the accessor is transparent.
-                        IsTransparent : 1,
+    /// Whether the accessor is transparent.
+    IsTransparent : 1,
 
-                        /// Whether we have computed the above.
-                        IsTransparentComputed : 1);
+    /// Whether we have computed the above.
+    IsTransparentComputed : 1
+  );
 
   SWIFT_INLINE_BITFIELD(ConstructorDecl, AbstractFunctionDecl, 1+1,
     /// Whether this constructor can fail, by building an Optional type.
@@ -5926,6 +5933,7 @@ class FuncDecl : public AbstractFunctionDecl {
   friend class SelfAccessKindRequest;
   friend class IsStaticRequest;
   friend class ResultTypeRequest;
+  friend class IsAsyncHandlerRequest;
 
   SourceLoc StaticLoc;  // Location of the 'static' token or invalid.
   SourceLoc FuncLoc;    // Location of the 'func' token.
@@ -5957,6 +5965,8 @@ class FuncDecl : public AbstractFunctionDecl {
     Bits.FuncDecl.SelfAccessComputed = false;
     Bits.FuncDecl.IsStaticComputed = false;
     Bits.FuncDecl.IsStatic = false;
+    Bits.FuncDecl.IsAsyncHandlerComputed = false;
+    Bits.FuncDecl.IsAsyncHandler = false;
     Bits.FuncDecl.HasTopLevelLocalContextCaptures = false;
   }
 
@@ -5987,6 +5997,18 @@ class FuncDecl : public AbstractFunctionDecl {
     return None;
   }
 
+  Optional<bool> getCachedIsAsyncHandler() const {
+    if (Bits.FuncDecl.IsAsyncHandlerComputed)
+      return Bits.FuncDecl.IsAsyncHandler;
+
+    return None;
+  }
+
+  void setIsAsyncHandler(bool value) {
+    Bits.FuncDecl.IsAsyncHandlerComputed = true;
+    Bits.FuncDecl.IsAsyncHandler = value;
+  }
+
 public:
   /// Factory function only for use by deserialization.
   static FuncDecl *createDeserialized(ASTContext &Context,

include/swift/AST/TypeCheckRequests.h

@@ -802,7 +802,7 @@ class SelfAccessKindRequest :
 class IsAsyncHandlerRequest :
     public SimpleRequest<IsAsyncHandlerRequest,
                          bool(FuncDecl *),
-                         RequestFlags::Cached> {
+                         RequestFlags::SeparatelyCached> {
 public:
   using SimpleRequest::SimpleRequest;
 
@@ -812,8 +812,10 @@ class IsAsyncHandlerRequest :
   bool evaluate(Evaluator &evaluator, FuncDecl *func) const;
 
 public:
-  // Caching
+  // Separate caching.
   bool isCached() const { return true; }
+  Optional<bool> getCachedResult() const;
+  void cacheResult(bool value) const;
 };
 
 /// Determine whether the given function can be an @asyncHandler, without

lib/AST/TypeCheckRequests.cpp

@@ -616,6 +616,20 @@ void SelfAccessKindRequest::cacheResult(SelfAccessKind value) const {
   funcDecl->setSelfAccessKind(value);
 }
 
+//----------------------------------------------------------------------------//
+// IsAsyncHandlerRequest computation.
+//----------------------------------------------------------------------------//
+
+Optional<bool> IsAsyncHandlerRequest::getCachedResult() const {
+  auto *funcDecl = std::get<0>(getStorage());
+  return funcDecl->getCachedIsAsyncHandler();
+}
+
+void IsAsyncHandlerRequest::cacheResult(bool value) const {
+  auto *funcDecl = std::get<0>(getStorage());
+  funcDecl->setIsAsyncHandler(value);
+}
+
 //----------------------------------------------------------------------------//
 // IsGetterMutatingRequest computation.
 //----------------------------------------------------------------------------//

lib/Sema/ConstraintSystem.cpp

@@ -2144,14 +2144,6 @@ std::pair<Type, bool> ConstraintSystem::adjustTypeOfOverloadReference(
   llvm_unreachable("Unhandled OverloadChoiceKind in switch.");
 }
 
-/// Whether the declaration is considered 'async'.
-static bool isDeclAsync(ValueDecl *value) {
-  if (auto func = dyn_cast<AbstractFunctionDecl>(value))
-    return func->isAsyncContext();
-
-  return false;
-}
-
 /// Walk a closure AST to determine its effects.
 ///
 /// \returns a function's extended info describing the effects, as
@@ -2374,7 +2366,7 @@ FunctionType::ExtInfo ConstraintSystem::closureEffects(ClosureExpr *expr) {
 
 bool ConstraintSystem::isAsynchronousContext(DeclContext *dc) {
   if (auto func = dyn_cast<AbstractFunctionDecl>(dc))
-    return isDeclAsync(func);
+    return func->isAsyncContext();
 
   if (auto closure = dyn_cast<ClosureExpr>(dc))
     return closureEffects(closure).isAsync();
@@ -2708,8 +2700,10 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
   if (auto *decl = choice.getDeclOrNull()) {
     // If we're choosing an asynchronous declaration within a synchronous
     // context, or vice-versa, increase the async/async mismatch score.
-    if (isAsynchronousContext(useDC) != isDeclAsync(decl))
-      increaseScore(SK_AsyncSyncMismatch);
+    if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
+      if (func->isAsyncContext() != isAsynchronousContext(useDC))
+        increaseScore(SK_AsyncSyncMismatch);
+    }
 
     // If we're binding to an init member, the 'throws' need to line up
     // between the bound and reference types.