[concurrency] Fix a few issues with @execution(caller)/@execution(concurrent).

Specifically:

1. I made it so that thunks from caller -> concurrent properly ignore the
isolated parameter of the thunk when calling the concurrent function.

rdar://148112362

2. I made it so that thunks from concurrent -> caller properly create a
Optional<any Actor>.none and pass that into the caller function.

rdar://148112384

3. I made it so that in cases where we are assigning an @sendable caller to a
non-sendable caller variable, we allow for the conversion as long as the
parameters/results are sendable as well.

rdar://148112532

4. I made it so that when we generate a thunk from @execution(caller) ->
@GlobalActor, we mangle in @GlobalActor into the thunk.

rdar://148112569

5. I discovered that due to the way we handle function conversion expr/decl ref
expr, we were emitted two thunks when we assigned a global @caller function to a
local @caller variable. The result is that we would first cast from @caller ->
@Concurrent and then back to @caller. The result of this would be that the
@caller function would always be called on the global queue.

rdar://148112646

I also added a bunch of basic tests as well that showed that this behavior was
broken.

Author: gottesmm

include/swift/AST/Types.h

@@ -3800,6 +3800,12 @@ class AnyFunctionType : public TypeBase {
   /// Return the function type without the throwing.
   AnyFunctionType *getWithoutThrowing() const;
 
+  /// Return the function type with the given \p isolation.
+  AnyFunctionType *getWithIsolation(FunctionTypeIsolation isolation) const;
+
+  /// Return the function type setting sendable to \p newValue.
+  AnyFunctionType *getWithSendable(bool newValue) const;
+
   /// True if the parameter declaration it is attached to is guaranteed
   /// to not persist the closure for longer than the duration of the call.
   bool isNoEscape() const {

lib/AST/Type.cpp

@@ -4486,6 +4486,17 @@ AnyFunctionType *AnyFunctionType::getWithoutThrowing() const {
   return withExtInfo(info);
 }
 
+AnyFunctionType *
+AnyFunctionType::getWithIsolation(FunctionTypeIsolation isolation) const {
+  auto info = getExtInfo().intoBuilder().withIsolation(isolation).build();
+  return withExtInfo(info);
+}
+
+AnyFunctionType *AnyFunctionType::getWithSendable(bool newValue) const {
+  auto info = getExtInfo().intoBuilder().withSendable(newValue).build();
+  return withExtInfo(info);
+}
+
 std::optional<Type> AnyFunctionType::getEffectiveThrownErrorType() const {
   // A non-throwing function... has no thrown interface type.
   if (!isThrowing())

lib/SILGen/SILGenExpr.cpp

@@ -487,6 +487,11 @@ namespace {
     }
     RValue visitFunctionConversionExpr(FunctionConversionExpr *E,
                                        SGFContext C);
+
+    /// Helper method for handling function conversion expr to
+    /// @execution(caller). Returns an empty RValue on failure.
+    RValue emitExecutionCallerFunctionConversionExpr(FunctionConversionExpr *E,
+                                                     SGFContext C);
     RValue visitActorIsolationErasureExpr(ActorIsolationErasureExpr *E,
                                           SGFContext C);
     RValue visitExtractFunctionIsolationExpr(ExtractFunctionIsolationExpr *E,
@@ -1942,9 +1947,58 @@ static ManagedValue convertFunctionRepresentation(SILGenFunction &SGF,
   llvm_unreachable("bad representation");
 }
 
+RValue RValueEmitter::emitExecutionCallerFunctionConversionExpr(
+    FunctionConversionExpr *e, SGFContext C) {
+  CanAnyFunctionType srcType =
+      cast<FunctionType>(e->getSubExpr()->getType()->getCanonicalType());
+  CanAnyFunctionType destType =
+      cast<FunctionType>(e->getType()->getCanonicalType());
+  assert(destType->getIsolation().isNonIsolatedCaller() &&
+         "Should only call this if destType is non isolated caller");
+
+  auto *subExpr = e->getSubExpr();
+
+  // Check if we have a subExpr and if this conversion is just stripping off
+  // @Sendable. In such a case, we can look through.
+  if (auto *fce = dyn_cast<FunctionConversionExpr>(subExpr)) {
+    if (srcType->hasExtInfo() && srcType->getExtInfo().isSendable() &&
+        destType->hasExtInfo() && !destType->getExtInfo().isSendable() &&
+        destType->getWithSendable(true) == srcType) {
+      subExpr = fce->getSubExpr();
+
+      // We changed our subExpr... so recompute our srcType.
+      srcType = cast<FunctionType>(subExpr->getType()->getCanonicalType());
+    }
+  }
+
+  // Check if the only difference in between our destType and srcType is our
+  // isolation.
+  if (!srcType->hasExtInfo() || !destType->hasExtInfo() ||
+      destType->getWithIsolation(srcType->getIsolation()) != srcType) {
+    return RValue();
+  }
+
+  // Ok, we know that our underlying types are the same. Lets try to emit.
+  auto *declRef = dyn_cast<DeclRefExpr>(subExpr);
+  if (!declRef)
+    return RValue();
+
+  auto *decl = dyn_cast<FuncDecl>(declRef->getDecl());
+  if (!decl || !getActorIsolation(decl).isCallerIsolationInheriting())
+    return RValue();
+
+  // Ok, we found our target.
+  SILDeclRef silDeclRef(decl);
+  assert(silDeclRef.getParameterListCount() == 1);
+  auto substType = cast<AnyFunctionType>(destType);
+  auto typeContext = SGF.getFunctionTypeInfo(substType);
+  ManagedValue result = SGF.emitClosureValue(
+      e, silDeclRef, typeContext, declRef->getDeclRef().getSubstitutions());
+  return RValue(SGF, e, destType, result);
+}
+
 RValue RValueEmitter::visitFunctionConversionExpr(FunctionConversionExpr *e,
-                                                  SGFContext C)
-{
+                                                  SGFContext C) {
   CanAnyFunctionType srcType =
       cast<FunctionType>(e->getSubExpr()->getType()->getCanonicalType());
   CanAnyFunctionType destType =
@@ -2041,6 +2095,19 @@ RValue RValueEmitter::visitFunctionConversionExpr(FunctionConversionExpr *e,
     }
   }
 
+  // Check if we are converting a function to an @execution(caller) from a
+  // declref that is also @execution(caller). In such a case, this was a case
+  // that was put in by Sema. We do not need a thunk, but just need to recognize
+  // this case and elide the conversion. The reason why we need to do this is
+  // that otherwise, we put in extra thunks that convert @execution(caller) to
+  // @execution(concurrent) back to @execution(caller). This is done b/c we do
+  // not represent @execution(caller) in interface types, so the actual decl ref
+  // will be viewed as @async () -> ().
+  if (destType->getIsolation().isNonIsolatedCaller()) {
+    if (RValue rv = emitExecutionCallerFunctionConversionExpr(e, C))
+      return rv;
+  }
+
   // Break the conversion into three stages:
   // 1) changing the representation from foreign to native
   // 2) changing the signature within the representation

lib/SILGen/SILGenFunction.h

@@ -2601,11 +2601,19 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                               SILType loweredResultTy,
                               SGFContext ctx = SGFContext());
 
+  enum class ThunkGenFlag {
+    None,
+    ConvertingToNonIsolatedCaller,
+    ConvertingFromNonIsolatedCaller,
+  };
+  using ThunkGenOptions = OptionSet<ThunkGenFlag>;
+
   /// Used for emitting SILArguments of bare functions, such as thunks.
   void collectThunkParams(
       SILLocation loc, SmallVectorImpl<ManagedValue> &params,
       SmallVectorImpl<ManagedValue> *indirectResultParams = nullptr,
-      SmallVectorImpl<ManagedValue> *indirectErrorParams = nullptr);
+      SmallVectorImpl<ManagedValue> *indirectErrorParams = nullptr,
+      ThunkGenOptions options = {});
 
   /// Build the type of a function transformation thunk.
   CanSILFunctionType buildThunkType(CanSILFunctionType &sourceType,

lib/SILGen/SILGenPoly.cpp

@@ -985,7 +985,7 @@ ManagedValue Transform::transformTuple(ManagedValue inputTuple,
 void SILGenFunction::collectThunkParams(
     SILLocation loc, SmallVectorImpl<ManagedValue> &params,
     SmallVectorImpl<ManagedValue> *indirectResults,
-    SmallVectorImpl<ManagedValue> *indirectErrors) {
+    SmallVectorImpl<ManagedValue> *indirectErrors, ThunkGenOptions options) {
   // Add the indirect results.
   for (auto resultTy : F.getConventions().getIndirectSILResultTypes(
            getTypeExpansionContext())) {
@@ -1021,7 +1021,16 @@ void SILGenFunction::collectThunkParams(
     // be lowered to their underlying type if allowed by resilience.
     auto inContextParamTy = F.getLoweredType(paramTy.getASTType())
                                 .getCategoryType(paramTy.getCategory());
-    params.push_back(B.createInputFunctionArgument(inContextParamTy, loc));
+    auto functionArgument =
+        B.createInputFunctionArgument(inContextParamTy, loc);
+
+    // If we are told to not propagate the isolated parameter and this is the
+    // implicit leading/isolated parameter, continue.
+    if (options.contains(ThunkGenFlag::ConvertingToNonIsolatedCaller) &&
+        param.hasOption(SILParameterInfo::ImplicitLeading) &&
+        param.hasOption(SILParameterInfo::Isolated))
+      continue;
+    params.push_back(functionArgument);
   }
 }
 
@@ -1454,15 +1463,18 @@ class TranslateArguments : public ExpanderBase<TranslateArguments, ParamInfo> {
   CanSILFunctionType InnerTypesFuncTy;
   ArrayRef<SILParameterInfo> InnerTypes;
   InnerPackArgGenerator InnerPacks;
+  SILGenFunction::ThunkGenOptions Options;
+
 public:
   TranslateArguments(SILGenFunction &SGF, SILLocation loc,
                      ArrayRef<ManagedValue> outerArgs,
                      SmallVectorImpl<ManagedValue> &innerArgs,
                      CanSILFunctionType innerTypesFuncTy,
-                     ArrayRef<SILParameterInfo> innerTypes)
-    : ExpanderBase(SGF, loc, outerArgs), InnerArgs(innerArgs),
-      InnerTypesFuncTy(innerTypesFuncTy), InnerTypes(innerTypes),
-      InnerPacks(*this) {}
+                     ArrayRef<SILParameterInfo> innerTypes,
+                     SILGenFunction::ThunkGenOptions options = {})
+      : ExpanderBase(SGF, loc, outerArgs), InnerArgs(innerArgs),
+        InnerTypesFuncTy(innerTypesFuncTy), InnerTypes(innerTypes),
+        InnerPacks(*this), Options(options) {}
 
   void process(AbstractionPattern innerOrigFunctionType,
                AnyFunctionType::CanParamArrayRef innerSubstTypes,
@@ -2905,12 +2917,18 @@ static ManagedValue applyTrivialConversions(SILGenFunction &SGF,
 }
 
 /// Forward arguments according to a function type's ownership conventions.
-static void forwardFunctionArguments(SILGenFunction &SGF,
-                                     SILLocation loc,
-                                     CanSILFunctionType fTy,
-                                     ArrayRef<ManagedValue> managedArgs,
-                                     SmallVectorImpl<SILValue> &forwardedArgs) {
+static void
+forwardFunctionArguments(SILGenFunction &SGF, SILLocation loc,
+                         CanSILFunctionType fTy,
+                         ArrayRef<ManagedValue> managedArgs,
+                         SmallVectorImpl<SILValue> &forwardedArgs,
+                         SILGenFunction::ThunkGenOptions options = {}) {
   auto argTypes = fTy->getParameters();
+  if (options.contains(
+          SILGenFunction::ThunkGenFlag::ConvertingFromNonIsolatedCaller)) {
+    argTypes = argTypes.drop_front();
+  }
+
   for (auto index : indices(managedArgs)) {
     auto arg = managedArgs[index];
     auto argTy = argTypes[index];
@@ -5424,9 +5442,31 @@ static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
 
   FullExpr scope(SGF.Cleanups, CleanupLocation(loc));
 
+  using ThunkGenFlag = SILGenFunction::ThunkGenFlag;
+  auto options = SILGenFunction::ThunkGenOptions();
+
+  // If our original function was nonisolated caller and our eventual type is
+  // just nonisolated, pop the isolated argument.
+  //
+  // NOTE: We do this early before thunk params so that we avoid pushing the
+  // isolated parameter preventing us from having to memcpy over the array.
+  if (outputSubstType->isAsync()) {
+    if (outputSubstType->getIsolation().getKind() ==
+            FunctionTypeIsolation::Kind::NonIsolatedCaller &&
+        inputSubstType->getIsolation().getKind() !=
+            FunctionTypeIsolation::Kind::NonIsolatedCaller)
+      options |= ThunkGenFlag::ConvertingToNonIsolatedCaller;
+
+    if (outputSubstType->getIsolation().getKind() !=
+            FunctionTypeIsolation::Kind::NonIsolatedCaller &&
+        inputSubstType->getIsolation().getKind() ==
+            FunctionTypeIsolation::Kind::NonIsolatedCaller)
+      options |= ThunkGenFlag::ConvertingFromNonIsolatedCaller;
+  }
+
   SmallVector<ManagedValue, 8> params;
   SmallVector<ManagedValue, 4> indirectResultParams;
-  SGF.collectThunkParams(loc, params, &indirectResultParams);
+  SGF.collectThunkParams(loc, params, &indirectResultParams, nullptr, options);
 
   // Ignore the self parameter at the SIL level. IRGen will use it to
   // recover type metadata.
@@ -5444,6 +5484,16 @@ static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
     outputErasedIsolation = params.pop_back_val();
   }
 
+  if (!SGF.F.maybeGetIsolatedArgument() && argTypes.size() &&
+      argTypes.front().hasOption(SILParameterInfo::Isolated) &&
+      argTypes.front().hasOption(SILParameterInfo::ImplicitLeading))
+    options |= ThunkGenFlag::ConvertingFromNonIsolatedCaller;
+
+  // If we are converting to nonisolated caller, we are going to have an extra
+  // parameter in our argTypes that we need to drop.
+  if (options.contains(ThunkGenFlag::ConvertingFromNonIsolatedCaller))
+    argTypes = argTypes.drop_front();
+
   // We may need to establish the right executor for the input function.
   // If both function types are synchronous, whoever calls this thunk is
   // responsible for establishing the executor properly, so we don't need
@@ -5514,11 +5564,9 @@ static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
   // other direction (the thunk receives an Int like a T, and passes it
   // like a normal Int when calling the inner function).
   SmallVector<ManagedValue, 8> args;
-  TranslateArguments(SGF, loc, params, args, fnType, argTypes)
-    .process(inputOrigType,
-             inputSubstType.getParams(),
-             outputOrigType,
-             outputSubstType.getParams());
+  TranslateArguments(SGF, loc, params, args, fnType, argTypes, options)
+      .process(inputOrigType, inputSubstType.getParams(), outputOrigType,
+               outputSubstType.getParams());
 
   SmallVector<SILValue, 8> argValues;
 
@@ -5546,11 +5594,35 @@ static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
                               /*mandatory*/false);
   }
 
+  // If we are thunking a nonisolated caller to nonisolated or global actor, we
+  // need to load the actor.
+  if (options.contains(ThunkGenFlag::ConvertingFromNonIsolatedCaller)) {
+    auto outputIsolation = outputSubstType->getIsolation();
+    switch (outputIsolation.getKind()) {
+    case FunctionTypeIsolation::Kind::NonIsolated:
+      argValues.push_back(SGF.emitNonIsolatedIsolation(loc).getValue());
+      break;
+    case FunctionTypeIsolation::Kind::GlobalActor: {
+      auto globalActor =
+          outputIsolation.getGlobalActorType()->getCanonicalType();
+      argValues.push_back(
+          SGF.emitGlobalActorIsolation(loc, globalActor).getValue());
+      break;
+    }
+    case FunctionTypeIsolation::Kind::Parameter:
+    case FunctionTypeIsolation::Kind::Erased:
+    case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      llvm_unreachable("Should never see this");
+      break;
+    }
+  }
+
   // Add the rest of the arguments.
-  forwardFunctionArguments(SGF, loc, fnType, args, argValues);
+  forwardFunctionArguments(SGF, loc, fnType, args, argValues, options);
 
   auto fun = fnType->isCalleeGuaranteed() ? fnValue.borrow(SGF, loc).getValue()
                                           : fnValue.forward(SGF);
+
   SILValue innerResult =
       SGF.emitApplyWithRethrow(loc, fun,
                                /*substFnType*/ fnValue.getType(),
@@ -5683,18 +5755,29 @@ static ManagedValue createThunk(SILGenFunction &SGF,
   auto toType = expectedType->getWithExtInfo(
       expectedType->getExtInfo().withNoEscape(false));
   CanType dynamicSelfType;
-  auto thunkType = SGF.buildThunkType(sourceType, toType,
-                                      inputSubstType,
-                                      outputSubstType,
-                                      genericEnv,
-                                      interfaceSubs,
-                                      dynamicSelfType);
-  // An actor-isolated non-async function can be converted to an async function
-  // by inserting a hop to the global actor.
+  auto thunkType =
+      SGF.buildThunkType(sourceType, toType, inputSubstType, outputSubstType,
+                         genericEnv, interfaceSubs, dynamicSelfType);
   CanType globalActorForThunk;
-  if (outputSubstType->isAsync()
-      && !inputSubstType->isAsync()) {
-    globalActorForThunk = CanType(inputSubstType->getGlobalActor());
+  // If our output type is async...
+  if (outputSubstType->isAsync()) {
+    // And our input type is not async, we can convert the actor-isolated
+    // non-async function to an async function by inserting a hop to the global
+    // actor.
+    if (!inputSubstType->isAsync()) {
+      globalActorForThunk = CanType(inputSubstType->getGlobalActor());
+    } else {
+      // If our inputSubstType is also async and we are converting from a
+      // nonisolated caller to a global actor from a global actor, attach the
+      // global actor for thunk so we mangle appropriately.
+      auto outputIsolation = outputSubstType->getIsolation();
+      if (outputIsolation.getKind() ==
+              FunctionTypeIsolation::Kind::GlobalActor &&
+          inputSubstType->getIsolation().getKind() ==
+              FunctionTypeIsolation::Kind::NonIsolatedCaller)
+        globalActorForThunk =
+            outputIsolation.getGlobalActorType()->getCanonicalType();
+    }
   }
 
   auto thunk = SGF.SGM.getOrCreateReabstractionThunk(

lib/Sema/TypeCheckConcurrency.cpp

@@ -2728,9 +2728,16 @@ namespace {
               diagnoseNonSendableParametersAndResult(toFnType);
               break;
 
-            case FunctionTypeIsolation::Kind::NonIsolatedCaller:
             case FunctionTypeIsolation::Kind::Parameter:
               llvm_unreachable("invalid conversion");
+
+            case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+              // Non isolated caller is always async. This can only occur if we
+              // are converting from an `@Sendable` representation to something
+              // else. So we need to just check that we diagnose non sendable
+              // parameters and results.
+              diagnoseNonSendableParametersAndResult(toFnType);
+              break;
             }
             break;
           }