Unify mangling operators for async, @Sendable, @differentiable and @noDerivative.

Repurpose mangling operator `Y` as an umbrella operator that covers new attributes on function types. Free up operators `J`, `j`, and `k`.

```
async ::= 'Ya'                             // 'async' annotation on function types
sendable ::= 'Yb'                          // @sendable on function types
throws ::= 'K'                             // 'throws' annotation on function types
differentiable ::= 'Yjf'                   // @differentiable(_forward) on function type
differentiable ::= 'Yjr'                   // @differentiable(reverse) on function type
differentiable ::= 'Yjd'                   // @differentiable on function type
differentiable ::= 'Yjl'                   // @differentiable(_linear) on function type
```

Resolves rdar://76299796.

Author: rxwei

docs/ABI/Mangling.rst

@@ -570,19 +570,19 @@ Types
                                              // they are mangled separately as part of the entity.
   params-type ::= empty-list                 // shortcut for no parameters
 
-  sendable ::= 'J'                           // @Sendable on function types
-  async ::= 'Y'                              // 'async' annotation on function types
+  async ::= 'Ya'                             // 'async' annotation on function types
+  sendable ::= 'Yb'                          // @Sendable on function types
   throws ::= 'K'                             // 'throws' annotation on function types
-  differentiable ::= 'jf'                    // @differentiable(_forward) on function type
-  differentiable ::= 'jr'                    // @differentiable(reverse) on function type
-  differentiable ::= 'jd'                    // @differentiable on function type
-  differentiable ::= 'jl'                    // @differentiable(_linear) on function type
+  differentiable ::= 'Yjf'                   // @differentiable(_forward) on function type
+  differentiable ::= 'Yjr'                   // @differentiable(reverse) on function type
+  differentiable ::= 'Yjd'                   // @differentiable on function type
+  differentiable ::= 'Yjl'                   // @differentiable(_linear) on function type
 
   type-list ::= list-type '_' list-type*     // list of types
   type-list ::= empty-list
 
                                                   // FIXME: Consider replacing 'h' with a two-char code
-  list-type ::= type identifier? 'k'? 'z'? 'h'? 'n'? 'd'?  // type with optional label, '@noDerivative', inout convention, shared convention, owned convention, and variadic specifier
+  list-type ::= type identifier? 'Yk'? 'z'? 'h'? 'n'? 'd'?  // type with optional label, '@noDerivative', inout convention, shared convention, owned convention, and variadic specifier
 
   METATYPE-REPR ::= 't'                      // Thin metatype representation
   METATYPE-REPR ::= 'T'                      // Thick metatype representation

include/swift/Demangling/Demangler.h

@@ -569,6 +569,8 @@ class Demangler : public NodeFactory {
 
   NodePointer demangleTypeMangling();
   NodePointer demangleSymbolicReference(unsigned char rawKind);
+  NodePointer demangleTypeAnnotation();
+
   NodePointer demangleAutoDiffFunctionOrSimpleThunk(Node::Kind nodeKind);
   NodePointer demangleAutoDiffFunctionKind();
   NodePointer demangleAutoDiffSubsetParametersThunk();

include/swift/Demangling/TypeDecoder.h

@@ -738,27 +738,6 @@ class TypeDecoder {
         ++firstChildIdx;
       }
 
-      bool isThrow = false;
-      if (Node->getChild(firstChildIdx)->getKind()
-            == NodeKind::ThrowsAnnotation) {
-        isThrow = true;
-        ++firstChildIdx;
-      }
-
-      bool isSendable = false;
-      if (Node->getChild(firstChildIdx)->getKind()
-            == NodeKind::ConcurrentFunctionType) {
-        isSendable = true;
-        ++firstChildIdx;
-      }
-
-      bool isAsync = false;
-      if (Node->getChild(firstChildIdx)->getKind()
-            == NodeKind::AsyncAnnotation) {
-        isAsync = true;
-        ++firstChildIdx;
-      }
-
       FunctionMetadataDifferentiabilityKind diffKind;
       if (Node->getChild(firstChildIdx)->getKind() ==
             NodeKind::DifferentiableFunctionType) {
@@ -784,6 +763,27 @@ class TypeDecoder {
         ++firstChildIdx;
       }
 
+      bool isThrow = false;
+      if (Node->getChild(firstChildIdx)->getKind()
+            == NodeKind::ThrowsAnnotation) {
+        isThrow = true;
+        ++firstChildIdx;
+      }
+
+      bool isSendable = false;
+      if (Node->getChild(firstChildIdx)->getKind()
+            == NodeKind::ConcurrentFunctionType) {
+        isSendable = true;
+        ++firstChildIdx;
+      }
+
+      bool isAsync = false;
+      if (Node->getChild(firstChildIdx)->getKind()
+            == NodeKind::AsyncAnnotation) {
+        isAsync = true;
+        ++firstChildIdx;
+      }
+
       flags = flags.withConcurrent(isSendable)
           .withAsync(isAsync).withThrows(isThrow)
           .withDifferentiable(diffKind.isDifferentiable());
@@ -1371,25 +1371,25 @@ class TypeDecoder {
             FunctionParam<BuiltType> &param) -> bool {
       Demangle::NodePointer node = typeNode;
 
-      auto setOwnership = [&](ValueOwnership ownership) {
-        param.setValueOwnership(ownership);
-        node = node->getFirstChild();
-        hasParamFlags = true;
-      };
-
       bool recurse = true;
       while (recurse) {
         switch (node->getKind()) {
         case NodeKind::InOut:
-          setOwnership(ValueOwnership::InOut);
+          param.setValueOwnership(ValueOwnership::InOut);
+          node = node->getFirstChild();
+          hasParamFlags = true;
           break;
 
         case NodeKind::Shared:
-          setOwnership(ValueOwnership::Shared);
+          param.setValueOwnership(ValueOwnership::Shared);
+          node = node->getFirstChild();
+          hasParamFlags = true;
           break;
 
         case NodeKind::Owned:
-          setOwnership(ValueOwnership::Owned);
+          param.setValueOwnership(ValueOwnership::Owned);
+          node = node->getFirstChild();
+          hasParamFlags = true;
           break;
 
         case NodeKind::NoDerivative:

lib/AST/ASTMangler.cpp

@@ -2448,25 +2448,25 @@ void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
   appendFunctionResultType(fn->getResult(), forDecl);
   appendFunctionInputType(fn->getParams(), forDecl);
   if (fn->isAsync() || functionMangling == AsyncHandlerBodyMangling)
-    appendOperator("Y");
+    appendOperator("Ya");
   if (fn->isSendable())
-    appendOperator("J");
+    appendOperator("Yb");
   if (fn->isThrowing())
     appendOperator("K");
   switch (auto diffKind = fn->getDifferentiabilityKind()) {
   case DifferentiabilityKind::NonDifferentiable:
     break;
   case DifferentiabilityKind::Forward:
-    appendOperator("jf");
+    appendOperator("Yjf");
     break;
   case DifferentiabilityKind::Reverse:
-    appendOperator("jr");
+    appendOperator("Yjr");
     break;
   case DifferentiabilityKind::Normal:
-    appendOperator("jd");
+    appendOperator("Yjd");
     break;
   case DifferentiabilityKind::Linear:
-    appendOperator("jl");
+    appendOperator("Yjl");
     break;
   }
 }
@@ -2542,7 +2542,7 @@ void ASTMangler::appendTypeListElement(Identifier name, Type elementType,
     appendType(elementType, forDecl);
 
   if (flags.isNoDerivative()) {
-    appendOperator("k");
+    appendOperator("Yk");
   }
   switch (flags.getValueOwnership()) {
   case ValueOwnership::Default:

lib/Demangling/Demangler.cpp

@@ -730,6 +730,22 @@ NodePointer Demangler::demangleSymbolicReference(unsigned char rawKind) {
   return resolved;
 }
 
+NodePointer Demangler::demangleTypeAnnotation() {
+  switch (char c2 = nextChar()) {
+  case 'a':
+    return createNode(Node::Kind::AsyncAnnotation);
+  case 'b':
+    return createNode(Node::Kind::ConcurrentFunctionType);
+  case 'j':
+    return demangleDifferentiableFunctionType();
+  case 'k':
+    return createType(
+        createWithChild(Node::Kind::NoDerivative, popTypeAndGetChild()));
+  default:
+    return nullptr;
+  }
+}
+
 NodePointer Demangler::demangleOperator() {
 recur:
   switch (unsigned char c = nextChar()) {
@@ -767,7 +783,6 @@ NodePointer Demangler::demangleOperator() {
       }
 
     case 'I': return demangleImplFunctionType();
-    case 'J': return createNode(Node::Kind::ConcurrentFunctionType);
     case 'K': return createNode(Node::Kind::ThrowsAnnotation);
     case 'L': return demangleLocalIdentifier();
     case 'M': return demangleMetatype();
@@ -782,7 +797,7 @@ NodePointer Demangler::demangleOperator() {
     case 'V': return demangleAnyGenericType(Node::Kind::Structure);
     case 'W': return demangleWitness();
     case 'X': return demangleSpecialType();
-    case 'Y': return createNode(Node::Kind::AsyncAnnotation);
+    case 'Y': return demangleTypeAnnotation();
     case 'Z': return createWithChild(Node::Kind::Static, popNode(isEntity));
     case 'a': return demangleAnyGenericType(Node::Kind::TypeAlias);
     case 'c': return popFunctionType(Node::Kind::FunctionType);
@@ -792,10 +807,6 @@ NodePointer Demangler::demangleOperator() {
     case 'h': return createType(createWithChild(Node::Kind::Shared,
                                                 popTypeAndGetChild()));
     case 'i': return demangleSubscript();
-    case 'j': return demangleDifferentiableFunctionType();
-    case 'k':
-      return createType(
-          createWithChild(Node::Kind::NoDerivative, popTypeAndGetChild()));
     case 'l': return demangleGenericSignature(/*hasParamCounts*/ false);
     case 'm': return createType(createWithChild(Node::Kind::Metatype,
                                                 popNode(Node::Kind::Type)));
@@ -1257,10 +1268,10 @@ NodePointer Demangler::popFunctionType(Node::Kind kind, bool hasClangType) {
     ClangType = demangleClangType();
   }
   addChild(FuncType, ClangType);
+  addChild(FuncType, popNode(Node::Kind::DifferentiableFunctionType));
   addChild(FuncType, popNode(Node::Kind::ThrowsAnnotation));
   addChild(FuncType, popNode(Node::Kind::ConcurrentFunctionType));
   addChild(FuncType, popNode(Node::Kind::AsyncAnnotation));
-  addChild(FuncType, popNode(Node::Kind::DifferentiableFunctionType));
 
   FuncType = addChild(FuncType, popFunctionParams(Node::Kind::ArgumentTuple));
   FuncType = addChild(FuncType, popFunctionParams(Node::Kind::ReturnType));
@@ -1293,6 +1304,9 @@ NodePointer Demangler::popFunctionParamLabels(NodePointer Type) {
     return nullptr;
 
   unsigned FirstChildIdx = 0;
+  if (FuncType->getChild(FirstChildIdx)->getKind()
+        == Node::Kind::DifferentiableFunctionType)
+    ++FirstChildIdx;
   if (FuncType->getChild(FirstChildIdx)->getKind()
         == Node::Kind::ThrowsAnnotation)
     ++FirstChildIdx;
@@ -1302,9 +1316,6 @@ NodePointer Demangler::popFunctionParamLabels(NodePointer Type) {
   if (FuncType->getChild(FirstChildIdx)->getKind()
         == Node::Kind::AsyncAnnotation)
     ++FirstChildIdx;
-  if (FuncType->getChild(FirstChildIdx)->getKind()
-        == Node::Kind::DifferentiableFunctionType)
-    ++FirstChildIdx;
   auto ParameterType = FuncType->getChild(FirstChildIdx);
 
   assert(ParameterType->getKind() == Node::Kind::ArgumentTuple);

lib/Demangling/NodePrinter.cpp

@@ -809,6 +809,12 @@ class NodePrinter {
     unsigned startIndex = 0;
     bool isSendable = false, isAsync = false, isThrows = false;
     auto diffKind = MangledDifferentiabilityKind::NonDifferentiable;
+    if (node->getChild(startIndex)->getKind() ==
+        Node::Kind::DifferentiableFunctionType) {
+      diffKind =
+          (MangledDifferentiabilityKind)node->getChild(startIndex)->getIndex();
+      ++startIndex;
+    }
     if (node->getChild(startIndex)->getKind() == Node::Kind::ClangType) {
       // handled earlier
       ++startIndex;
@@ -826,12 +832,6 @@ class NodePrinter {
       ++startIndex;
       isAsync = true;
     }
-    if (node->getChild(startIndex)->getKind() ==
-        Node::Kind::DifferentiableFunctionType) {
-      diffKind =
-          (MangledDifferentiabilityKind)node->getChild(startIndex)->getIndex();
-      ++startIndex;
-    }
 
     switch (diffKind) {
     case MangledDifferentiabilityKind::Forward:

lib/Demangling/Remangler.cpp

@@ -1678,7 +1678,7 @@ void Remangler::mangleOwned(Node *node) {
 
 void Remangler::mangleNoDerivative(Node *node) {
   mangleSingleChildNode(node);
-  Buffer << 'k';
+  Buffer << "Yk";
 }
 
 void Remangler::mangleInfixOperator(Node *node) {
@@ -2465,15 +2465,15 @@ void Remangler::mangleFullObjCResilientClassStub(Node *node) {
 }
 
 void Remangler::mangleConcurrentFunctionType(Node *node) {
-  Buffer << 'J';
+  Buffer << "Yb";
 }
 
 void Remangler::mangleAsyncAnnotation(Node *node) {
-  Buffer << 'Y';
+  Buffer << "Ya";
 }
 
 void Remangler::mangleDifferentiableFunctionType(Node *node) {
-  Buffer << 'j' << (char)node->getIndex(); // differentiability kind
+  Buffer << "Yj" << (char)node->getIndex(); // differentiability kind
 }
 
 void Remangler::mangleThrowsAnnotation(Node *node) {

lib/SILGen/SILGenBridging.cpp

@@ -1484,7 +1484,7 @@ SILFunction *SILGenFunction::emitNativeAsyncToForeignThunk(SILDeclRef thunk) {
   assert(thunkSuffix[1] == 'T'
          && thunkSuffix[0] == 'o'
          && "not an objc thunk?");
-  closureName += "yyYcfU_"; // closure with type () async -> ()
+  closureName += "yyYacfU_"; // closure with type () async -> ()
   closureName.push_back(thunkSuffix[1]);
   closureName.push_back(thunkSuffix[0]);
 

stdlib/public/runtime/Demangle.cpp

@@ -564,15 +564,6 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
     result->addChild(resultTy, Dem);
 
     auto funcNode = Dem.createNode(kind);
-    if (func->isThrowing())
-      funcNode->addChild(Dem.createNode(Node::Kind::ThrowsAnnotation), Dem);
-    if (func->isSendable()) {
-      funcNode->addChild(
-          Dem.createNode(Node::Kind::ConcurrentFunctionType), Dem);
-    }
-    if (func->isAsync())
-      funcNode->addChild(Dem.createNode(Node::Kind::AsyncAnnotation), Dem);
-
     switch (func->getDifferentiabilityKind().Value) {
     case FunctionMetadataDifferentiabilityKind::NonDifferentiable:
       break;
@@ -597,6 +588,14 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
           (Node::IndexType)MangledDifferentiabilityKind::Linear), Dem);
       break;
     }
+    if (func->isThrowing())
+      funcNode->addChild(Dem.createNode(Node::Kind::ThrowsAnnotation), Dem);
+    if (func->isSendable()) {
+      funcNode->addChild(
+          Dem.createNode(Node::Kind::ConcurrentFunctionType), Dem);
+    }
+    if (func->isAsync())
+      funcNode->addChild(Dem.createNode(Node::Kind::AsyncAnnotation), Dem);
 
     funcNode->addChild(parameters, Dem);
     funcNode->addChild(result, Dem);

test/AutoDiff/SILGen/mangling.swift

@@ -7,17 +7,17 @@ import _Differentiation
 // CHECK-LABEL: sil hidden [ossa] @$s8mangling15nonescapingFunc2fnyS2fXE_tF : $@convention(thin) (@noescape @callee_guaranteed (Float) -> Float) -> () {
 func nonescapingFunc(fn: (Float) -> Float) {}
 
-// CHECK-LABEL: sil hidden [ossa] @$s8mangling8diffFunc2fnyS2fjrXE_tF : $@convention(thin) (@differentiable(reverse) @noescape @callee_guaranteed (Float) -> Float) -> () {
+// CHECK-LABEL: sil hidden [ossa] @$s8mangling8diffFunc2fnyS2fYjrXE_tF : $@convention(thin) (@differentiable(reverse) @noescape @callee_guaranteed (Float) -> Float) -> () {
 func diffFunc(fn: @differentiable(reverse) (Float) -> Float) {}
 
-// CHECK-LABEL: sil hidden [ossa] @$s8mangling10linearFunc2fnyS2fjlXE_tF : $@convention(thin) (@differentiable(_linear) @noescape @callee_guaranteed (Float) -> Float) -> () {
+// CHECK-LABEL: sil hidden [ossa] @$s8mangling10linearFunc2fnyS2fYjlXE_tF : $@convention(thin) (@differentiable(_linear) @noescape @callee_guaranteed (Float) -> Float) -> () {
 func linearFunc(fn: @differentiable(_linear) (Float) -> Float) {}
 
 // CHECK-LABEL: sil hidden [ossa] @$s8mangling12escapingFunc2fnS2fcS2fc_tF : $@convention(thin) (@guaranteed @callee_guaranteed (Float) -> Float) -> @owned @callee_guaranteed (Float) -> Float {
 func escapingFunc(fn: @escaping (Float) -> Float) -> (Float) -> Float { fn }
 
-// CHECK-LABEL: sil hidden [ossa] @$s8mangling16diffEscapingFunc2fnS2fjrcS2fjrc_tF : $@convention(thin) (@guaranteed @differentiable(reverse) @callee_guaranteed (Float) -> Float) -> @owned @differentiable(reverse) @callee_guaranteed (Float) -> Float {
+// CHECK-LABEL: sil hidden [ossa] @$s8mangling16diffEscapingFunc2fnS2fYjrcS2fYjrc_tF : $@convention(thin) (@guaranteed @differentiable(reverse) @callee_guaranteed (Float) -> Float) -> @owned @differentiable(reverse) @callee_guaranteed (Float) -> Float {
 func diffEscapingFunc(fn: @escaping @differentiable(reverse) (Float) -> Float) -> @differentiable(reverse) (Float) -> Float { fn }
 
-// CHECK-LABEL: sil hidden [ossa] @$s8mangling18linearEscapingFunc2fnS2fjlcS2fjlc_tF : $@convention(thin) (@guaranteed @differentiable(_linear) @callee_guaranteed (Float) -> Float) -> @owned @differentiable(_linear) @callee_guaranteed (Float) -> Float {
+// CHECK-LABEL: sil hidden [ossa] @$s8mangling18linearEscapingFunc2fnS2fYjlcS2fYjlc_tF : $@convention(thin) (@guaranteed @differentiable(_linear) @callee_guaranteed (Float) -> Float) -> @owned @differentiable(_linear) @callee_guaranteed (Float) -> Float {
 func linearEscapingFunc(fn: @escaping @differentiable(_linear) (Float) -> Float) -> @differentiable(_linear) (Float) -> Float { fn }