Mark imported @completionHandlerAsync attrs as implicit

Mark imported `@completionHandlerAsync` attrs as
implicit, which avoids printing them in generated
interfaces. And for the sake of completion,
serialize the implicit bit in case it's used
elsewhere in the future.

To make sure we continue to print
`@completionHandlerAsync` attributes explicitly
written by the user in Swift, add a SourceKit
interface test.

Resolves rdar://76685011

Author: hamishknight

include/swift/AST/Attr.h

@@ -2077,9 +2077,10 @@ class CompletionHandlerAsyncAttr final : public DeclAttribute {
   CompletionHandlerAsyncAttr(AbstractFunctionDecl &asyncFunctionDecl,
                              size_t completionHandlerIndex,
                              SourceLoc completionHandlerIndexLoc,
-                             SourceLoc atLoc, SourceRange range)
+                             SourceLoc atLoc, SourceRange range,
+                             bool implicit)
       : DeclAttribute(DAK_CompletionHandlerAsync, atLoc, range,
-                      /*implicit*/ false),
+                      implicit),
         AsyncFunctionDecl(&asyncFunctionDecl) ,
         CompletionHandlerIndex(completionHandlerIndex),
         CompletionHandlerIndexLoc(completionHandlerIndexLoc) {}

lib/ClangImporter/ImportDecl.cpp

@@ -8104,7 +8104,7 @@ void addCompletionHandlerAttribute(Decl *asyncImport,
       member->getAttrs().add(
           new (SwiftContext) CompletionHandlerAsyncAttr(
               cast<AbstractFunctionDecl>(*asyncImport), completionIndex,
-              SourceLoc(), SourceLoc(), SourceRange()));
+              SourceLoc(), SourceLoc(), SourceRange(), /*implicit*/ true));
     }
   }
 }

lib/Serialization/Deserialization.cpp

@@ -4639,16 +4639,17 @@ llvm::Error DeclDeserializer::deserializeDeclCommon() {
       }
 
       case decls_block::CompletionHandlerAsync_DECL_ATTR: {
+        bool isImplicit;
         uint64_t handlerIndex;
         uint64_t asyncFunctionDeclID;
         serialization::decls_block::CompletionHandlerAsyncDeclAttrLayout::
-            readRecord(scratch, handlerIndex, asyncFunctionDeclID);
+            readRecord(scratch, isImplicit, handlerIndex, asyncFunctionDeclID);
 
         auto mappedFunctionDecl =
             cast<AbstractFunctionDecl>(MF.getDecl(asyncFunctionDeclID));
         Attr = new (ctx) CompletionHandlerAsyncAttr(
             *mappedFunctionDecl, handlerIndex, /*handlerIndexLoc*/ SourceLoc(),
-            /*atLoc*/ SourceLoc(), /*range*/ SourceRange());
+            /*atLoc*/ SourceLoc(), /*range*/ SourceRange(), isImplicit);
         break;
       }
 

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 610; // async initializers for nominal types
+const uint16_t SWIFTMODULE_VERSION_MINOR = 611; // implicit bit for CompletionHandlerAsyncAttr
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1930,6 +1930,7 @@ namespace decls_block {
 
   using CompletionHandlerAsyncDeclAttrLayout = BCRecordLayout<
     CompletionHandlerAsync_DECL_ATTR,
+    BCFixed<1>,                 // Implicit flag.
     BCVBR<5>,                   // Completion handler index
     DeclIDField                 // Mapped async function decl
   >;

lib/Serialization/Serialization.cpp

@@ -2633,8 +2633,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
       auto asyncFuncDeclID = S.addDeclRef(attr->AsyncFunctionDecl);
 
       CompletionHandlerAsyncDeclAttrLayout::emitRecord(
-          S.Out, S.ScratchRecord, abbrCode, attr->CompletionHandlerIndex,
-          asyncFuncDeclID);
+          S.Out, S.ScratchRecord, abbrCode, attr->isImplicit(),
+          attr->CompletionHandlerIndex, asyncFuncDeclID);
       return;
     }
     }

test/SourceKit/InterfaceGen/Inputs/gen_concurrency.swift

@@ -0,0 +1,5 @@
+class ClassWithAsyncAndHandler {
+  @completionHandlerAsync("foo(_:)", completionHandlerIndex: 1)
+  func foo(_ operation: String, completionHandler handler: @escaping (Int) -> Void) {}
+  func foo(_ operation: String) async -> Int { 0 }
+}

test/SourceKit/InterfaceGen/Inputs/header_concurrency.h

@@ -0,0 +1,5 @@
+@import Foundation;
+
+@interface ClassWithHandlerMethod
+-(void)methodWithHandler:(NSString *)operation completionHandler:(void (^)(NSInteger))handler;
+@end

test/SourceKit/InterfaceGen/gen_objc_concurrency.swift

@@ -0,0 +1,20 @@
+// REQUIRES: objc_interop
+// REQUIRES: concurrency
+
+// RUN: %empty-directory(%t)
+
+// RUN: %sourcekitd-test -req=interface-gen %S/Inputs/gen_concurrency.swift -- %S/Inputs/gen_concurrency.swift -target %target-triple -I %t -Xfrontend -enable-experimental-concurrency | %FileCheck %s --check-prefix=SWIFT-GEN-INTERFACE
+
+// Make sure we print @completionHandlerAsync when it was explicitly written by the user.
+// SWIFT-GEN-INTERFACE-LABEL: class ClassWithAsyncAndHandler {
+// SWIFT-GEN-INTERFACE:         @completionHandlerAsync("foo(_:)", completionHandlerIndex: 1)
+// SWIFT-GEN-INTERFACE-NEXT:    internal func foo(_ operation: String, completionHandler handler: @escaping (Int) -> Void)
+// SWIFT-GEN-INTERFACE:         internal func foo(_ operation: String) async -> Int
+
+// RUN: %sourcekitd-test -req=interface-gen -using-swift-args -header %S/Inputs/header_concurrency.h -- %s -Xfrontend -enable-objc-interop -Xfrontend -enable-experimental-concurrency -import-objc-header %S/Inputs/header_concurrency.h -sdk %clang-importer-sdk | %FileCheck %s --check-prefix=OBJC-GEN-INTERFACE
+
+// But don't print @completionHandlerAsync if it was implicitly added to an imported Clang decl (rdar://76685011).
+// OBJC-GEN-INTERFACE-LABEL: class ClassWithHandlerMethod {
+// OBJC-GEN-INTERFACE-NOT:     @completionHandlerAsync
+// OBJC-GEN-INTERFACE:         func method(withHandler operation: String!, completionHandler handler: ((Int) -> Void)!)
+// OBJC-GEN-INTERFACE:         func method(withHandler operation: String!) async -> Int