Merge pull request #78206 from gottesmm/rdar141520344-1

[concurrency] Add support for NonIsolatedAsyncInheritsIsolationFromContext behind a flag

Author: gottesmm

include/swift/AST/ActorIsolation.h

@@ -69,6 +69,11 @@ class ActorIsolation {
     /// The actor isolation iss statically erased, as for a call to
     /// an isolated(any) function.  This is not possible for declarations.
     Erased,
+    /// Inherits isolation from the caller of the given function.
+    ///
+    /// DISCUSSION: This is used for nonisolated asynchronous functions that we
+    /// want to inherit from their context the context's actor isolation.
+    CallerIsolationInheriting,
   };
 
 private:
@@ -107,6 +112,12 @@ class ActorIsolation {
     return ActorIsolation(unsafe ? NonisolatedUnsafe : Nonisolated);
   }
 
+  static ActorIsolation forCallerIsolationInheriting() {
+    // NOTE: We do not use parameter indices since the parameter is implicit
+    // from the perspective of the AST.
+    return ActorIsolation(CallerIsolationInheriting);
+  }
+
   static ActorIsolation forActorInstanceSelf(ValueDecl *decl);
 
   /// Create an ActorIsolation appropriate for a type that is self.
@@ -152,8 +163,11 @@ class ActorIsolation {
                                             ActorIsolation::NonisolatedUnsafe))
             .Case("global_actor",
                   std::optional<ActorIsolation>(ActorIsolation::GlobalActor))
-            .Case("global_actor_unsafe", std::optional<ActorIsolation>(
-                                             ActorIsolation::GlobalActor))
+            .Case("global_actor_unsafe",
+                  std::optional<ActorIsolation>(ActorIsolation::GlobalActor))
+            .Case("caller_isolation_inheriting",
+                  std::optional<ActorIsolation>(
+                      ActorIsolation::CallerIsolationInheriting))
             .Default(std::nullopt);
     if (kind == std::nullopt)
       return std::nullopt;
@@ -180,8 +194,8 @@ class ActorIsolation {
     return parameterIndex;
   }
 
-  /// Returns true if this actor-instance isolation applies to the self
-  /// parameter of a method.
+  /// Returns true if this is an actor-instance isolation that additionally
+  /// applies to the self parameter of a method.
   bool isActorInstanceForSelfParameter() const {
     return getActorInstanceParameter() == 0;
   }
@@ -198,6 +212,7 @@ class ActorIsolation {
     case Unspecified:
     case Nonisolated:
     case NonisolatedUnsafe:
+    case CallerIsolationInheriting:
       return false;
     }
   }

include/swift/AST/TypeAttr.def

@@ -111,6 +111,7 @@ SIMPLE_SIL_TYPE_ATTR(captures_generics, CapturesGenerics)
 SIMPLE_SIL_TYPE_ATTR(moveOnly, MoveOnly)
 SIMPLE_SIL_TYPE_ATTR(sil_isolated, SILIsolated)
 SIMPLE_SIL_TYPE_ATTR(sil_sending, SILSending)
+SIMPLE_SIL_TYPE_ATTR(sil_implicit_leading_param, SILImplicitLeadingParam)
 
 // SIL metatype attributes.
 SIMPLE_SIL_TYPE_ATTR(thin, Thin)

include/swift/AST/Types.h

@@ -83,6 +83,7 @@ class PlaceholderTypeRepr;
 enum class ReferenceCounting : uint8_t;
 enum class ResilienceExpansion : unsigned;
 class SILModule;
+class SILFunction;
 class SILType;
 class SourceLoc;
 class TypeAliasDecl;
@@ -4438,6 +4439,16 @@ class SILParameterInfo {
     /// that the parameter must be an Optional actor or something that conforms
     /// to AnyActor.
     Isolated = 0x4,
+
+    /// Set if the given parameter is an implicit parameter that is not part of
+    /// the formal type. These are always located after the return values and
+    /// before the main parameters. This is because we want to at the SIL level
+    /// generally treat them as normal parameters... but when working with the
+    /// AST during lowering, we need to handle ignoring them appropriately.
+    ///
+    /// DISCUSSION: These are enforced by the SIL verifier to always be in
+    /// between indirect results and the explicit parameters.
+    ImplicitLeading = 0x8,
   };
 
   using Options = OptionSet<Flag>;
@@ -4464,6 +4475,11 @@ class SILParameterInfo {
   ///
   /// \c t must refer back to the function type this is a parameter for.
   CanType getArgumentType(SILModule &M, const SILFunctionType *t, TypeExpansionContext context) const;
+
+  /// Helper function that just grabs the module, type, and context out of \arg
+  /// fn and then calls getArgumentType.
+  CanType getArgumentType(SILFunction *fn) const;
+
   ParameterConvention getConvention() const { return convention; }
   // Does this parameter convention require indirect storage? This reflects a
   // SILFunctionType's formal (immutable) conventions, as opposed to the

include/swift/Basic/Features.def

@@ -430,14 +430,18 @@ 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.
+/// When a parameter has unspecified isolation, infer it as main actor isolated.
 EXPERIMENTAL_FEATURE(GenerateForceToMainActorThunks, false)
 
 EXPERIMENTAL_FEATURE(AddressableParameters, true)
 
 /// Allow the @abi attribute.
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(ABIAttribute, true)
 
+/// Functions with nonisolated isolation inherit their isolation from the
+/// calling context.
+EXPERIMENTAL_FEATURE(NonIsolatedAsyncInheritsIsolationFromContext, false)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/AST/ASTDumper.cpp

@@ -2959,6 +2959,10 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
       printFlag(true, "dynamically_isolated", CapturesColor);
       break;
 
+    case ActorIsolation::CallerIsolationInheriting:
+      printFlag(true, "isolated_to_caller_isolation", CapturesColor);
+      break;
+
     case ActorIsolation::ActorInstance:
       printFieldQuoted(isolation.getActorInstance()->printRef(),
                        "actor_isolated", CapturesColor);

lib/AST/ASTPrinter.cpp

@@ -7583,6 +7583,11 @@ void SILParameterInfo::print(
     Printer.printLifetimeDependence(*lifetimeDependence);
   }
 
+  if (options.contains(SILParameterInfo::ImplicitLeading)) {
+    options -= SILParameterInfo::ImplicitLeading;
+    Printer << "@sil_implicit_leading_param ";
+  }
+
   // If we did not handle a case in Options, this code was not updated
   // appropriately.
   assert(!bool(options) && "Code not updated for introduced option");

lib/AST/ActorIsolation.cpp

@@ -174,6 +174,11 @@ bool ActorIsolation::isEqual(const ActorIsolation &lhs,
     // to answer.
     return false;
 
+  case CallerIsolationInheriting:
+    // This returns false for the same reason as erased. The caller has to check
+    // against the actual caller isolation.
+    return false;
+
   case ActorInstance: {
     auto *lhsActor = lhs.getActorInstance();
     auto *rhsActor = rhs.getActorInstance();

lib/AST/Decl.cpp

@@ -2708,6 +2708,7 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
 
             return true;
 
+          case ActorIsolation::CallerIsolationInheriting:
           case ActorIsolation::ActorInstance:
           case ActorIsolation::Nonisolated:
           case ActorIsolation::Erased: // really can't happen
@@ -11341,6 +11342,7 @@ bool VarDecl::isSelfParamCaptureIsolated() const {
       case ActorIsolation::NonisolatedUnsafe:
       case ActorIsolation::GlobalActor:
       case ActorIsolation::Erased:
+      case ActorIsolation::CallerIsolationInheriting:
         return false;
 
       case ActorIsolation::ActorInstance:

lib/AST/FeatureSet.cpp

@@ -120,6 +120,7 @@ UNINTERESTING_FEATURE(Volatile)
 UNINTERESTING_FEATURE(SuppressedAssociatedTypes)
 UNINTERESTING_FEATURE(StructLetDestructuring)
 UNINTERESTING_FEATURE(MacrosOnImports)
+UNINTERESTING_FEATURE(NonIsolatedAsyncInheritsIsolationFromContext)
 
 static bool usesFeatureNonescapableTypes(Decl *decl) {
   auto containsNonEscapable =

lib/AST/TypeCheckRequests.cpp

@@ -1856,6 +1856,7 @@ SourceLoc MacroDefinitionRequest::getNearestLoc() const {
 
 bool ActorIsolation::requiresSubstitution() const {
   switch (kind) {
+  case CallerIsolationInheriting:
   case ActorInstance:
   case Nonisolated:
   case NonisolatedUnsafe:
@@ -1871,6 +1872,7 @@ bool ActorIsolation::requiresSubstitution() const {
 ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
   switch (kind) {
   case ActorInstance:
+  case CallerIsolationInheriting:
   case Nonisolated:
   case NonisolatedUnsafe:
   case Unspecified:
@@ -1891,6 +1893,11 @@ void ActorIsolation::printForDiagnostics(llvm::raw_ostream &os,
     os << "actor" << (asNoun ? " isolation" : "-isolated");
     break;
 
+  case ActorIsolation::CallerIsolationInheriting:
+    os << "caller isolation inheriting"
+       << (asNoun ? " isolation" : "-isolated");
+    break;
+
   case ActorIsolation::GlobalActor: {
     if (isMainActor()) {
       os << "main actor" << (asNoun ? " isolation" : "-isolated");
@@ -1927,6 +1934,9 @@ void ActorIsolation::print(llvm::raw_ostream &os) const {
       os << ". name: '" << vd->getBaseIdentifier() << "'";
     }
     return;
+  case CallerIsolationInheriting:
+    os << "caller_isolation_inheriting";
+    return;
   case Nonisolated:
     os << "nonisolated";
     return;
@@ -1951,6 +1961,9 @@ void ActorIsolation::printForSIL(llvm::raw_ostream &os) const {
   case ActorInstance:
     os << "actor_instance";
     return;
+  case CallerIsolationInheriting:
+    os << "caller_isolation_inheriting";
+    return;
   case Nonisolated:
     os << "nonisolated";
     return;
@@ -1996,6 +2009,10 @@ void swift::simple_display(
       }
       break;
 
+    case ActorIsolation::CallerIsolationInheriting:
+      out << "isolated to isolation of caller";
+      break;
+
     case ActorIsolation::Nonisolated:
     case ActorIsolation::NonisolatedUnsafe:
       out << "nonisolated";