[concurrency] Add support for HopToMainActorIfNeededThunk.

It is behind the experimental flag GenerateForceToMainActorThunks.

Author: gottesmm

include/swift/AST/SILThunkKind.h

@@ -34,7 +34,12 @@ struct SILThunkKind {
     /// purposes of the underlying thunking machinery.
     Identity = 1,
 
-    MaxValue = Identity,
+    /// A thunk that checks if a value is on the main actor and if it isn't
+    /// jumps to the main actor. It expects that the passed in function does not
+    /// have any arguments, results, is synchronous, and does not throw.
+    HopToMainActorIfNeeded = 2,
+
+    MaxValue = HopToMainActorIfNeeded,
   };
 
   InnerTy innerTy;
@@ -68,6 +73,8 @@ struct SILThunkKind {
       return Demangle::MangledSILThunkKind::Invalid;
     case Identity:
       return Demangle::MangledSILThunkKind::Identity;
+    case HopToMainActorIfNeeded:
+      return Demangle::MangledSILThunkKind::HopToMainActorIfNeeded;
     }
   }
 };

include/swift/Basic/Features.def

@@ -433,6 +433,9 @@ EXPERIMENTAL_FEATURE(CoroutineAccessorsUnwindOnCallerError, false)
 /// modify/read coroutines use the callee-allocated ABI
 EXPERIMENTAL_FEATURE(CoroutineAccessorsAllocateInCallee, false)
 
+// When a parameter has unspecified isolation, infer it as main actor isolated.
+EXPERIMENTAL_FEATURE(GenerateForceToMainActorThunks, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/Demangling/Demangle.h

@@ -139,6 +139,7 @@ enum class MangledDifferentiabilityKind : char {
 enum class MangledSILThunkKind : char {
   Invalid = 0,
   Identity = 'I',
+  HopToMainActorIfNeeded = 'H',
 };
 
 /// The pass that caused the specialization to occur. We use this to make sure

include/swift/Demangling/DemangleNodes.def

@@ -292,6 +292,7 @@ NODE(ReflectionMetadataSuperclassDescriptor)
 NODE(GenericTypeParamDecl)
 NODE(CurryThunk)
 NODE(SILThunkIdentity)
+NODE(SILThunkHopToMainActorIfNeeded)
 NODE(DispatchThunk)
 NODE(MethodDescriptor)
 NODE(ProtocolRequirementsBaseDescriptor)

include/swift/SIL/SILBuilder.h

@@ -1251,6 +1251,13 @@ class SILBuilder {
     return createThunk(Loc, Op, ThunkInst::Kind::Identity, substitutionMap);
   }
 
+  ThunkInst *
+  createHopToMainActorIfNeededThunk(SILLocation Loc, SILValue Op,
+                                    SubstitutionMap substitutionMap = {}) {
+    return createThunk(Loc, Op, ThunkInst::Kind::HopToMainActorIfNeeded,
+                       substitutionMap);
+  }
+
   ConvertEscapeToNoEscapeInst *
   createConvertEscapeToNoEscape(SILLocation Loc, SILValue Op, SILType Ty,
                                 bool lifetimeGuaranteed) {

lib/AST/FeatureSet.cpp

@@ -199,6 +199,7 @@ UNINTERESTING_FEATURE(SameElementRequirements)
 UNINTERESTING_FEATURE(UnspecifiedMeansMainActorIsolated)
 UNINTERESTING_FEATURE(GlobalActorInferenceCutoff)
 UNINTERESTING_FEATURE(KeyPathWithStaticMembers)
+UNINTERESTING_FEATURE(GenerateForceToMainActorThunks)
 
 static bool usesFeatureSendingArgsAndResults(Decl *decl) {
   auto isFunctionTypeWithSending = [](Type type) {

lib/Demangling/Demangler.cpp

@@ -2796,6 +2796,9 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
       switch (char c = nextChar()) {
       case 'I':
         return createWithChild(Node::Kind::SILThunkIdentity, popNode(isEntity));
+      case 'H':
+        return createWithChild(Node::Kind::SILThunkHopToMainActorIfNeeded,
+                               popNode(isEntity));
       default:
         return nullptr;
       }

lib/Demangling/NodePrinter.cpp

@@ -368,6 +368,7 @@ class NodePrinter {
     case Node::Kind::CoroutineContinuationPrototype:
     case Node::Kind::CurryThunk:
     case Node::Kind::SILThunkIdentity:
+    case Node::Kind::SILThunkHopToMainActorIfNeeded:
     case Node::Kind::DispatchThunk:
     case Node::Kind::Deallocator:
     case Node::Kind::IsolatedDeallocator:
@@ -1430,6 +1431,10 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     Printer << "identity thunk of ";
     print(Node->getChild(0), depth + 1);
     return nullptr;
+  case Node::Kind::SILThunkHopToMainActorIfNeeded:
+    Printer << "hop to main actor thunk of ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
   case Node::Kind::DispatchThunk:
     Printer << "dispatch thunk of ";
     print(Node->getChild(0), depth + 1);

lib/Demangling/OldRemangler.cpp

@@ -2530,6 +2530,12 @@ ManglingError Remangler::mangleSILThunkIdentity(Node *node, unsigned depth) {
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleSILThunkHopToMainActorIfNeeded(Node *node,
+                                                              unsigned depth) {
+  Buffer << "<sil-hop-to-main-actor-if-needed-thunk>";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleDispatchThunk(Node *node, unsigned depth) {
   Buffer << "<dispatch-thunk>";
   return ManglingError::Success;

lib/Demangling/Remangler.cpp

@@ -3382,6 +3382,14 @@ ManglingError Remangler::mangleSILThunkIdentity(Node *node, unsigned depth) {
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleSILThunkHopToMainActorIfNeeded(Node *node,
+                                                              unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1)); // type
+  Buffer << "TT"
+         << "H";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleDispatchThunk(Node *node, unsigned depth) {
   RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Tj";