Merge pull request #79504 from xedin/execution-caller-mangling

[Mangling] Mangle presence of `@execution(caller)` in a function type

Author: xedin

docs/ABI/Mangling.rst

@@ -756,6 +756,9 @@ Types
     function-isolation ::= type 'YA'         // @isolated(any) on function type
     sending-result ::= 'YT'                  // -> sending T
   #endif
+  #if SWIFT_RUNTIME_VERSION >= 6.2
+    function-isolation :== 'YC'              // @execution(caller) on function type
+  #endif
   differentiable ::= 'Yjf'                   // @differentiable(_forward) on function type
   differentiable ::= 'Yjr'                   // @differentiable(reverse) on function type
   differentiable ::= 'Yjd'                   // @differentiable on function type

include/swift/ABI/MetadataValues.h

@@ -1222,6 +1222,7 @@ class TargetExtendedFunctionTypeFlags {
 
     // Values for the enumerated isolation kinds
     IsolatedAny            = 0x00000002U,
+    NonIsolatedCaller      = 0x00000004U,
 
     // Values if we have a sending result.
     HasSendingResult  = 0x00000010U,
@@ -1253,6 +1254,12 @@ class TargetExtendedFunctionTypeFlags {
               (Data & ~IsolationMask) | IsolatedAny);
   }
 
+  const TargetExtendedFunctionTypeFlags<int_type>
+  withNonIsolatedCaller() const {
+    return TargetExtendedFunctionTypeFlags<int_type>((Data & ~IsolationMask) |
+                                                     NonIsolatedCaller);
+  }
+
   const TargetExtendedFunctionTypeFlags<int_type>
   withSendingResult(bool newValue = true) const {
     return TargetExtendedFunctionTypeFlags<int_type>(
@@ -1273,6 +1280,10 @@ class TargetExtendedFunctionTypeFlags {
     return (Data & IsolationMask) == IsolatedAny;
   }
 
+  bool isNonIsolatedCaller() const {
+    return (Data & IsolationMask) == NonIsolatedCaller;
+  }
+
   bool hasSendingResult() const {
     return bool(Data & HasSendingResult);
   }

include/swift/AST/ExtInfo.h

@@ -123,6 +123,9 @@ class FunctionTypeIsolation {
   bool isErased() const {
     return getKind() == Kind::Erased;
   }
+  bool isNonIsolatedCaller() const {
+    return getKind() == Kind::NonIsolatedCaller;
+  }
 
   // The opaque accessors below are just for the benefit of ExtInfoBuilder,
   // which finds it convenient to break down the type separately.  Normal

include/swift/Demangling/DemangleNodes.def

@@ -157,6 +157,7 @@ NODE(Isolated)
 CONTEXT_NODE(IsolatedDeallocator)
 NODE(Sending)
 NODE(IsolatedAnyFunctionType)
+NODE(NonIsolatedCallerFunctionType)
 NODE(SendingResultFunctionType)
 NODE(KeyPathGetterThunkHelper)
 NODE(KeyPathSetterThunkHelper)

include/swift/Demangling/TypeDecoder.h

@@ -941,6 +941,10 @@ class TypeDecoder {
                  NodeKind::IsolatedAnyFunctionType) {
         extFlags = extFlags.withIsolatedAny();
         ++firstChildIdx;
+      } else if (Node->getChild(firstChildIdx)->getKind() ==
+                 NodeKind::NonIsolatedCallerFunctionType) {
+        extFlags = extFlags.withNonIsolatedCaller();
+        ++firstChildIdx;
       }
 
       FunctionMetadataDifferentiabilityKind diffKind;

lib/AST/ASTDemangler.cpp

@@ -460,6 +460,8 @@ Type ASTBuilder::createFunctionType(
     isolation = FunctionTypeIsolation::forGlobalActor(globalActor);
   } else if (extFlags.isIsolatedAny()) {
     isolation = FunctionTypeIsolation::forErased();
+  } else if (extFlags.isNonIsolatedCaller()) {
+    isolation = FunctionTypeIsolation::forNonIsolatedCaller();
   }
 
   auto noescape =

lib/AST/ASTMangler.cpp

@@ -3287,8 +3287,7 @@ void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
     break;
 
   case FunctionTypeIsolation::Kind::NonIsolatedCaller:
-    // TODO: We need a special mangling for this to
-    // make it distinct from the `@execution(concurrent)`.
+    appendOperator("YC");
     break;
   }
 

lib/Demangling/Demangler.cpp

@@ -988,6 +988,8 @@ NodePointer Demangler::demangleTypeAnnotation() {
   case 'c':
     return createWithChild(
         Node::Kind::GlobalActorFunctionType, popTypeAndGetChild());
+  case 'C':
+    return createNode(Node::Kind::NonIsolatedCallerFunctionType);
   case 'i':
     return createType(
         createWithChild(Node::Kind::Isolated, popTypeAndGetChild()));
@@ -1654,7 +1656,8 @@ NodePointer Demangler::popFunctionType(Node::Kind kind, bool hasClangType) {
   // function-isolation?
   auto isFunctionIsolation = [](Node::Kind kind) {
     return kind == Node::Kind::GlobalActorFunctionType ||
-           kind == Node::Kind::IsolatedAnyFunctionType;
+           kind == Node::Kind::IsolatedAnyFunctionType ||
+           kind == Node::Kind::NonIsolatedCallerFunctionType;
   };
   addChild(FuncType, popNode(isFunctionIsolation));
 
@@ -1717,6 +1720,9 @@ NodePointer Demangler::popFunctionParamLabels(NodePointer Type) {
   if (FuncType->getChild(FirstChildIdx)->getKind()
         == Node::Kind::IsolatedAnyFunctionType)
     ++FirstChildIdx;
+  if (FuncType->getChild(FirstChildIdx)->getKind()
+        == Node::Kind::NonIsolatedCallerFunctionType)
+    ++FirstChildIdx;
   if (FuncType->getChild(FirstChildIdx)->getKind()
         == Node::Kind::DifferentiableFunctionType)
     ++FirstChildIdx;

lib/Demangling/NodePrinter.cpp

@@ -572,6 +572,7 @@ class NodePrinter {
     case Node::Kind::DifferentiableFunctionType:
     case Node::Kind::GlobalActorFunctionType:
     case Node::Kind::IsolatedAnyFunctionType:
+    case Node::Kind::NonIsolatedCallerFunctionType:
     case Node::Kind::SendingResultFunctionType:
     case Node::Kind::AsyncAnnotation:
     case Node::Kind::ThrowsAnnotation:
@@ -915,6 +916,14 @@ class NodePrinter {
       print(node->getChild(startIndex), depth + 1);
       ++startIndex;
     }
+
+    Node *nonIsolatedCallerNode = nullptr;
+    if (node->getChild(startIndex)->getKind() ==
+          Node::Kind::NonIsolatedCallerFunctionType) {
+      nonIsolatedCallerNode = node->getChild(startIndex);
+      ++startIndex;
+    }
+
     if (node->getChild(startIndex)->getKind() ==
           Node::Kind::GlobalActorFunctionType) {
       print(node->getChild(startIndex), depth + 1);
@@ -963,6 +972,9 @@ class NodePrinter {
       break;
     }
 
+    if (nonIsolatedCallerNode)
+      print(nonIsolatedCallerNode, depth + 1);
+
     if (isSendable)
       Printer << "@Sendable ";
 
@@ -3108,6 +3120,9 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
   case Node::Kind::IsolatedAnyFunctionType:
     Printer << "@isolated(any) ";
     return nullptr;
+  case Node::Kind::NonIsolatedCallerFunctionType:
+    Printer << "@execution(caller) ";
+    return nullptr;
   case Node::Kind::SendingResultFunctionType:
     Printer << "sending ";
     return nullptr;

lib/Demangling/OldRemangler.cpp

@@ -858,6 +858,12 @@ ManglingError Remangler::mangleIsolatedAnyFunctionType(Node *node,
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleNonIsolatedCallerFunctionType(Node *node,
+                                                             unsigned depth) {
+  Buffer << "YC";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleSendingResultFunctionType(Node *node,
                                                          unsigned depth) {
   Buffer << "YT";