Merge pull request swiftlang#35661 from DougGregor/serialize-foreign-async-convention

Author: swift-ci

lib/Serialization/DeclTypeRecordNodes.def

@@ -151,7 +151,7 @@ PATTERN(VAR)
 OTHER(PARAMETERLIST, 210)
 // 211 is unused
 OTHER(FOREIGN_ERROR_CONVENTION, 212)
-// 213 is unused
+OTHER(FOREIGN_ASYNC_CONVENTION, 213)
 OTHER(XREF_TYPE_PATH_PIECE, 214)
 OTHER(XREF_VALUE_PATH_PIECE, 215)
 OTHER(XREF_EXTENSION_PATH_PIECE, 216)

lib/Serialization/Deserialization.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/AutoDiff.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/Expr.h"
+#include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Initializer.h"
@@ -2697,6 +2698,8 @@ class DeclDeserializer {
 
     if (auto errorConvention = MF.maybeReadForeignErrorConvention())
       ctor->setForeignErrorConvention(*errorConvention);
+    if (auto asyncConvention = MF.maybeReadForeignAsyncConvention())
+      ctor->setForeignAsyncConvention(*asyncConvention);
 
     if (auto bodyText = MF.maybeReadInlinableBodyText())
       ctor->setBodyStringRepresentation(*bodyText);
@@ -3182,6 +3185,8 @@ class DeclDeserializer {
 
     if (auto errorConvention = MF.maybeReadForeignErrorConvention())
       fn->setForeignErrorConvention(*errorConvention);
+    if (auto asyncConvention = MF.maybeReadForeignAsyncConvention())
+      fn->setForeignAsyncConvention(*asyncConvention);
 
     if (auto bodyText = MF.maybeReadInlinableBodyText())
       fn->setBodyStringRepresentation(*bodyText);
@@ -5485,7 +5490,7 @@ class TypeDeserializer {
 
     auto extInfo =
         SILFunctionType::ExtInfoBuilder(*representation, pseudogeneric,
-                                        noescape, concurrent, async, *diffKind, 
+                                        noescape, concurrent, async, *diffKind,
                                         clangFunctionType)
             .build();
 
@@ -6477,3 +6482,49 @@ Optional<ForeignErrorConvention> ModuleFile::maybeReadForeignErrorConvention() {
 
   llvm_unreachable("Unhandled ForeignErrorConvention in switch.");
 }
+
+Optional<ForeignAsyncConvention> ModuleFile::maybeReadForeignAsyncConvention() {
+  using namespace decls_block;
+
+  SmallVector<uint64_t, 8> scratch;
+
+  BCOffsetRAII restoreOffset(DeclTypeCursor);
+
+  llvm::BitstreamEntry next =
+      fatalIfUnexpected(DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
+  if (next.Kind != llvm::BitstreamEntry::Record)
+    return None;
+
+  unsigned recKind =
+      fatalIfUnexpected(DeclTypeCursor.readRecord(next.ID, scratch));
+  switch (recKind) {
+  case FOREIGN_ASYNC_CONVENTION:
+    restoreOffset.reset();
+    break;
+
+  default:
+    return None;
+  }
+
+  TypeID completionHandlerTypeID;
+  unsigned completionHandlerParameterIndex;
+  unsigned rawErrorParameterIndex;
+  ForeignAsyncConventionLayout::readRecord(scratch,
+                                           completionHandlerTypeID,
+                                           completionHandlerParameterIndex,
+                                           rawErrorParameterIndex);
+
+  Type completionHandlerType = getType(completionHandlerTypeID);
+  CanType canCompletionHandlerType;
+  if (completionHandlerType)
+    canCompletionHandlerType = completionHandlerType->getCanonicalType();
+
+  // Decode the error parameter.
+  Optional<unsigned> completionHandlerErrorParamIndex;
+  if (rawErrorParameterIndex > 0)
+    completionHandlerErrorParamIndex = rawErrorParameterIndex - 1;
+
+  return ForeignAsyncConvention(
+      canCompletionHandlerType, completionHandlerParameterIndex,
+      completionHandlerErrorParamIndex);
+}

lib/Serialization/ModuleFile.h

@@ -805,9 +805,12 @@ class ModuleFile
   llvm::Expected<NormalProtocolConformance *>
   readNormalConformanceChecked(serialization::NormalConformanceID id);
 
-  /// Reads a foreign error conformance from \c DeclTypeCursor, if present.
+  /// Reads a foreign error convention from \c DeclTypeCursor, if present.
   Optional<ForeignErrorConvention> maybeReadForeignErrorConvention();
 
+  /// Reads a foreign async convention from \c DeclTypeCursor, if present.
+  Optional<ForeignAsyncConvention> maybeReadForeignAsyncConvention();
+
   /// Reads inlinable body text from \c DeclTypeCursor, if present.
   Optional<StringRef> maybeReadInlinableBodyText();
 

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 = 592; // @concurrent SIL function type
+const uint16_t SWIFTMODULE_VERSION_MINOR = 593; // foreign async convention
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1767,6 +1767,13 @@ namespace decls_block {
     TypeIDField                       // result type
   >;
 
+  using ForeignAsyncConventionLayout = BCRecordLayout<
+    FOREIGN_ASYNC_CONVENTION,
+    TypeIDField, // completion handler type
+    BCVBR<4>,    // completion handler parameter index
+    BCVBR<4>     // completion handler error parameter index (+1)
+  >;
+
   using AbstractClosureExprLayout = BCRecordLayout<
     ABSTRACT_CLOSURE_EXPR_CONTEXT,
     TypeIDField, // type

lib/Serialization/Serialization.cpp

@@ -19,6 +19,7 @@
 #include "swift/AST/DiagnosticsCommon.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/FileSystem.h"
+#include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/IndexSubset.h"
@@ -2693,6 +2694,18 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
                                              resultTypeID);
   }
 
+  void writeForeignAsyncConvention(const ForeignAsyncConvention &fac) {
+    using namespace decls_block;
+    TypeID completionHandlerTypeID = S.addTypeRef(fac.completionHandlerType());
+    unsigned rawErrorParameterIndex = fac.completionHandlerErrorParamIndex()
+      .map([](unsigned index) { return index + 1; }).getValueOr(0);
+    auto abbrCode = S.DeclTypeAbbrCodes[ForeignAsyncConventionLayout::Code];
+    ForeignAsyncConventionLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
+                                             completionHandlerTypeID,
+                                             fac.completionHandlerParamIndex(),
+                                             rawErrorParameterIndex);
+  }
+
   void writeGenericParams(const GenericParamList *genericParams) {
     using namespace decls_block;
 
@@ -3590,6 +3603,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
 
     if (auto errorConvention = fn->getForeignErrorConvention())
       writeForeignErrorConvention(*errorConvention);
+    if (auto asyncConvention = fn->getForeignAsyncConvention())
+      writeForeignAsyncConvention(*asyncConvention);
 
     writeInlinableBodyTextIfNeeded(fn);
   }
@@ -3671,6 +3686,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
 
     if (auto errorConvention = fn->getForeignErrorConvention())
       writeForeignErrorConvention(*errorConvention);
+    if (auto asyncConvention = fn->getForeignAsyncConvention())
+      writeForeignAsyncConvention(*asyncConvention);
 
     writeInlinableBodyTextIfNeeded(fn);
   }
@@ -3825,6 +3842,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
 
     if (auto errorConvention = ctor->getForeignErrorConvention())
       writeForeignErrorConvention(*errorConvention);
+    if (auto asyncConvention = ctor->getForeignAsyncConvention())
+      writeForeignAsyncConvention(*asyncConvention);
 
     writeInlinableBodyTextIfNeeded(ctor);
   }
@@ -4669,6 +4688,7 @@ void Serializer::writeAllDeclsAndTypes() {
   registerDeclTypeAbbr<SubstitutionMapLayout>();
 
   registerDeclTypeAbbr<ForeignErrorConventionLayout>();
+  registerDeclTypeAbbr<ForeignAsyncConventionLayout>();
   registerDeclTypeAbbr<AbstractClosureExprLayout>();
   registerDeclTypeAbbr<PatternBindingInitializerLayout>();
   registerDeclTypeAbbr<DefaultArgumentInitializerLayout>();

test/Serialization/Inputs/def_objc_async.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+open class Base: NSObject { }
+
+extension Base {
+	@objc open func foo(id: Int) async { }
+}

test/Serialization/objc_async.swift

@@ -0,0 +1,18 @@
+// RUN: %empty-directory(%t)
+// RUN: %empty-directory(%t-scratch)
+// RUN: %target-swift-frontend -emit-module -o %t-scratch/def_objc_async~partial.swiftmodule -primary-file %S/Inputs/def_objc_async.swift -module-name def_objc_async -enable-experimental-concurrency
+// RUN: %target-swift-frontend -merge-modules -emit-module -parse-as-library -enable-testing %t-scratch/def_objc_async~partial.swiftmodule -module-name def_objc_async -o %t/def_objc_async.swiftmodule -enable-experimental-concurrency
+// RUN: %target-swift-frontend -typecheck -I%t -verify %s -enable-experimental-concurrency
+
+// REQUIRES: concurrency
+// REQUIRES: objc_interop
+
+import def_objc_async
+import Foundation
+
+class Derived: Base {
+}
+
+extension Derived {
+	override func foo(id: Int) async { }
+}