Merge pull request #38832 from apple/cherry-async-alternative-name

[5.5][Refactoring] Use @available(*, renamed:) to link async alternative

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(
+      const AbstractFunctionDecl *asyncAlternative = nullptr) const;
+
   /// Determine whether this function is implicitly known to have its
   /// parameters of function type be @_unsafeSendable.
   ///
@@ -6563,6 +6576,10 @@ class AccessorDecl final : public FuncDecl {
     Bits.AccessorDecl.IsTransparentComputed = 1;
   }
 
+  /// A representation of the name to be displayed to users. \c getNameStr
+  /// for anything other than a getter or setter.
+  void printUserFacingName(llvm::raw_ostream &out) const;
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Accessor;
   }

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

@@ -30,6 +30,8 @@ NOTE(decl_declared_here,none,
      "%0 declared here", (DeclName))
 NOTE(kind_declared_here,none,
      "%0 declared here", (DescriptiveDeclKind))
+NOTE(descriptive_decl_declared_here,none,
+     "'%0' declared here", (StringRef))
 NOTE(implicit_member_declared_here,none,
      "%1 '%0' is implicitly declared", (StringRef, StringRef))
 NOTE(extended_type_declared_here,none,
@@ -3376,32 +3378,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/Module.h

@@ -758,7 +758,6 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   void collectBasicSourceFileInfo(
       llvm::function_ref<void(const BasicSourceFileInfo &)> callback) const;
 
-public:
   /// Retrieve a fingerprint value that summarizes the contents of this module.
   ///
   /// This interface hash a of a module is guaranteed to change if the interface
@@ -771,6 +770,15 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// contents have been made.
   Fingerprint getFingerprint() const;
 
+  /// Returns an approximation of whether the given module could be
+  /// redistributed and consumed by external clients.
+  ///
+  /// FIXME: The scope of this computation should be limited entirely to
+  /// RenamedDeclRequest. Unfortunately, it has been co-opted to support the
+  /// \c SerializeOptionsForDebugging hack. Once this information can be
+  /// transferred from module files to the dSYMs, remove this.
+  bool isExternallyConsumed() const;
+
   SourceRange getSourceRange() const { return SourceRange(); }
 
   static bool classof(const DeclContext *DC) {

include/swift/AST/TypeCheckRequests.h

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

include/swift/AST/TypeCheckerTypeIDZone.def

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

include/swift/Frontend/Frontend.h

@@ -400,15 +400,6 @@ class CompilerInvocation {
   SerializationOptions
   computeSerializationOptions(const SupplementaryOutputPaths &outs,
                               const ModuleDecl *module) const;
-
-  /// Returns an approximation of whether the given module could be
-  /// redistributed and consumed by external clients.
-  ///
-  /// FIXME: The scope of this computation should be limited entirely to
-  /// PrintAsObjC. Unfortunately, it has been co-opted to support the
-  /// \c SerializeOptionsForDebugging hack. Once this information can be
-  /// transferred from module files to the dSYMs, remove this.
-  bool isModuleExternallyConsumed(const ModuleDecl *mod) const;
 };
 
 /// A class which manages the state and execution of the compiler.

include/swift/IDE/Utils.h

@@ -577,8 +577,10 @@ ClangNode extensionGetClangNode(const ExtensionDecl *ext);
 
 /// Utility for finding the referenced declaration from a call, which might
 /// include a second level of function application for a 'self.' expression,
-/// or a curry thunk, etc.
-std::pair<Type, ConcreteDeclRef> getReferencedDecl(Expr *expr);
+/// or a curry thunk, etc. If \p semantic is true then the underlying semantic
+/// expression of \p expr is used.
+std::pair<Type, ConcreteDeclRef> getReferencedDecl(Expr *expr,
+                                                   bool semantic = true);
 
 /// Whether the last expression in \p ExprStack is being called.
 bool isBeingCalled(ArrayRef<Expr*> ExprStack);

include/swift/PrintAsObjC/PrintAsObjC.h

@@ -25,8 +25,7 @@ namespace swift {
   /// header.
   ///
   /// Returns true on error.
-  bool printAsObjC(raw_ostream &out, ModuleDecl *M, StringRef bridgingHeader,
-                   AccessLevel minRequiredAccess);
+  bool printAsObjC(raw_ostream &out, ModuleDecl *M, StringRef bridgingHeader);
 }
 
 #endif

lib/AST/Attr.cpp

@@ -875,8 +875,20 @@ 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: \"";
+      if (auto *Accessor = dyn_cast<AccessorDecl>(Attr->RenameDecl)) {
+        SmallString<32> Name;
+        llvm::raw_svector_ostream OS(Name);
+        Accessor->printUserFacingName(OS);
+        Printer << Name.str();
+      } else {
+        Printer << Attr->RenameDecl->getName();
+      }
+      Printer << "\"";
+    }
 
     // If there's no message, but this is specifically an imported
     // "unavailable in Swift" attribute, synthesize a message to look good in
@@ -1085,20 +1097,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 +1241,6 @@ StringRef DeclAttribute::getAttrName() const {
     return "derivative";
   case DAK_Transpose:
     return "transpose";
-  case DAK_CompletionHandlerAsync:
-    return "completionHandlerAsync";
   }
   llvm_unreachable("bad DeclAttrKind");
 }
@@ -1466,21 +1462,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(),