Merge pull request swiftlang#34093 from DougGregor/concurrency-mangle-sil-async

[Concurrency] (De-)mangling for SIL @async function types.

Author: DougGregor

docs/ABI/Mangling.rst

@@ -600,7 +600,7 @@ mangled in to disambiguate.
   impl-function-type ::= type* 'I' FUNC-ATTRIBUTES '_'
   impl-function-type ::= type* generic-signature 'I' FUNC-ATTRIBUTES '_'
 
-  FUNC-ATTRIBUTES ::= PATTERN-SUBS? INVOCATION-SUBS? PSEUDO-GENERIC? CALLEE-ESCAPE? DIFFERENTIABILITY-KIND? CALLEE-CONVENTION FUNC-REPRESENTATION? COROUTINE-KIND? (PARAM-CONVENTION PARAM-DIFFERENTIABILITY?)* RESULT-CONVENTION* ('Y' PARAM-CONVENTION)* ('z' RESULT-CONVENTION RESULT-DIFFERENTIABILITY?)?
+  FUNC-ATTRIBUTES ::= PATTERN-SUBS? INVOCATION-SUBS? PSEUDO-GENERIC? CALLEE-ESCAPE? DIFFERENTIABILITY-KIND? CALLEE-CONVENTION FUNC-REPRESENTATION? COROUTINE-KIND? ASYNC? (PARAM-CONVENTION PARAM-DIFFERENTIABILITY?)* RESULT-CONVENTION* ('Y' PARAM-CONVENTION)* ('z' RESULT-CONVENTION RESULT-DIFFERENTIABILITY?)?
 
   PATTERN-SUBS ::= 's'                       // has pattern substitutions
   INVOCATION-SUB ::= 'I'                     // has invocation substitutions
@@ -627,6 +627,8 @@ mangled in to disambiguate.
   COROUTINE-KIND ::= 'A'                     // yield-once coroutine
   COROUTINE-KIND ::= 'G'                     // yield-many coroutine
 
+  ASYNC ::= 'H'                              // @async
+
   PARAM-CONVENTION ::= 'i'                   // indirect in
   PARAM-CONVENTION ::= 'c'                   // indirect in constant
   PARAM-CONVENTION ::= 'l'                   // indirect inout

include/swift/Demangling/TypeDecoder.h

@@ -706,6 +706,8 @@ class TypeDecoder {
           } else if (text == "@convention(block)") {
             flags =
               flags.withRepresentation(ImplFunctionRepresentation::Block);
+          } else if (text == "@async") {
+            flags = flags.withAsync();
           }
         } else if (child->getKind() == NodeKind::ImplDifferentiable) {
           flags = flags.withDifferentiabilityKind(

include/swift/Reflection/TypeRefBuilder.h

@@ -443,6 +443,8 @@ class TypeRefBuilder {
       break;
     }
 
+    funcFlags = funcFlags.withAsync(flags.isAsync());
+
     auto result = createTupleType({}, "");
     return FunctionTypeRef::create(*this, {}, result, funcFlags);
   }

lib/AST/ASTMangler.cpp

@@ -1689,6 +1689,11 @@ void ASTMangler::appendImplFunctionType(SILFunctionType *fn) {
     break;
   }
 
+  // Asynchronous functions.
+  if (fn->isAsync()) {
+    OpArgs.push_back('H');
+  }
+
   auto outerGenericSig = CurGenericSignature;
   CurGenericSignature = fn->getSubstGenericSignature();
 

lib/Demangling/Demangler.cpp

@@ -1829,6 +1829,11 @@ NodePointer Demangler::demangleImplFunctionType() {
   if (CoroAttr)
     type->addChild(createNode(Node::Kind::ImplFunctionAttribute, CoroAttr), *this);
 
+  if (nextIf('H')) {
+    type->addChild(createNode(Node::Kind::ImplFunctionAttribute, "@async"),
+                   *this);
+  }
+
   addChild(type, GenSig);
 
   int NumTypesToAdd = 0;

lib/Demangling/OldDemangler.cpp

@@ -2148,6 +2148,9 @@ class OldDemangler {
         return nullptr;
     }
 
+    if (Mangled.nextIf('H'))
+      addImplFunctionAttribute(type, "@async");
+
     // Enter a new generic context if this type is generic.
     // FIXME: replace with std::optional, when we have it.
     bool isPseudogeneric = false;

lib/Demangling/OldRemangler.cpp

@@ -1255,6 +1255,8 @@ void Remangler::mangleImplFunctionAttribute(Node *node) {
     Buffer << "A";
   } else if (text == "@yield_many") {
     Buffer << "G";
+  } else if (text == "@async") {
+    Buffer << "H";
   } else {
     unreachable("bad impl-function-attribute");
   }

lib/Demangling/Remangler.cpp

@@ -1537,6 +1537,7 @@ void Remangler::mangleImplFunctionType(Node *node) {
                         .Case("@convention(witness_method)", 'W')
                         .Case("@yield_once", 'A')
                         .Case("@yield_many", 'G')
+                        .Case("@async", 'H')
                         .Default(0);
         assert(FuncAttr && "invalid impl function attribute");
         Buffer << FuncAttr;

test/TypeDecoder/concurrency.swift

@@ -0,0 +1,28 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-build-swift -emit-executable %s -g -o %t/concurrency -emit-module -Xfrontend -enable-experimental-concurrency
+
+// RUN: sed -ne '/\/\/ *DEMANGLE-TYPE: /s/\/\/ *DEMANGLE-TYPE: *//p' < %s > %t/input
+// RUN: %lldb-moduleimport-test-with-sdk %t/concurrency -type-from-mangled=%t/input | %FileCheck %s --check-prefix=CHECK-TYPE
+
+func blackHole(_: Any...) {}
+
+public var lookAtMeeee: [(Int) async -> Void] = []
+
+func foo() {
+  do {
+    let x1 = [(Int) async -> Void]()
+    let x2 = [(Int) async throws -> Void]()
+
+    blackHole(x1, x2)
+  }
+}
+
+// DEMANGLE-TYPE: $sSayySiYcG
+// CHECK-TYPE: Array<(Int) async -> ()>
+
+// DEMANGLE-TYPE: $sSayySiYKcG
+// CHECK-TYPE: Array<(Int) async throws -> ()>
+
+// DEMANGLE-TYPE: $sIegH_D
+// CHECK-TYPE: @async @callee_guaranteed () -> ()