Requestify @completionHandlerAsync typechecking

This patch puts the type-checking of @completionHandlerAsync behind a
request. We need to be able to request that it gets computed when
checking for warnings of top-level code and global variables that are
closures.

The current order that these get traversed for typechecking is in
declaration ordering, so if we have a global async closure that calls
the completion handler function declared before the completion handler
function declaration, we won't have typechecked the attribute and
resolved the async function declaration yet. This means that we won't
emit the warning, which is bad.

By requestifying it, we can request that the attribute get typechecked
and resolved earlier and verify that the thing typechecks before we do
anything else.

Author: etcwilde

include/swift/AST/TypeCheckRequests.h

@@ -2936,6 +2936,26 @@ class ConditionalRequirementsRequest
   bool isCached() const { return true; }
 };
 
+class TypeCheckCompletionHandlerAsyncAttrRequest
+    : public SimpleRequest<TypeCheckCompletionHandlerAsyncAttrRequest,
+                           bool(AbstractFunctionDecl *,
+                                CompletionHandlerAsyncAttr *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator,
+                AbstractFunctionDecl *attachedFucntionDecl,
+                CompletionHandlerAsyncAttr *attr) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);
 void simple_display(llvm::raw_ostream &out, ImplicitMemberAction action);

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -323,3 +323,6 @@ SWIFT_REQUEST(TypeChecker, SynthesizeMainFunctionRequest,
 SWIFT_REQUEST(TypeChecker, GetImplicitSendableRequest,
               NormalProtocolConformance *(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, TypeCheckCompletionHandlerAsyncAttrRequest,
+              bool (AbstractFunctionDecl *, CompletionHandlerAsyncAttr *),
+              Cached, NoLocationInfo)

lib/Sema/TypeCheckAttr.cpp

@@ -5609,7 +5609,18 @@ void TypeChecker::checkClosureAttributes(ClosureExpr *closure) {
 
 void AttributeChecker::visitCompletionHandlerAsyncAttr(
     CompletionHandlerAsyncAttr *attr) {
+  AbstractFunctionDecl *AFD = dyn_cast<AbstractFunctionDecl>(D);
+  if (!AFD)
+    return;
+
+  evaluateOrDefault(Ctx.evaluator,
+                    TypeCheckCompletionHandlerAsyncAttrRequest{AFD, attr}, {});
+}
 
+bool TypeCheckCompletionHandlerAsyncAttrRequest::evaluate(
+    Evaluator &evaluator, AbstractFunctionDecl *attachedFunctionDecl,
+    CompletionHandlerAsyncAttr *attr) const {
+  auto &Diags = attachedFunctionDecl->getASTContext().Diags;
   // Check phases:
   //  1. Attached function shouldn't be async and should have enough args
   //     to have a completion handler
@@ -5621,30 +5632,29 @@ void AttributeChecker::visitCompletionHandlerAsyncAttr(
   //      - Do some sanity checking on types
 
   // Phase 1: Typecheck the function the attribute is attached to
-  auto attachedFunctionDecl = cast<AbstractFunctionDecl>(D);
   if (attachedFunctionDecl->hasAsync()) {
-    diagnose(attr->getLocation(),
-             diag::attr_completion_handler_async_handler_not_func, attr);
-    diagnose(attachedFunctionDecl->getAsyncLoc(),
-             diag::note_attr_function_declared_async);
-    return;
+    Diags.diagnose(attr->getLocation(),
+                   diag::attr_completion_handler_async_handler_not_func, attr);
+    Diags.diagnose(attachedFunctionDecl->getAsyncLoc(),
+                   diag::note_attr_function_declared_async);
+    return false;
   }
 
   const ParameterList *attachedFunctionParams =
       attachedFunctionDecl->getParameters();
   assert(attachedFunctionParams && "Attached function has no parameter list");
   if (attachedFunctionParams->size() == 0) {
-    diagnose(attr->getLocation(),
-             diag::attr_completion_handler_async_handler_not_func, attr);
-    return;
+    Diags.diagnose(attr->getLocation(),
+                   diag::attr_completion_handler_async_handler_not_func, attr);
+    return false;
   }
   size_t completionHandlerIndex = attr->CompletionHandlerIndexLoc.isValid()
                                       ? attr->CompletionHandlerIndex
                                       : attachedFunctionParams->size() - 1;
   if (attachedFunctionParams->size() < completionHandlerIndex) {
-    diagnose(attr->CompletionHandlerIndexLoc,
-             diag::attr_completion_handler_async_handler_out_of_range);
-    return;
+    Diags.diagnose(attr->CompletionHandlerIndexLoc,
+                   diag::attr_completion_handler_async_handler_out_of_range);
+    return false;
   }
 
   // Phase 2: Typecheck the completion handler
@@ -5654,14 +5664,17 @@ void AttributeChecker::visitCompletionHandlerAsyncAttr(
     AnyFunctionType *handlerType =
         completionHandlerParamDecl->getType()->getAs<AnyFunctionType>();
     if (!handlerType) {
-      diagnose(attr->getLocation(),
-               diag::attr_completion_handler_async_handler_not_func, attr);
-      diagnose(completionHandlerParamDecl->getTypeRepr()->getLoc(),
-               diag::note_attr_completion_handler_async_type_is_not_function,
-               completionHandlerParamDecl->getType())
+      Diags.diagnose(attr->getLocation(),
+                     diag::attr_completion_handler_async_handler_not_func,
+                     attr);
+      Diags
+          .diagnose(
+              completionHandlerParamDecl->getTypeRepr()->getLoc(),
+              diag::note_attr_completion_handler_async_type_is_not_function,
+              completionHandlerParamDecl->getType())
           .highlight(
               completionHandlerParamDecl->getTypeRepr()->getSourceRange());
-      return;
+      return false;
     }
 
     auto handlerTypeRepr =
@@ -5678,27 +5691,31 @@ void AttributeChecker::visitCompletionHandlerAsyncAttr(
     const bool hasError = missingVoid | hasAutoclosure | !hasEscaping;
 
     if (hasError) {
-      diagnose(attr->getLocation(),
-               diag::attr_completion_handler_async_handler_not_func, attr);
+      Diags.diagnose(attr->getLocation(),
+                     diag::attr_completion_handler_async_handler_not_func,
+                     attr);
 
       if (missingVoid)
-        diagnose(completionHandlerParamDecl->getLoc(),
-                 diag::note_attr_completion_function_must_return_void)
+        Diags
+            .diagnose(completionHandlerParamDecl->getLoc(),
+                      diag::note_attr_completion_function_must_return_void)
             .highlight(
                 completionHandlerParamDecl->getTypeRepr()->getSourceRange());
 
       if (!hasEscaping)
-        diagnose(completionHandlerParamDecl->getLoc(),
-                 diag::note_attr_completion_handler_async_handler_attr_req,
-                 true, "escaping")
+        Diags
+            .diagnose(completionHandlerParamDecl->getLoc(),
+                      diag::note_attr_completion_handler_async_handler_attr_req,
+                      true, "escaping")
             .highlight(
                 completionHandlerParamDecl->getTypeRepr()->getSourceRange());
 
       if (hasAutoclosure)
-        diagnose(handlerTypeAttrs->getLoc(TAK_autoclosure),
-                 diag::note_attr_completion_handler_async_handler_attr_req,
-                 false, "autoclosure");
-      return;
+        Diags.diagnose(
+            handlerTypeAttrs->getLoc(TAK_autoclosure),
+            diag::note_attr_completion_handler_async_handler_attr_req, false,
+            "autoclosure");
+      return false;
     }
   }
 
@@ -5747,21 +5764,23 @@ void AttributeChecker::visitCompletionHandlerAsyncAttr(
     }
 
     if (candidates.empty()) {
-      diagnose(attr->AsyncFunctionNameLoc,
-               diag::attr_completion_handler_async_no_suitable_function,
-               attr->getAsyncFunctionName());
-      return;
+      Diags.diagnose(attr->AsyncFunctionNameLoc,
+                     diag::attr_completion_handler_async_no_suitable_function,
+                     attr->getAsyncFunctionName());
+      return false;
     } else if (candidates.size() > 1) {
-      diagnose(attr->AsyncFunctionNameLoc,
-               diag::attr_completion_handler_async_ambiguous_function, attr,
-               attr->getAsyncFunctionName());
+      Diags.diagnose(attr->AsyncFunctionNameLoc,
+                     diag::attr_completion_handler_async_ambiguous_function,
+                     attr, attr->getAsyncFunctionName());
 
       for (AbstractFunctionDecl *candidate : candidates) {
-        diagnose(candidate->getLoc(), diag::decl_declared_here,
-                 candidate->getName());
+        Diags.diagnose(candidate->getLoc(), diag::decl_declared_here,
+                       candidate->getName());
       }
-      return;
+      return false;
     }
     attr->AsyncFunctionDecl = candidates.front();
   }
+
+  return true;
 }