Remove AsyncFunctionName from serialization

We can get the DeclName of the async function from the resolved function
decl itself, so we don't actually need to serialize it. This patch pulls
the declNameRef from the serialization.

Author: etcwilde

include/swift/AST/Attr.h

@@ -2151,19 +2151,27 @@ class TransposeAttr final
 /// alternative, optionally providing a name (for cases when the alternative
 /// has a different name).
 class CompletionHandlerAsyncAttr final : public DeclAttribute {
+private:
+  /// DeclName of the async function in the attribute
+  const DeclNameRef AsyncFunctionName;
+
 public:
   /// Source location of the async function name in the attribute
   const SourceLoc AsyncFunctionNameLoc;
 
-  /// DeclName of the async function in the attribute
-  const DeclNameRef AsyncFunctionName;
-
-  /// Source location of the completion handler index passed to the index
-  const SourceLoc CompletionHandlerIndexLoc;
+  /// Get the name of the async function
+  ///
+  /// The name will come from the AsyncFunctionDecl if available, otherwise will
+  /// fall back on the user-provided name. If that is not defined, this function
+  /// will abort.
+  DeclNameRef getAsyncFunctionName() const;
 
   /// The index of the completion handler
   const size_t CompletionHandlerIndex;
 
+  /// Source location of the completion handler index passed to the index
+  const SourceLoc CompletionHandlerIndexLoc;
+
   /// True when the completion handler was specified explicitly
   const bool ExplicitCompletionHandlerIndex;
 
@@ -2177,12 +2185,26 @@ class CompletionHandlerAsyncAttr final : public DeclAttribute {
                              SourceLoc atLoc, SourceRange range)
       : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
                       /*implicit*/ false),
-        AsyncFunctionNameLoc(asyncFunctionNameLoc),
         AsyncFunctionName(asyncFunctionName),
-        CompletionHandlerIndexLoc(completionHandlerIndexLoc),
+        AsyncFunctionNameLoc(asyncFunctionNameLoc),
         CompletionHandlerIndex(completionHandlerIndex),
+        CompletionHandlerIndexLoc(completionHandlerIndexLoc),
         ExplicitCompletionHandlerIndex(explicitCompletionHandlerIndex) {}
 
+  CompletionHandlerAsyncAttr(AbstractFunctionDecl &asyncFunctionDecl,
+                             bool explicitCompletionHandlerIndex,
+                             size_t completionHandlerIndex,
+                             SourceLoc completionHandlerIndexLoc,
+                             SourceLoc atLoc, SourceRange range)
+      : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
+                      /*implicit*/ false),
+        CompletionHandlerIndex(completionHandlerIndex),
+        CompletionHandlerIndexLoc(completionHandlerIndexLoc),
+        ExplicitCompletionHandlerIndex(explicitCompletionHandlerIndex),
+        AsyncFunctionDecl(&asyncFunctionDecl) {}
+
+
+
   static bool classof(const DeclAttribute *DA) {
     return DA->getKind() == DAK_CompletionHandlerAsync;
   }

lib/AST/Attr.cpp

@@ -2002,3 +2002,11 @@ void swift::simple_display(llvm::raw_ostream &out, const DeclAttribute *attr) {
   if (attr)
     attr->print(out);
 }
+
+DeclNameRef CompletionHandlerAsyncAttr::getAsyncFunctionName() const {
+  if (AsyncFunctionDecl)
+    return DeclNameRef(AsyncFunctionDecl->getName());
+  if (AsyncFunctionName)
+    return AsyncFunctionName;
+  llvm_unreachable("completionHandlerAsync attr missing async function name");
+}

lib/Sema/TypeCheckAttr.cpp

@@ -5804,7 +5804,7 @@ void AttributeChecker::visitCompletionHandlerAsyncAttr(
     //  should return all of those types in a tuple
 
     SmallVector<ValueDecl *, 2> allCandidates;
-    lookupReplacedDecl(attr->AsyncFunctionName, attr, attachedFunctionDecl,
+    lookupReplacedDecl(attr->getAsyncFunctionName(), attr, attachedFunctionDecl,
                        allCandidates);
     SmallVector<AbstractFunctionDecl *, 2> candidates;
     candidates.reserve(allCandidates.size());
@@ -5821,12 +5821,12 @@ void AttributeChecker::visitCompletionHandlerAsyncAttr(
     if (candidates.empty()) {
       diagnose(attr->AsyncFunctionNameLoc,
                diag::attr_completion_handler_async_no_suitable_function,
-               attr->AsyncFunctionName);
+               attr->getAsyncFunctionName());
       return;
     } else if (candidates.size() > 1) {
       diagnose(attr->AsyncFunctionNameLoc,
                diag::attr_completion_handler_async_ambiguous_function, attr,
-               attr->AsyncFunctionName);
+               attr->getAsyncFunctionName());
 
       for (AbstractFunctionDecl *candidate : candidates) {
         diagnose(candidate->getLoc(), diag::decl_declared_here,

lib/Serialization/Deserialization.cpp

@@ -4553,34 +4553,19 @@ llvm::Error DeclDeserializer::deserializeDeclCommon() {
       }
 
       case decls_block::CompletionHandlerAsync_DECL_ATTR: {
-        bool isCompound;
-        ArrayRef<uint64_t> rawPieces;
         uint64_t handlerIndex;
         bool explicitHandlerIndex;
         uint64_t asyncFunctionDeclID;
         serialization::decls_block::CompletionHandlerAsyncDeclAttrLayout::
             readRecord(scratch, explicitHandlerIndex, handlerIndex,
-                       asyncFunctionDeclID, isCompound, rawPieces);
-
-        DeclNameRef asyncFunctionName;
-        if (!rawPieces.empty()) {
-          auto baseName = MF.getDeclBaseName(rawPieces[0]);
-          SmallVector<Identifier, 4> pieces;
-          for (auto rawPiece : rawPieces.drop_front())
-            pieces.push_back(MF.getIdentifier(rawPiece));
-          asyncFunctionName = !isCompound
-                                  ? DeclNameRef({baseName})
-                                  : DeclNameRef({ctx, baseName, pieces});
-        }
+                       asyncFunctionDeclID);
 
         auto mappedFunctionDecl =
             cast<AbstractFunctionDecl>(MF.getDecl(asyncFunctionDeclID));
         Attr = new (ctx) CompletionHandlerAsyncAttr(
-            asyncFunctionName, /*functionNameLoc*/ SourceLoc(),
-            explicitHandlerIndex, handlerIndex, /*handlerIndexLoc*/ SourceLoc(),
+            *mappedFunctionDecl, explicitHandlerIndex, handlerIndex,
+            /*handlerIndexLoc*/ SourceLoc(),
             /*atLoc*/ SourceLoc(), /*range*/ SourceRange());
-        static_cast<CompletionHandlerAsyncAttr *>(Attr)->AsyncFunctionDecl =
-            mappedFunctionDecl;
         break;
       }
 

lib/Serialization/ModuleFormat.h

@@ -1928,9 +1928,7 @@ namespace decls_block {
     CompletionHandlerAsync_DECL_ATTR,
     BCFixed<1>,                 // True if explicit handler index
     BCVBR<5>,                   // Completion handler index
-    DeclIDField,                // Mapped async function decl
-    BCFixed<1>,                 // True if compound name
-    BCArray<IdentifierIDField>  // Name and parameters
+    DeclIDField                 // Mapped async function decl
   >;
 
 #define SIMPLE_DECL_ATTR(X, CLASS, ...)         \

lib/Serialization/Serialization.cpp

@@ -2631,17 +2631,10 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
              "Serializing unresolved completion handler async function decl");
       auto asyncFuncDeclID = S.addDeclRef(attr->AsyncFunctionDecl);
 
-      SmallVector<IdentifierID, 4> pieces;
-
-      pieces.push_back(
-          S.addDeclBaseNameRef(attr->AsyncFunctionName.getBaseName()));
-      for (auto argName : attr->AsyncFunctionName.getArgumentNames())
-        pieces.push_back(S.addDeclBaseNameRef(argName));
-
       CompletionHandlerAsyncDeclAttrLayout::emitRecord(
           S.Out, S.ScratchRecord, abbrCode,
           attr->ExplicitCompletionHandlerIndex, attr->CompletionHandlerIndex,
-          asyncFuncDeclID, attr->AsyncFunctionName.isCompoundName(), pieces);
+          asyncFuncDeclID);
       return;
     }
     }