[IRGen] Corrected mangling of AsyncFunctionPointers.

Previously, the suffix "AD" was used to mangle AsyncFunctionPointers.
That was incorrect because it was already used in the mangling scheme.
Here, that error is fixed by using 'u' under the thunk or specialization
operator 'T' to mangle AsyncFunctionPointers.  Additionally, printing
and demangling support is added.

rdar://problem/72336407

Author: nate-chandler

docs/ABI/Mangling.rst

@@ -207,6 +207,7 @@ types where the metadata itself has unknown layout.)
   global ::= global 'TD'                 // dynamic dispatch thunk
   global ::= global 'Td'                 // direct method reference thunk
   global ::= global 'TI'                 // implementation of a dynamic_replaceable function
+  global :== global 'Tu'                 // async function pointer of a function
   global ::= global 'TX'                 // function pointer of a dynamic_replaceable function
   global ::= entity entity 'TV'          // vtable override thunk, derived followed by base
   global ::= type label-list? 'D'        // type mangling for the debugger with label list for function types.

include/swift/Demangling/DemangleNodes.def

@@ -306,5 +306,8 @@ NODE(GlobalVariableOnceToken)
 NODE(GlobalVariableOnceDeclList)
 NODE(CanonicalPrespecializedGenericTypeCachingOnceToken)
 
+// Added in Swift 5.5
+NODE(AsyncFunctionPointer)
+
 #undef CONTEXT_NODE
 #undef NODE

lib/Demangling/Demangler.cpp

@@ -122,6 +122,7 @@ bool swift::Demangle::isFunctionAttr(Node::Kind kind) {
     case Node::Kind::DynamicallyReplaceableFunctionImpl:
     case Node::Kind::DynamicallyReplaceableFunctionKey:
     case Node::Kind::DynamicallyReplaceableFunctionVar:
+    case Node::Kind::AsyncFunctionPointer:
       return true;
     default:
       return false;
@@ -2473,6 +2474,7 @@ NodePointer Demangler::popProtocolConformance() {
         return nullptr;
       return createNode(Node::Kind::OutlinedBridgedMethod, Params);
     }
+    case 'u': return createNode(Node::Kind::AsyncFunctionPointer);
     default:
       return nullptr;
   }

lib/Demangling/NodePrinter.cpp

@@ -564,6 +564,7 @@ class NodePrinter {
     case Node::Kind::GlobalVariableOnceFunction:
     case Node::Kind::GlobalVariableOnceToken:
     case Node::Kind::CanonicalPrespecializedGenericTypeCachingOnceToken:
+    case Node::Kind::AsyncFunctionPointer:
       return false;
     }
     printer_unreachable("bad node kind");
@@ -2552,6 +2553,9 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
                "metadata for ";
     print(Node->getChild(0));
     return nullptr;
+  case Node::Kind::AsyncFunctionPointer:
+    Printer << "async function pointer to ";
+    return nullptr;
   }
   printer_unreachable("bad node kind!");
 }

lib/Demangling/OldRemangler.cpp

@@ -816,6 +816,10 @@ void Remangler::mangleDefaultArgumentInitializer(Node *node,
   mangleNamedEntity(node, 'I', "A", ctx);
 }
 
+void Remangler::mangleAsyncFunctionPointer(Node *node) {
+  Buffer << "Tu";
+}
+
 void Remangler::mangleDeallocator(Node *node, EntityContext &ctx) {
   mangleSimpleEntity(node, 'F', "D", ctx);
 }

lib/Demangling/Remangler.cpp

@@ -835,6 +835,10 @@ void Remangler::mangleDefaultArgumentInitializer(Node *node) {
   mangleChildNode(node, 1);
 }
 
+void Remangler::mangleAsyncFunctionPointer(Node *node) {
+  Buffer << "Tu";
+}
+
 void Remangler::mangleDependentAssociatedTypeRef(Node *node) {
   mangleIdentifier(node->getFirstChild());
   if (node->getNumChildren() > 1)
@@ -1382,6 +1386,7 @@ void Remangler::mangleGlobal(Node *node) {
       case Node::Kind::DynamicallyReplaceableFunctionKey:
       case Node::Kind::DynamicallyReplaceableFunctionImpl:
       case Node::Kind::DynamicallyReplaceableFunctionVar:
+      case Node::Kind::AsyncFunctionPointer:
         mangleInReverseOrder = true;
         break;
       default:

lib/IRGen/Linking.cpp

@@ -432,13 +432,13 @@ std::string LinkEntity::mangleAsString() const {
          getSILDifferentiabilityWitness()->getConfig()});
   case Kind::AsyncFunctionPointer: {
     std::string Result(getSILFunction()->getName());
-    Result.append("AD");
+    Result.append("Tu");
     return Result;
   }
   case Kind::AsyncFunctionPointerAST: {
     std::string Result;
     Result = mangler.mangleEntity(getDecl());
-    Result.append("AD");
+    Result.append("Tu");
     return Result;
   }
   }

test/Demangle/Inputs/manglings.txt

@@ -371,3 +371,4 @@ $s7example1fyyYF -> example.f() async -> ()
 $s7example1fyyYKF -> example.f() async throws -> ()
 $s4main20receiveInstantiationyySo34__CxxTemplateInst12MagicWrapperIiEVzF ---> main.receiveInstantiation(inout __C.__CxxTemplateInst12MagicWrapperIiE) -> ()
 $s4main19returnInstantiationSo34__CxxTemplateInst12MagicWrapperIiEVyF ---> main.returnInstantiation() -> __C.__CxxTemplateInst12MagicWrapperIiE
+$s4main6testityyYFTu ---> async function pointer to main.testit() async -> ()

test/IRGen/async/run-call-classinstance-int64-to-void.sil

@@ -29,7 +29,7 @@ class S {
   init()
 }
 
-// CHECK-LL: @classinstanceSInt64ToVoidAD =
+// CHECK-LL: @classinstanceSInt64ToVoidTu =
 // CHECK-LL: define hidden swiftcc void @classinstanceSInt64ToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]+}} {
 sil hidden @classinstanceSInt64ToVoid : $@async @convention(method) (Int64, @guaranteed S) -> () {
 bb0(%int : $Int64, %instance : $S):

test/IRGen/async/run-call-classinstance-void-to-void.sil

@@ -29,7 +29,7 @@ class S {
   init()
 }
 
-// CHECK-LL: @classinstanceSVoidToVoidAD =
+// CHECK-LL: @classinstanceSVoidToVoidTu =
 // CHECK-LL: define hidden swiftcc void @classinstanceSVoidToVoid(%swift.task* {{%[0-9]+}}, %swift.executor* {{%[0-9]+}}, %swift.context* {{%[0-9]+}}) {{#[0-9]*}} {
 sil hidden @classinstanceSVoidToVoid : $@async @convention(method) (@guaranteed S) -> () {
 bb0(%instance : $S):