Replace @completionHandlerAsync with @available(*, renamed:)

Instead of a new attribute `@completionHandlerAsync`, allow the use of
the existing `renamed` parameter of `@available` to specify the
asynchronous alternative of a synchronous function.

No errors will be output from invalid names as `@completionHandlerAsync`
had, but if a function is correctly matched then it will be used to
output warnings when using the synchronous function in an asynchronous
context (as before).

Resolves rdar://80612731

Author: bnbarham

include/swift/AST/Attr.def

@@ -625,11 +625,7 @@ SIMPLE_DECL_ATTR(reasync, AtReasync,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   110)
 
-DECL_ATTR(completionHandlerAsync, CompletionHandlerAsync,
-  OnAbstractFunction | ConcurrencyOnly | LongAttribute |
-  ABIStableToAdd | ABIStableToRemove |
-  APIStableToAdd | APIStableToRemove,
-  111)
+// 111 was an experimental @completionHandlerAsync and is now unused
 
 CONTEXTUAL_SIMPLE_DECL_ATTR(nonisolated, Nonisolated,
   DeclModifier | OnFunc | OnConstructor | OnVar | OnSubscript |

include/swift/AST/Attr.h

@@ -626,7 +626,7 @@ class AvailableAttr : public DeclAttribute {
 
   AvailableAttr(SourceLoc AtLoc, SourceRange Range,
                    PlatformKind Platform,
-                   StringRef Message, StringRef Rename,
+                   StringRef Message, StringRef Rename, ValueDecl *RenameDecl,
                    const llvm::VersionTuple &Introduced,
                    SourceRange IntroducedRange,
                    const llvm::VersionTuple &Deprecated,
@@ -636,7 +636,7 @@ class AvailableAttr : public DeclAttribute {
                    PlatformAgnosticAvailabilityKind PlatformAgnostic,
                    bool Implicit)
     : DeclAttribute(DAK_Available, AtLoc, Range, Implicit),
-      Message(Message), Rename(Rename),
+      Message(Message), Rename(Rename), RenameDecl(RenameDecl),
       INIT_VER_TUPLE(Introduced), IntroducedRange(IntroducedRange),
       INIT_VER_TUPLE(Deprecated), DeprecatedRange(DeprecatedRange),
       INIT_VER_TUPLE(Obsoleted), ObsoletedRange(ObsoletedRange),
@@ -657,6 +657,12 @@ class AvailableAttr : public DeclAttribute {
   /// the `NS_SWIFT_NAME` annotation in Objective-C.
   const StringRef Rename;
 
+  /// The declaration referred to by \c Rename. Note that this is only set for
+  /// deserialized attributes or inferred attributes from ObjectiveC code.
+  /// \c ValueDecl::getRenamedDecl should be used to find the declaration
+  /// corresponding to \c Rename.
+  ValueDecl *RenameDecl;
+
   /// Indicates when the symbol was introduced.
   const Optional<llvm::VersionTuple> Introduced;
 
@@ -743,6 +749,11 @@ class AvailableAttr : public DeclAttribute {
                          llvm::VersionTuple Obsoleted
                          = llvm::VersionTuple());
 
+  /// Create an AvailableAttr that indicates the given \p AsyncFunc should be
+  /// preferentially used in async contexts
+  static AvailableAttr *createForAlternative(ASTContext &C,
+                                             AbstractFunctionDecl *AsyncFunc);
+
   AvailableAttr *clone(ASTContext &C, bool implicit) const;
 
   static bool classof(const DeclAttribute *DA) {
@@ -2041,57 +2052,6 @@ class TransposeAttr final
   }
 };
 
-/// 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 CompletionHandlerAsyncAttr final : public DeclAttribute {
-public:
-  /// Reference to the async alternative function. Only set for deserialized
-  /// attributes or inferred attributes from ObjectiveC code.
-  AbstractFunctionDecl *AsyncFunctionDecl;
-
-  /// DeclName of the async function in the attribute. Only set from actual
-  /// Swift code, deserialization/ObjectiveC imports will set the decl instead.
-  const DeclNameRef AsyncFunctionName;
-
-  /// Source location of the async function name in the attribute
-  const SourceLoc AsyncFunctionNameLoc;
-
-  /// The index of the completion handler
-  const size_t CompletionHandlerIndex;
-
-  /// Source location of the completion handler index passed to the index
-  const SourceLoc CompletionHandlerIndexLoc;
-
-  CompletionHandlerAsyncAttr(DeclNameRef asyncFunctionName,
-                             SourceLoc asyncFunctionNameLoc,
-                             size_t completionHandlerIndex,
-                             SourceLoc completionHandlerIndexLoc,
-                             SourceLoc atLoc, SourceRange range)
-      : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
-                      /*implicit*/ false),
-        AsyncFunctionDecl(nullptr),
-        AsyncFunctionName(asyncFunctionName),
-        AsyncFunctionNameLoc(asyncFunctionNameLoc),
-        CompletionHandlerIndex(completionHandlerIndex),
-        CompletionHandlerIndexLoc(completionHandlerIndexLoc) {}
-
-  CompletionHandlerAsyncAttr(AbstractFunctionDecl &asyncFunctionDecl,
-                             size_t completionHandlerIndex,
-                             SourceLoc completionHandlerIndexLoc,
-                             SourceLoc atLoc, SourceRange range,
-                             bool implicit)
-      : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
-                      implicit),
-        AsyncFunctionDecl(&asyncFunctionDecl) ,
-        CompletionHandlerIndex(completionHandlerIndex),
-        CompletionHandlerIndexLoc(completionHandlerIndexLoc) {}
-
-  static bool classof(const DeclAttribute *DA) {
-    return DA->getKind() == DAK_CompletionHandlerAsync;
-  }
-};
-
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/Decl.h

@@ -6168,9 +6168,22 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// constructor.
   bool hasDynamicSelfResult() const;
 
-
+  /// The async function marked as the alternative to this function, if any.
   AbstractFunctionDecl *getAsyncAlternative() const;
 
+  /// If \p asyncAlternative is set, then compare its parameters to this
+  /// (presumed synchronous) function's parameters to find the index of the
+  /// completion handler parameter. This should be the the only missing
+  /// parameter in \p asyncAlternative, ignoring defaulted parameters if they
+  /// have the same label. It must have a void-returning function type and be
+  /// attributed with @escaping but not @autoclosure.
+  ///
+  /// Returns the last index of the parameter that looks like a completion
+  /// handler if \p asyncAlternative is not set (with the same conditions on
+  /// its type as above).
+  Optional<unsigned> findPotentialCompletionHandlerParam(
+      AbstractFunctionDecl *asyncAlternative = nullptr) const;
+
   /// Determine whether this function is implicitly known to have its
   /// parameters of function type be @_unsafeSendable.
   ///

include/swift/AST/DiagnosticsParse.def

@@ -1690,11 +1690,6 @@ ERROR(sil_inst_autodiff_invalid_witness_generic_signature,PointsToFirstBadToken,
       "parameters as original function generic signature '%1'",
       (StringRef, StringRef))
 
-// completionHandlerAsync
-ERROR(attr_completion_handler_async_invalid_name, none,
-      "argument of '%0' attribute must be an identifier or full function name",
-      (StringRef))
-
 //------------------------------------------------------------------------------
 // MARK: Generics parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -3376,32 +3376,6 @@ ERROR(diff_params_clause_param_not_differentiable,none,
       "'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))
-
 WARNING(warn_use_async_alternative,none,
         "consider using asynchronous alternative function",())
 

include/swift/AST/TypeCheckRequests.h

@@ -2969,23 +2969,6 @@ class ConditionalRequirementsRequest
   bool isCached() const { return true; }
 };
 
-class AsyncAlternativeRequest
-    : public SimpleRequest<AsyncAlternativeRequest,
-                           AbstractFunctionDecl *(AbstractFunctionDecl *),
-                           RequestFlags::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  AbstractFunctionDecl *evaluate(
-      Evaluator &evaluator, AbstractFunctionDecl *attachedFunctionDecl) const;
-
-public:
-  bool isCached() const { return true; }
-};
-
 class RenamedDeclRequest
     : public SimpleRequest<RenamedDeclRequest,
                            ValueDecl *(const ValueDecl *, const AvailableAttr *),

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -329,9 +329,6 @@ SWIFT_REQUEST(TypeChecker, SynthesizeMainFunctionRequest,
 SWIFT_REQUEST(TypeChecker, GetImplicitSendableRequest,
               NormalProtocolConformance *(NominalTypeDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, AsyncAlternativeRequest,
-              AbstractFunctionDecl *(AbstractFunctionDecl *),
-              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, RenamedDeclRequest,
-               ValueDecl *(const ValueDecl *),
-               Cached, NoLocationInfo)
+              ValueDecl *(const ValueDecl *),
+              Cached, NoLocationInfo)

lib/AST/Attr.cpp

@@ -875,8 +875,11 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     if (Attr->Obsoleted)
       Printer << ", obsoleted: " << Attr->Obsoleted.getValue().getAsString();
 
-    if (!Attr->Rename.empty())
+    if (!Attr->Rename.empty()) {
       Printer << ", renamed: \"" << Attr->Rename << "\"";
+    } else if (Attr->RenameDecl) {
+      Printer << ", renamed: \"" << Attr->RenameDecl->getName() << "\"";
+    }
 
     // If there's no message, but this is specifically an imported
     // "unavailable in Swift" attribute, synthesize a message to look good in
@@ -1085,20 +1088,6 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
 #include "swift/AST/Attr.def"
     llvm_unreachable("handled above");
 
-  case DAK_CompletionHandlerAsync: {
-    auto *attr = cast<CompletionHandlerAsyncAttr>(this);
-    Printer.printAttrName("@completionHandlerAsync");
-    Printer << "(\"";
-    if (attr->AsyncFunctionDecl) {
-      Printer << attr->AsyncFunctionDecl->getName();
-    } else {
-      Printer << attr->AsyncFunctionName;
-    }
-    Printer << "\", completionHandlerIndex: " <<
-        attr->CompletionHandlerIndex << ')';
-    break;
-  }
-
   default:
     assert(DeclAttribute::isDeclModifier(getKind()) &&
            "handled above");
@@ -1243,8 +1232,6 @@ StringRef DeclAttribute::getAttrName() const {
     return "derivative";
   case DAK_Transpose:
     return "transpose";
-  case DAK_CompletionHandlerAsync:
-    return "completionHandlerAsync";
   }
   llvm_unreachable("bad DeclAttrKind");
 }
@@ -1466,21 +1453,32 @@ AvailableAttr::createPlatformAgnostic(ASTContext &C,
     assert(!Obsoleted.empty());
   }
   return new (C) AvailableAttr(
-    SourceLoc(), SourceRange(), PlatformKind::none, Message, Rename,
+    SourceLoc(), SourceRange(), PlatformKind::none, Message, Rename, nullptr,
     NoVersion, SourceRange(),
     NoVersion, SourceRange(),
     Obsoleted, SourceRange(),
     Kind, /* isImplicit */ false);
 }
 
+AvailableAttr *AvailableAttr::createForAlternative(
+    ASTContext &C, AbstractFunctionDecl *AsyncFunc) {
+  llvm::VersionTuple NoVersion;
+  return new (C) AvailableAttr(
+    SourceLoc(), SourceRange(), PlatformKind::none, "", "", AsyncFunc,
+    NoVersion, SourceRange(),
+    NoVersion, SourceRange(),
+    NoVersion, SourceRange(),
+    PlatformAgnosticAvailabilityKind::None, /*Implicit=*/true);
+}
+
 bool AvailableAttr::isActivePlatform(const ASTContext &ctx) const {
   return isPlatformActive(Platform, ctx.LangOpts);
 }
 
 AvailableAttr *AvailableAttr::clone(ASTContext &C, bool implicit) const {
   return new (C) AvailableAttr(implicit ? SourceLoc() : AtLoc,
                                implicit ? SourceRange() : getRange(),
-                               Platform, Message, Rename,
+                               Platform, Message, Rename, RenameDecl,
                                Introduced ? *Introduced : llvm::VersionTuple(),
                                implicit ? SourceRange() : IntroducedRange,
                                Deprecated ? *Deprecated : llvm::VersionTuple(),

lib/AST/Availability.cpp

@@ -99,7 +99,7 @@ createAvailableAttr(PlatformKind Platform,
   return new (Context) AvailableAttr(
       SourceLoc(), SourceRange(), Platform,
       /*Message=*/StringRef(),
-      /*Rename=*/StringRef(),
+      /*Rename=*/StringRef(), /*RenameDecl=*/nullptr,
         Introduced, /*IntroducedRange=*/SourceRange(),
         Deprecated, /*DeprecatedRange=*/SourceRange(),
         Obsoleted, /*ObsoletedRange=*/SourceRange(),