Merge pull request #37584 from jckarter/actor-to-async-closure-conversion

Allow conversions from actor-bound sync function type to unbound async function type.

Author: jckarter

docs/ABI/Mangling.rst

@@ -251,6 +251,8 @@ types where the metadata itself has unknown layout.)
   REABSTRACT-THUNK-TYPE ::= 'R'          // reabstraction thunk
   REABSTRACT-THUNK-TYPE ::= 'r'          // reabstraction thunk (obsolete)
 
+  global ::= reabstraction-thunk type 'TU' // reabstraction thunk with global actor constraint
+
 The `from-type` and `to-type` in a reabstraction thunk helper function
 are always non-polymorphic ``<impl-function-type>`` types.
 

include/swift/AST/ASTMangler.h

@@ -163,6 +163,7 @@ class ASTMangler : public Mangler {
   std::string mangleReabstractionThunkHelper(CanSILFunctionType ThunkType,
                                              Type FromType, Type ToType,
                                              Type SelfType,
+                                             Type GlobalActorBound,
                                              ModuleDecl *Module);
 
   /// Mangle a completion handler block implementation function, used for importing ObjC

include/swift/Demangling/DemangleNodes.def

@@ -194,6 +194,7 @@ NODE(ProtocolWitnessTablePattern)
 NODE(ReabstractionThunk)
 NODE(ReabstractionThunkHelper)
 NODE(ReabstractionThunkHelperWithSelf)
+NODE(ReabstractionThunkHelperWithGlobalActor)
 CONTEXT_NODE(ReadAccessor)
 NODE(RelatedEntityDeclName)
 NODE(RetroactiveConformance)

include/swift/SIL/FormalLinkage.h

@@ -43,6 +43,7 @@ enum class FormalLinkage {
 };
 
 FormalLinkage getDeclLinkage(const ValueDecl *decl);
+FormalLinkage getTypeLinkage(CanType formalType);
 SILLinkage getSILLinkage(FormalLinkage linkage,
                          ForDefinition_t forDefinition);
 SILLinkage

lib/AST/ASTMangler.cpp

@@ -379,6 +379,7 @@ std::string ASTMangler::mangleReabstractionThunkHelper(
                                             Type FromType,
                                             Type ToType,
                                             Type SelfType,
+                                            Type GlobalActorBound,
                                             ModuleDecl *Module) {
   Mod = Module;
   assert(ThunkType->getPatternSubstitutions().empty() && "not implemented");
@@ -399,6 +400,11 @@ std::string ASTMangler::mangleReabstractionThunkHelper(
     appendOperator("Ty");
   else
     appendOperator("TR");
+  
+  if (GlobalActorBound) {
+    appendType(GlobalActorBound);
+    appendOperator("TU");
+  }
 
   return finalize();
 }

lib/Demangling/Demangler.cpp

@@ -2537,6 +2537,20 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
       return createNode(Node::Kind::OutlinedBridgedMethod, Params);
     }
     case 'u': return createNode(Node::Kind::AsyncFunctionPointer);
+    case 'U': {
+      auto globalActor = popNode(Node::Kind::Type);
+      if (!globalActor)
+        return nullptr;
+      
+      auto reabstraction = popNode();
+      if (!reabstraction)
+        return nullptr;
+      
+      auto node = createNode(Node::Kind::ReabstractionThunkHelperWithGlobalActor);
+      node->addChild(reabstraction, *this);
+      node->addChild(globalActor, *this);
+      return node;
+    }
     case 'J':
       switch (peekChar()) {
       case 'S':

lib/Demangling/NodePrinter.cpp

@@ -471,6 +471,7 @@ class NodePrinter {
     case Node::Kind::ReabstractionThunk:
     case Node::Kind::ReabstractionThunkHelper:
     case Node::Kind::ReabstractionThunkHelperWithSelf:
+    case Node::Kind::ReabstractionThunkHelperWithGlobalActor:
     case Node::Kind::ReadAccessor:
     case Node::Kind::RelatedEntityDeclName:
     case Node::Kind::RetroactiveConformance:
@@ -1745,6 +1746,12 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     print(Node->getChild(idx));
     return nullptr;
   }
+  case Node::Kind::ReabstractionThunkHelperWithGlobalActor: {
+    print(Node->getChild(0));
+    Printer << " with global actor constraint ";
+    print(Node->getChild(1));
+    return nullptr;
+  }
   case Node::Kind::ReabstractionThunkHelperWithSelf: {
     Printer << "reabstraction thunk ";
     unsigned idx = 0;

lib/Demangling/OldRemangler.cpp

@@ -755,6 +755,10 @@ void Remangler::mangleReabstractionThunk(Node *node) {
   Buffer << "<reabstraction-thunk>";
 }
 
+void Remangler::mangleReabstractionThunkHelperWithGlobalActor(Node *node) {
+  Buffer << "<reabstraction-thunk-helper-with-global-actor>";
+}
+
 void Remangler::mangleAutoDiffFunction(Node *node, EntityContext &ctx) {
   Buffer << "<autodiff-function>";
 }

lib/Demangling/Remangler.cpp

@@ -2125,6 +2125,11 @@ void Remangler::mangleReabstractionThunkHelperWithSelf(Node *node) {
   Buffer << "Ty";
 }
 
+void Remangler::mangleReabstractionThunkHelperWithGlobalActor(Node *node) {
+  mangleChildNodes(node);
+  Buffer << "TU";
+}
+
 void Remangler::mangleAutoDiffFunctionOrSimpleThunk(Node *node, StringRef op) {
   auto childIt = node->begin();
   while (childIt != node->end() &&

lib/SIL/IR/SIL.cpp

@@ -141,6 +141,31 @@ bool SILModule::isTypeMetadataAccessible(CanType type) {
   });
 }
 
+/// Return the minimum linkage structurally required to reference the given formal type.
+FormalLinkage swift::getTypeLinkage(CanType t) {
+  assert(t->isLegalFormalType());
+  
+  class Walker : public TypeWalker {
+  public:
+    FormalLinkage Linkage;
+    Walker() : Linkage(FormalLinkage::PublicUnique) {}
+
+    Action walkToTypePre(Type ty) override {
+      // Non-nominal types are always available.
+      auto decl = ty->getNominalOrBoundGenericNominal();
+      if (!decl)
+        return Action::Continue;
+      
+      Linkage = std::min(Linkage, getDeclLinkage(decl));
+      return Action::Continue;
+    }
+  };
+
+  Walker w;
+  t.walk(w);
+  return w.Linkage;
+}
+
 /// Answer whether IRGen's emitTypeMetadataForLayout can fetch metadata for
 /// a type, which is the necessary condition for being able to do value
 /// operations on the type using dynamic metadata.