[Concurrency] Factor "is @asyncHandler"? check into a request.

This is stating for inference of @asyncHandler.

Author: DougGregor

include/swift/AST/Decl.h

@@ -5892,9 +5892,12 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   ///
   /// Functions that are an 'async' context can make calls to 'async' functions.
   bool isAsyncContext() const {
-    return hasAsync() || getAttrs().hasAttribute<AsyncHandlerAttr>();
+    return hasAsync() || isAsyncHandler();
   }
 
+  /// Returns true if the function is an @asyncHandler.
+  bool isAsyncHandler() const;
+
   /// Returns true if the function body throws.
   bool hasThrows() const { return Bits.AbstractFunctionDecl.Throws; }
 

include/swift/AST/TypeCheckRequests.h

@@ -781,6 +781,24 @@ class SelfAccessKindRequest :
   void cacheResult(SelfAccessKind value) const;
 };
 
+/// Determine whether the given function is an @asyncHandler.
+class IsAsyncHandlerRequest :
+    public SimpleRequest<IsAsyncHandlerRequest,
+                         bool(FuncDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, FuncDecl *func) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Request whether the storage has a mutating getter.
 class IsGetterMutatingRequest :
     public SimpleRequest<IsGetterMutatingRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -81,6 +81,8 @@ SWIFT_REQUEST(TypeChecker, ExtendedTypeRequest, Type(ExtensionDecl *), Cached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, FunctionBuilderTypeRequest, Type(ValueDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, IsAsyncHandlerRequest, bool(FuncDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, FunctionOperatorRequest, OperatorDecl *(FuncDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(NameLookup, GenericSignatureRequest,

lib/AST/Decl.cpp

@@ -6691,6 +6691,17 @@ bool AbstractFunctionDecl::argumentNameIsAPIByDefault() const {
   return false;
 }
 
+bool AbstractFunctionDecl::isAsyncHandler() const {
+  auto func = dyn_cast<FuncDecl>(this);
+  if (!func)
+    return false;
+
+  auto mutableFunc = const_cast<FuncDecl *>(func);
+  return evaluateOrDefault(getASTContext().evaluator,
+                           IsAsyncHandlerRequest{mutableFunc},
+                           false);
+}
+
 BraceStmt *AbstractFunctionDecl::getBody(bool canSynthesize) const {
   if ((getBodyKind() == BodyKind::Synthesize ||
        getBodyKind() == BodyKind::Unparsed) &&

lib/Sema/TypeCheckAttr.cpp

@@ -330,10 +330,8 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
       return;
     }
 
-    if (checkAsyncHandler(func, /*diagnose=*/true)) {
-      attr->setInvalid();
-      return;
-    }
+    // Trigger the request to check for @asyncHandler.
+    (void)func->isAsyncHandler();
   }
 };
 } // end anonymous namespace
@@ -5236,3 +5234,19 @@ void swift::addAsyncNotes(FuncDecl *func) {
         .fixItInsert(func->getAttributeInsertionLoc(false), "@asyncHandler ");
   }
 }
+
+bool IsAsyncHandlerRequest::evaluate(
+    Evaluator &evaluator, FuncDecl *func) const {
+  // Check whether the attribute was explicitly specified.
+  if (auto attr = func->getAttrs().getAttribute<AsyncHandlerAttr>()) {
+    // Check for well-formedness.
+    if (checkAsyncHandler(func, /*diagnose=*/true)) {
+      attr->setInvalid();
+      return false;
+    }
+
+    return true;
+  }
+
+  return false;
+}