Replace @hasAsyncAlt with @completionHandlerAsync

This patch replaces the @hasAsyncAlternative attribute with
@completionHandlerAsync. The @completionHandlerAsync attribute takes the
function decl name of the async function and optionally the index of the
completion hander parameter in the function that it's attached to.
If the completion handler index is not provided, it's assumed to be the
last parameter in the parameter list.

We resolve the async function while typechecking the attribute. Before
resolving, we verify that the function the attribute is attached to
isn't async, that it has enough parameters to at least have the
indicated completion handler referenced by the index, that the
completion handler is an escaping non-auto-closure function that returns
Void.

The async function declaration resolution isn't perfect yet, but I want
to get this patch up and we can refine it later. It pulls all of the
delcs with the specified declname in the same context as the
function that the attribute is attached to. Going through that list, it
keeps any that are async functions. If there are none, we emit an error
saying that there are no viable functions, if there are multiple we emit
an error saying that the decl name is ambiguous, and if there is one
function, we keep that as the resolve async function declaration.

This does not take into account the data types of the completion handler
or the async function. There are some complexities to making this
mapping. Here are the pieces:
 - If the completion handler takes a single data type, the async
   function should return that type. (easy case)
 - If the completion handler takes a `Result<T, Error>`, the async
   function is a throwing function that returns a T. (Medium difficulty)
 - If the completion handler looks like `(T?, Error?) -> Void`, we have
   an ambiguous situation between the following async functions:
   - func foo() async throws -> T
   - func foo() async throws -> T?
   That is, we cannot tell whether the `T?` in the completion handler is
   optional because it will be nil on an error, or if it is intended to
   be optional.

This can be done later if it becomes a problem.

Author: etcwilde

include/swift/AST/Attr.def

@@ -624,7 +624,7 @@ SIMPLE_DECL_ATTR(reasync, AtReasync,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   110)
 
-DECL_ATTR(hasAsyncAlternative, HasAsyncAlternative,
+DECL_ATTR(completionHandlerAsync, CompletionHandlerAsync,
   OnAbstractFunction | ConcurrencyOnly |
   ABIStableToAdd | ABIStableToRemove |
   APIStableToAdd | APIStableToRemove,

include/swift/AST/Attr.h

@@ -2147,27 +2147,44 @@ class TransposeAttr final
   }
 };
 
-/// The `@hasAsyncAlternative` attribute marks a function as having an async
+/// The `@completionHandlerAsync` attribute marks a function as having an async
 /// alternative, optionally providing a name (for cases when the alternative
 /// has a different name).
-class HasAsyncAlternativeAttr final : public DeclAttribute  {
+class CompletionHandlerAsyncAttr final : public DeclAttribute {
 public:
-  /// An optional name of the async alternative function, where the name of the
-  /// attributed function is used otherwise.
-  const DeclNameRef Name;
+  /// Source location of the async function name in the attribute
+  const SourceLoc AsyncFunctionNameLoc;
 
-  HasAsyncAlternativeAttr(DeclNameRef Name, SourceLoc AtLoc, SourceRange Range)
-    : DeclAttribute(DAK_HasAsyncAlternative, AtLoc, Range, false),
-      Name(Name) {}
+  /// DeclName of the async function in the attribute
+  const DeclNameRef AsyncFunctionName;
 
-  HasAsyncAlternativeAttr(SourceLoc AtLoc, SourceRange Range)
-    : DeclAttribute(DAK_HasAsyncAlternative, AtLoc, Range, false) {}
+  /// Source location of the completion handler index passed to the index
+  const SourceLoc CompletionHandlerIndexLoc;
 
-  /// Determine whether this attribute has a name associated with it.
-  bool hasName() const { return !Name.getBaseName().empty(); }
+  /// The index of the completion handler
+  const size_t CompletionHandlerIndex;
+
+  /// True when the completion handler was specified explicitly
+  const bool ExplicitCompletionHandlerIndex;
+
+  AbstractFunctionDecl *AsyncFunctionDecl = nullptr;
+
+  CompletionHandlerAsyncAttr(DeclNameRef asyncFunctionName,
+                             SourceLoc asyncFunctionNameLoc,
+                             bool explicitCompletionHandlerIndex,
+                             size_t completionHandlerIndex,
+                             SourceLoc completionHandlerIndexLoc,
+                             SourceLoc atLoc, SourceRange range)
+      : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
+                      /*implicit*/ false),
+        AsyncFunctionNameLoc(asyncFunctionNameLoc),
+        AsyncFunctionName(asyncFunctionName),
+        CompletionHandlerIndexLoc(completionHandlerIndexLoc),
+        CompletionHandlerIndex(completionHandlerIndex),
+        ExplicitCompletionHandlerIndex(explicitCompletionHandlerIndex) {}
 
   static bool classof(const DeclAttribute *DA) {
-    return DA->getKind() == DAK_HasAsyncAlternative;
+    return DA->getKind() == DAK_CompletionHandlerAsync;
   }
 };
 

include/swift/AST/DiagnosticsParse.def

@@ -1376,6 +1376,9 @@ ERROR(attr_expected_comma,none,
 ERROR(attr_expected_string_literal,none,
 "expected string literal in '%0' attribute", (StringRef))
 
+ERROR(attr_expected_integer_literal,none,
+"expected integer literal in '%0' attribute", (StringRef))
+
 ERROR(attr_expected_option_such_as,none,
       "expected '%0' option such as '%1'", (StringRef, StringRef))
 
@@ -1675,8 +1678,8 @@ ERROR(sil_inst_autodiff_invalid_witness_generic_signature,PointsToFirstBadToken,
       "parameters as original function generic signature '%1'",
       (StringRef, StringRef))
 
-// hasAsyncAlternative
-ERROR(has_async_alternative_invalid_name, none,
+// completionHandlerAsync
+ERROR(attr_completion_handler_async_invalid_name, none,
       "argument of '%0' attribute must be an identifier or full function name",
       (StringRef))
 

include/swift/AST/DiagnosticsSema.def

@@ -3340,6 +3340,33 @@ ERROR(diff_params_clause_param_not_differentiable,none,
       "can only differentiate with respect to parameters that conform to "
       "'Differentiable', but %0 does not conform to 'Differentiable'", (Type))
 
+// completionHanderAsync attribute
+ERROR(attr_completion_handler_async_handler_not_func,none,
+      "'%0' should be attached to a non-async completion-handler function",
+      (DeclAttribute))
+
+NOTE(note_attr_function_declared_async,none,
+     "function declared async", ())
+
+NOTE(note_attr_completion_function_must_return_void,none,
+     "completion handler must return 'Void'", ())
+
+NOTE(note_attr_completion_handler_async_type_is_not_function,none,
+     "%0 is not a function type", (Type))
+
+NOTE(note_attr_completion_handler_async_handler_attr_req,none,
+     "completion handler must%select{ not|}0 be '@%1'",
+     (bool, StringRef))
+
+ERROR(attr_completion_handler_async_handler_out_of_range,none,
+      "completion handler index out of range of the function parameters", ())
+
+ERROR(attr_completion_handler_async_ambiguous_function,none,
+      "ambiguous '%0' async function %1", (DeclAttribute, DeclNameRef))
+
+ERROR(attr_completion_handler_async_no_suitable_function,none,
+      "no corresponding async function named %0", (DeclNameRef))
+
 //------------------------------------------------------------------------------
 // MARK: Type Check Expressions
 //------------------------------------------------------------------------------

lib/AST/Attr.cpp

@@ -1225,8 +1225,8 @@ StringRef DeclAttribute::getAttrName() const {
     return "derivative";
   case DAK_Transpose:
     return "transpose";
-  case DAK_HasAsyncAlternative:
-    return "hasAsyncAlternative";
+  case DAK_CompletionHandlerAsync:
+    return "completionHandlerAsync";
   }
   llvm_unreachable("bad DeclAttrKind");
 }

lib/Parse/ParseDecl.cpp

@@ -1570,42 +1570,68 @@ void Parser::parseAllAvailabilityMacroArguments() {
   AvailabilityMacrosComputed = true;
 }
 
-static HasAsyncAlternativeAttr *parseAsyncAlternativeAttribute(
-    Parser &P, StringRef AttrName, SourceLoc AtLoc, DeclAttrKind DK) {
+static CompletionHandlerAsyncAttr *
+parseCompletionHandlerAsyncAttribute(Parser &P, StringRef AttrName,
+                                     SourceLoc AtLoc, DeclAttrKind DK) {
   SourceLoc Loc = P.PreviousLoc;
 
-  // Unnamed @hasAsyncAlternative attribute
-  if (P.Tok.isNot(tok::l_paren))
-    return new (P.Context) HasAsyncAlternativeAttr(AtLoc, Loc);
-
-  P.consumeToken(tok::l_paren);
+  if (!P.consumeIf(tok::l_paren)) {
+    P.diagnose(P.getEndOfPreviousLoc(), diag::attr_expected_lparen, AttrName,
+               DeclAttribute::isDeclModifier(DK));
+    return nullptr;
+  }
 
   if (!P.Tok.is(tok::string_literal)) {
     P.diagnose(Loc, diag::attr_expected_string_literal, AttrName);
     return nullptr;
   }
 
-  auto Value = P.getStringLiteralIfNotInterpolated(
-      Loc, ("argument of '" + AttrName + "'").str());
+  SourceLoc nameLoc = P.Tok.getLoc();
+  Optional<StringRef> asyncFunctionName = P.getStringLiteralIfNotInterpolated(
+      nameLoc, ("argument of '" + AttrName + "'").str());
   P.consumeToken(tok::string_literal);
-  if (!Value)
+
+  if (!asyncFunctionName)
     return nullptr;
 
-  ParsedDeclName parsedName = parseDeclName(Value.getValue());
-  if (!parsedName || !parsedName.ContextName.empty()) {
-    P.diagnose(AtLoc, diag::has_async_alternative_invalid_name, AttrName);;
+  ParsedDeclName parsedAsyncName = parseDeclName(*asyncFunctionName);
+  if (!parsedAsyncName || !parsedAsyncName.ContextName.empty()) {
+    P.diagnose(nameLoc, diag::attr_completion_handler_async_invalid_name,
+               AttrName);
     return nullptr;
   }
 
+  size_t handlerIndex = 0;
+  SourceLoc handlerIndexLoc = SourceLoc();
+  if (P.consumeIf(tok::comma)) {
+    // The completion handler is explicitly specified, parse it
+    if (P.parseSpecificIdentifier("completionHandlerIndex",
+                                  diag::attr_missing_label,
+                                  "completionHandlerIndex", AttrName) ||
+        P.parseToken(tok::colon, diag::expected_colon_after_label,
+                     "completionHandlerIndex")) {
+      return nullptr;
+    }
+
+    if (P.Tok.getText().getAsInteger(0, handlerIndex)) {
+      P.diagnose(P.Tok.getLoc(), diag::attr_expected_integer_literal, AttrName);
+      return nullptr;
+    }
+
+    handlerIndexLoc = P.consumeToken(tok::integer_literal);
+  }
+
   SourceRange AttrRange = SourceRange(Loc, P.Tok.getRange().getStart());
   if (!P.consumeIf(tok::r_paren)) {
-    P.diagnose(Loc, diag::attr_expected_rparen, AttrName,
+    P.diagnose(P.getEndOfPreviousLoc(), diag::attr_expected_rparen, AttrName,
                DeclAttribute::isDeclModifier(DK));
     return nullptr;
   }
 
-  return new (P.Context) HasAsyncAlternativeAttr(
-      parsedName.formDeclNameRef(P.Context), AtLoc, AttrRange);
+  return new (P.Context) CompletionHandlerAsyncAttr(
+      parsedAsyncName.formDeclNameRef(P.Context), nameLoc,
+      handlerIndexLoc.isValid(), handlerIndex, handlerIndexLoc, AtLoc,
+      AttrRange);
 }
 
 bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
@@ -2686,8 +2712,9 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
         name, AtLoc, range, /*implicit*/ false));
     break;
   }
-  case DAK_HasAsyncAlternative: {
-    auto *attr = parseAsyncAlternativeAttribute(*this, AttrName, AtLoc, DK);
+  case DAK_CompletionHandlerAsync: {
+    auto *attr =
+        parseCompletionHandlerAsyncAttribute(*this, AttrName, AtLoc, DK);
     if (!attr) {
       skipUntilDeclStmtRBrace(tok::r_paren);
       consumeIf(tok::r_paren);