[AST] Declare NonIsolatedCaller as kind of FunctionTypeIsolation

This would make sure that async function types marked as `@execution(caller)`
have correct isolation.

Also defines all of the possible conversions to and from `caller`
isolated function types.

Author: xedin

include/swift/AST/ExtInfo.h

@@ -63,6 +63,21 @@ class FunctionTypeIsolation {
 
     /// The function's isolation is statically erased with @isolated(any).
     Erased,
+
+    /// Inherits isolation from the caller. This is only applicable
+    /// to asynchronous function types.
+    ///
+    /// NOTE: The difference in between NonIsolatedCaller and
+    /// NonIsolated is that NonIsolatedCaller is a strictly
+    /// weaker form of nonisolation. While both in their bodies cannot
+    /// access isolated state directly, NonIsolatedCaller functions
+    /// /are/ allowed to access state isolated to their caller via
+    /// function arguments since we know that the callee will stay
+    /// in the caller's isolation domain. In contrast, NonIsolated
+    /// is strongly nonisolated and is not allowed to access /any/
+    /// isolated state (even via function parameters) since it is
+    /// considered safe to run on /any/ actor.
+    NonIsolatedCaller,
   };
 
   static constexpr size_t NumBits = 3; // future-proof this slightly
@@ -87,6 +102,9 @@ class FunctionTypeIsolation {
   static FunctionTypeIsolation forErased() {
     return { Kind::Erased };
   }
+  static FunctionTypeIsolation forNonIsolatedCaller() {
+    return { Kind::NonIsolatedCaller };
+  }
 
   Kind getKind() const { return value.getInt(); }
   bool isNonIsolated() const {

lib/AST/ASTMangler.cpp

@@ -3285,6 +3285,11 @@ void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
     if (AllowIsolatedAny)
       appendOperator("YA");
     break;
+
+  case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+    // TODO: We need a special mangling for this to
+    // make it distinct from the `@execution(concurrent)`.
+    break;
   }
 
   if (isRecursedInto && fn->hasSendingResult()) {

lib/AST/ASTPrinter.cpp

@@ -6421,6 +6421,10 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       if (!Options.SuppressIsolatedAny)
         Printer << "@isolated(any) ";
       break;
+
+    case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      Printer << "@execution(caller) ";
+      break;
     }
 
     if (!Options.excludeAttrKind(TypeAttrKind::Sendable) && info.isSendable()) {

lib/SILGen/SILGenConcurrency.cpp

@@ -563,6 +563,7 @@ SILGenFunction::emitFunctionTypeIsolation(SILLocation loc,
 
   // Emit nonisolated by simply emitting Optional.none in the result type.
   case FunctionTypeIsolation::Kind::NonIsolated:
+  case FunctionTypeIsolation::Kind::NonIsolatedCaller:
     return emitNonIsolatedIsolation(loc);
 
   // Emit global actor isolation by loading .shared from the global actor,

lib/SILGen/SILGenPoly.cpp

@@ -5439,6 +5439,10 @@ static void buildThunkBody(SILGenFunction &SGF, SILLocation loc,
     case FunctionTypeIsolation::Kind::NonIsolated:
       break;
 
+    case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      hopToIsolatedParameter = true;
+      break;
+
     // For a function with parameter isolation, we'll have to dig the
     // argument out after translation but before making the call.
     case FunctionTypeIsolation::Kind::Parameter:

lib/Sema/CSSimplify.cpp

@@ -2964,6 +2964,10 @@ ConstraintSystem::matchFunctionIsolations(FunctionType *func1,
     case FunctionTypeIsolation::Kind::NonIsolated:
       return true;
 
+    // A thunk is going to pass `nil` to the isolated parameter.
+    case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      return matchIfConversion();
+
     // Erasing global-actor isolation to non-isolation can admit data
     // races; such violations are diagnosed by the actor isolation checker.
     // We deliberately do not allow actor isolation violations to influence
@@ -2984,6 +2988,35 @@ ConstraintSystem::matchFunctionIsolations(FunctionType *func1,
     }
     llvm_unreachable("bad kind");
 
+  // Converting to a caller isolated async function type.
+  case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+    switch (isolation1.getKind()) {
+    // Exact match.
+    case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      return true;
+
+    // Global actor: Thunk will hop to the global actor
+    // and would ignore passed in isolation.
+    // Erased: Just like global actor but would hop to
+    // the isolation stored in the @isolated(any) function.
+    case FunctionTypeIsolation::Kind::GlobalActor:
+    case FunctionTypeIsolation::Kind::Erased:
+      return matchIfConversion();
+
+    // In this case the isolation is dependent on a
+    // specific actor passed in as the isolation parameter
+    // and the thunk won't have it.
+    case FunctionTypeIsolation::Kind::Parameter:
+      return false;
+
+    // For asynchronous: Thunk would hop the appropriate actor.
+    // For synchronous: Thunk would call the function without
+    // a hop.
+    case FunctionTypeIsolation::Kind::NonIsolated:
+      return matchIfConversion();
+    }
+    llvm_unreachable("bad kind");
+
   // Converting to a global-actor-isolated type.
   case FunctionTypeIsolation::Kind::GlobalActor:
     switch (isolation1.getKind()) {
@@ -3004,6 +3037,11 @@ ConstraintSystem::matchFunctionIsolations(FunctionType *func1,
     case FunctionTypeIsolation::Kind::NonIsolated:
       return matchIfConversion();
 
+    // A thunk is going to pass in an instance of a global actor
+    // to the isolated parameter.
+    case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      return matchIfConversion();
+
     // Parameter isolation cannot be altered in the same way.
     case FunctionTypeIsolation::Kind::Parameter:
       return false;
@@ -3030,6 +3068,10 @@ ConstraintSystem::matchFunctionIsolations(FunctionType *func1,
     case FunctionTypeIsolation::Kind::GlobalActor:
       return matchIfConversion();
 
+    // A thunk is going to forward the isolation.
+    case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      return matchIfConversion();
+
     // Don't allow dynamically-isolated function types to convert to
     // any specific isolation for the same policy reasons that we don't
     // want to allow global-actors to change.
@@ -3050,6 +3092,11 @@ ConstraintSystem::matchFunctionIsolations(FunctionType *func1,
     case FunctionTypeIsolation::Kind::GlobalActor:
       return matchIfConversion(/*erasure*/ true);
 
+    // It's not possible to form a thunk for this case because
+    // we don't know what to pass to the isolated parameter.
+    case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      return false;
+
     // Parameter isolation is value-dependent and can't be erased in the
     // abstract, though.  We need to be able to recover the isolation from
     // a value.

lib/Sema/TypeCheckType.cpp

@@ -4206,7 +4206,7 @@ NeverNullType TypeResolver::resolveASTFunctionType(
     switch (isolation.getKind()) {
     case FunctionTypeIsolation::Kind::NonIsolated:
       break;
-
+         
     case FunctionTypeIsolation::Kind::GlobalActor:
       diagnoseInvalid(
           repr, executionAttr->getAtLoc(),
@@ -4228,15 +4228,19 @@ NeverNullType TypeResolver::resolveASTFunctionType(
           diag::
               attr_execution_concurrent_type_attr_incompatible_with_isolated_any);
       break;
+
+    case FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      llvm_unreachable("cannot happen because multiple @execution attributes "
+                       "aren't allowed.");
     }
 
     if (!repr->isInvalid()) {
       switch (executionAttr->getBehavior()) {
       case ExecutionKind::Concurrent:
-        // TODO: We need to introduce a new isolation kind to support this.
+        isolation = FunctionTypeIsolation::forNonIsolated();
         break;
       case ExecutionKind::Caller:
-        isolation = FunctionTypeIsolation::forNonIsolated();
+        isolation = FunctionTypeIsolation::forNonIsolatedCaller();
         break;
       }
     }

lib/Serialization/Deserialization.cpp

@@ -7133,6 +7133,8 @@ detail::function_deserializer::deserialize(ModuleFile &MF,
   auto isolation = swift::FunctionTypeIsolation::forNonIsolated();
   if (rawIsolation == unsigned(FunctionTypeIsolation::NonIsolated)) {
     // do nothing
+  } else if (rawIsolation == unsigned(FunctionTypeIsolation::NonIsolatedCaller)) {
+    isolation = swift::FunctionTypeIsolation::forNonIsolatedCaller();
   } else if (rawIsolation == unsigned(FunctionTypeIsolation::Parameter)) {
     isolation = swift::FunctionTypeIsolation::forParameter();
   } else if (rawIsolation == unsigned(FunctionTypeIsolation::Erased)) {

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 921; // remove alloc_vector
+const uint16_t SWIFTMODULE_VERSION_MINOR = 922; // function type isolation - caller
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -707,6 +707,7 @@ enum class FunctionTypeIsolation : uint8_t {
   Parameter,
   Erased,
   GlobalActorOffset, // Add this to the global actor type ID
+  NonIsolatedCaller,
 };
 using FunctionTypeIsolationField = TypeIDField;
 

lib/Serialization/Serialization.cpp

@@ -5781,6 +5781,8 @@ class Serializer::TypeSerializer : public TypeVisitor<TypeSerializer> {
     switch (isolation.getKind()) {
     case swift::FunctionTypeIsolation::Kind::NonIsolated:
       return unsigned(FunctionTypeIsolation::NonIsolated);
+    case swift::FunctionTypeIsolation::Kind::NonIsolatedCaller:
+      return unsigned(FunctionTypeIsolation::NonIsolatedCaller);
     case swift::FunctionTypeIsolation::Kind::Parameter:
       return unsigned(FunctionTypeIsolation::Parameter);
     case swift::FunctionTypeIsolation::Kind::Erased: