[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";

lib/SIL/IR/SILInstructions.cpp

@@ -2821,6 +2821,42 @@ bool ConvertFunctionInst::onlyConvertsSendable() const {
          getNonSendableFuncType(getType());
 }
 
+static CanSILFunctionType getDerivedFunctionTypeForHopToMainActorIfNeeded(
+    SILFunction *fn, CanSILFunctionType inputFunctionType,
+    SubstitutionMap subMap) {
+  inputFunctionType = inputFunctionType->substGenericArgs(
+      fn->getModule(), subMap, fn->getTypeExpansionContext());
+  bool needsSubstFunctionType = false;
+  for (auto param : inputFunctionType->getParameters()) {
+    needsSubstFunctionType |= param.getInterfaceType()->hasTypeParameter();
+  }
+  for (auto result : inputFunctionType->getResults()) {
+    needsSubstFunctionType |= result.getInterfaceType()->hasTypeParameter();
+  }
+  for (auto yield : inputFunctionType->getYields()) {
+    needsSubstFunctionType |= yield.getInterfaceType()->hasTypeParameter();
+  }
+
+  SubstitutionMap appliedSubs;
+  if (needsSubstFunctionType) {
+    appliedSubs = inputFunctionType->getCombinedSubstitutions();
+  }
+
+  auto extInfoBuilder =
+      inputFunctionType->getExtInfo()
+          .intoBuilder()
+          .withRepresentation(SILFunctionType::Representation::Thick)
+          .withIsPseudogeneric(false);
+
+  return SILFunctionType::get(
+      nullptr, extInfoBuilder.build(), inputFunctionType->getCoroutineKind(),
+      ParameterConvention::Direct_Guaranteed,
+      inputFunctionType->getParameters(), inputFunctionType->getYields(),
+      inputFunctionType->getResults(),
+      inputFunctionType->getOptionalErrorResult(), appliedSubs,
+      SubstitutionMap(), inputFunctionType->getASTContext());
+}
+
 static CanSILFunctionType
 getDerivedFunctionTypeForIdentityThunk(SILFunction *fn,
                                        CanSILFunctionType inputFunctionType,
@@ -2873,6 +2909,9 @@ ThunkInst::Kind::getDerivedFunctionType(SILFunction *fn,
   case Identity:
     return getDerivedFunctionTypeForIdentityThunk(fn, inputFunctionType,
                                                   subMap);
+  case HopToMainActorIfNeeded:
+    return getDerivedFunctionTypeForHopToMainActorIfNeeded(
+        fn, inputFunctionType, subMap);
   }
 
   llvm_unreachable("Covered switch isn't covered?!");

lib/SIL/IR/SILPrinter.cpp

@@ -2058,6 +2058,9 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
     case ThunkInst::Kind::Identity:
       *this << "[identity] ";
       break;
+    case ThunkInst::Kind::HopToMainActorIfNeeded:
+      *this << "[hop_to_mainactor_if_needed] ";
+      break;
     }
     *this << Ctx.getID(ti->getOperand());
     printSubstitutions(

lib/SIL/Parser/ParseSIL.cpp

@@ -4046,6 +4046,8 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
 
     auto kind = llvm::StringSwitch<ThunkInst::Kind>(attrName)
                     .Case("identity", ThunkInst::Kind::Identity)
+                    .Case("hop_to_mainactor_if_needed",
+                          ThunkInst::Kind::HopToMainActorIfNeeded)
                     .Default(ThunkInst::Kind::Invalid);
     if (!kind) {
       P.diagnose(OpcodeLoc, diag::sil_thunkinst_failed_to_parse_kind, attrName);

lib/SIL/Verifier/SILVerifier.cpp

@@ -5225,6 +5225,27 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     require(resTI == ti->getThunkKind().getDerivedFunctionType(
                          ti->getFunction(), objTI, ti->getSubstitutionMap()),
             "resTI is not the thunk kind assigned derived function type");
+
+    auto originalCalleeFuncType =
+        ti->getOperand()->getType().castTo<SILFunctionType>();
+
+    switch (ti->getThunkKind()) {
+    case ThunkInst::Kind::Invalid:
+      break;
+    case ThunkInst::Kind::Identity:
+      break;
+    case ThunkInst::Kind::HopToMainActorIfNeeded:
+      require(originalCalleeFuncType->getParameters().empty(),
+              "Hop To Main Actor If Needed cannot have any parameters");
+      require(originalCalleeFuncType->getResults().empty(),
+              "Hop To Main Actor If Needed cannot have any results");
+      // We require that hop_to_main_actor inputs do not an error since we
+      // have to have no results.
+      require(!originalCalleeFuncType->hasErrorResult(),
+              "HopToMainActorIfNeeded thunks cannot have input without an "
+              "error result");
+      break;
+    }
   }
 
   void checkConvertEscapeToNoEscapeInst(ConvertEscapeToNoEscapeInst *ICI) {

lib/SILGen/ManagedValue.h

@@ -324,6 +324,10 @@ class ManagedValue {
     assert(!hasCleanup());
     return getValue();
   }
+
+  /// Treat getValue() as used so that we can access the value directly when
+  /// debugging without needing to interpret the flag field.
+  LLVM_ATTRIBUTE_USED
   SILValue getValue() const { return valueAndFlag.getPointer(); }
 
   SILType getType() const { return getValue()->getType(); }

lib/SILGen/SILGenBuilder.cpp

@@ -1204,3 +1204,17 @@ ManagedValue SILGenBuilder::borrowObjectRValue(SILGenFunction &SGF,
   }
   return SGF.emitFormalEvaluationManagedBeginBorrow(loc, value);
 }
+
+ManagedValue SILGenBuilder::createHopToMainActorIfNeededThunk(
+    SILLocation loc, ManagedValue op, SubstitutionMap substitutionMap) {
+  if (op.getOwnershipKind() == OwnershipKind::None) {
+    auto *thunkedFunc = createHopToMainActorIfNeededThunk(
+        loc, op.forward(getSILGenFunction()), substitutionMap);
+    return SGF.emitManagedRValueWithCleanup(thunkedFunc);
+  }
+
+  CleanupCloner cloner(*this, op);
+  auto *thunkedFunc = createHopToMainActorIfNeededThunk(
+      loc, op.forward(getSILGenFunction()), substitutionMap);
+  return cloner.clone(thunkedFunc);
+}

lib/SILGen/SILGenBuilder.h

@@ -535,6 +535,11 @@ class SILGenBuilder : public SILBuilder {
 
     createTupleAddrConstructor(loc, destAddr, values, isInitOfDest);
   }
+
+  using SILBuilder::createHopToMainActorIfNeededThunk;
+  ManagedValue
+  createHopToMainActorIfNeededThunk(SILLocation loc, ManagedValue op,
+                                    SubstitutionMap substitutionMap = {});
 };
 
 } // namespace Lowering

lib/SILGen/SILGenFunction.cpp

@@ -1079,6 +1079,49 @@ SILGenFunction::emitClosureValue(SILLocation loc, SILDeclRef constant,
     }
   }
 
+  // If GenerateForceToMainActorThunks and Dynamic Actor Isolation Checking is
+  // enabled and we have a synchronous function...
+  if (F.getASTContext().LangOpts.hasFeature(
+          Feature::GenerateForceToMainActorThunks) &&
+      F.getASTContext().LangOpts.isDynamicActorIsolationCheckingEnabled() &&
+      !functionTy.castTo<SILFunctionType>()->isAsync()) {
+
+    // See if that function is a closure which requires dynamic isolation
+    // checking that doesn't take any parameters or results. In such a case, we
+    // create a hop to main actor if needed thunk.
+    if (auto *closureExpr = constant.getClosureExpr()) {
+      if (closureExpr->requiresDynamicIsolationChecking()) {
+        auto actorIsolation = closureExpr->getActorIsolation();
+        switch (actorIsolation) {
+        case ActorIsolation::Unspecified:
+        case ActorIsolation::Nonisolated:
+        case ActorIsolation::NonisolatedUnsafe:
+        case ActorIsolation::ActorInstance:
+          break;
+
+        case ActorIsolation::Erased:
+          llvm_unreachable("closure cannot have erased isolation");
+
+        case ActorIsolation::GlobalActor:
+          // For now only do this if we are using the main actor and are calling
+          // a function that doesn't depend on its result and doesn't have any
+          // parameters.
+          //
+          // NOTE: Since errors are results, this means that we cannot do this
+          // for throwing functions.
+          if (auto *args = closureExpr->getArgs();
+              (!args || args->empty()) && actorIsolation.isMainActor() &&
+              closureExpr->getResultType()->getCanonicalType() ==
+                  B.getASTContext().TheEmptyTupleType &&
+              !result.getType().castTo<SILFunctionType>()->hasErrorResult()) {
+            result = B.createHopToMainActorIfNeededThunk(loc, result, subs);
+          }
+          break;
+        }
+      }
+    }
+  }
+
   return result;
 }