Revert "[concurrency] Add support for HopToMainActorIfNeededThunk." (#79938)

* Revert "[concurrency] Add support for HopToMainActorIfNeededThunk."

This reverts commit 0e0665b.

* remove some last bits of 0e0665b

Author: ktoso

include/swift/AST/SILThunkKind.h

@@ -34,12 +34,7 @@ struct SILThunkKind {
     /// purposes of the underlying thunking machinery.
     Identity = 1,
 
-    /// 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,
+    MaxValue = Identity,
   };
 
   InnerTy innerTy;
@@ -73,8 +68,6 @@ struct SILThunkKind {
       return Demangle::MangledSILThunkKind::Invalid;
     case Identity:
       return Demangle::MangledSILThunkKind::Identity;
-    case HopToMainActorIfNeeded:
-      return Demangle::MangledSILThunkKind::HopToMainActorIfNeeded;
     }
   }
 };

include/swift/Basic/Features.def

@@ -476,9 +476,6 @@ SUPPRESSIBLE_EXPERIMENTAL_FEATURE(CoroutineAccessors, true)
 /// modify/read single-yield coroutines always execute code post-yield code
 EXPERIMENTAL_FEATURE(CoroutineAccessorsUnwindOnCallerError, false)
 
-/// When a parameter has unspecified isolation, infer it as main actor isolated.
-EXPERIMENTAL_FEATURE(GenerateForceToMainActorThunks, false)
-
 EXPERIMENTAL_FEATURE(AddressableParameters, true)
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(AddressableTypes, true)
 

include/swift/Demangling/Demangle.h

@@ -141,7 +141,6 @@ 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

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

include/swift/SIL/SILBuilder.h

@@ -1239,13 +1239,6 @@ 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,7 +199,6 @@ UNINTERESTING_FEATURE(ExtractConstantsFromMembers)
 UNINTERESTING_FEATURE(GroupActorErrors)
 UNINTERESTING_FEATURE(SameElementRequirements)
 UNINTERESTING_FEATURE(UnspecifiedMeansMainActorIsolated)
-UNINTERESTING_FEATURE(GenerateForceToMainActorThunks)
 
 static bool usesFeatureSendingArgsAndResults(Decl *decl) {
   auto isFunctionTypeWithSending = [](Type type) {

lib/Demangling/Demangler.cpp

@@ -2859,9 +2859,6 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
       switch (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

@@ -369,7 +369,6 @@ 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:
@@ -1454,10 +1453,6 @@ 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

@@ -2545,12 +2545,6 @@ 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

@@ -3403,14 +3403,6 @@ 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

@@ -2818,42 +2818,6 @@ 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,
@@ -2906,9 +2870,6 @@ 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

@@ -2148,9 +2148,6 @@ 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

@@ -4113,8 +4113,6 @@ 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

@@ -5248,27 +5248,6 @@ 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

@@ -332,7 +332,6 @@ 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

lib/SILGen/SILGenBuilder.cpp

@@ -1228,17 +1228,3 @@ 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

@@ -544,11 +544,6 @@ 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

@@ -1111,50 +1111,6 @@ 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::CallerIsolationInheriting:
-        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;
 }