[concurrency] Add support in SILGen/SIL for emitting and calling implicit leading parameters for CallerInheritingIsolation isolation.

This does not change region isolation yet to recognize these as effectively
nonisolated.

Author: gottesmm

lib/SIL/IR/SILFunctionType.cpp

@@ -1565,6 +1565,7 @@ class DestructureInputs {
   TypeConverter &TC;
   const Conventions &Convs;
   const ForeignInfo &Foreign;
+  std::optional<ActorIsolation> IsolationInfo;
   struct ForeignSelfInfo {
     AbstractionPattern OrigSelfParam;
     AnyFunctionType::CanParam SubstSelfParam;
@@ -1577,9 +1578,10 @@ class DestructureInputs {
 public:
   DestructureInputs(TypeExpansionContext expansion, TypeConverter &TC,
                     const Conventions &conventions, const ForeignInfo &foreign,
+                    std::optional<ActorIsolation> isolationInfo,
                     SmallVectorImpl<SILParameterInfo> &inputs)
       : expansion(expansion), TC(TC), Convs(conventions), Foreign(foreign),
-        Inputs(inputs) {}
+        IsolationInfo(isolationInfo), Inputs(inputs) {}
 
   void destructure(AbstractionPattern origType,
                    CanAnyFunctionType::CanParamArrayRef params,
@@ -1641,6 +1643,23 @@ class DestructureInputs {
       };
     }
 
+    // If we are an async function that is unspecified or nonisolated, insert an
+    // isolated parameter if NonIsolatedAsyncInheritsIsolationFromContext is
+    // enabled.
+    if (TC.Context.LangOpts.hasFeature(
+            Feature::NonIsolatedAsyncInheritsIsolationFromContext) &&
+        IsolationInfo &&
+        IsolationInfo->getKind() == ActorIsolation::CallerIsolationInheriting &&
+        extInfoBuilder.isAsync()) {
+      auto actorProtocol = TC.Context.getProtocol(KnownProtocolKind::Actor);
+      auto actorType =
+          ExistentialType::get(actorProtocol->getDeclaredInterfaceType());
+      addParameter(CanType(actorType).wrapInOptionalType(),
+                   ParameterConvention::Direct_Guaranteed,
+                   ParameterTypeFlags().withIsolated(true),
+                   true /*implicit leading parameter*/);
+    }
+
     // Add any foreign parameters that are positioned at the start
     // of the sequence.  visit() will add foreign parameters that are
     // positioned after any parameters it adds.
@@ -2472,8 +2491,17 @@ static CanSILFunctionType getSILFunctionType(
   // Destructure the input tuple type.
   SmallVector<SILParameterInfo, 8> inputs;
   {
+    std::optional<ActorIsolation> actorIsolation;
+    if (constant) {
+      if (constant->kind == SILDeclRef::Kind::Deallocator) {
+        actorIsolation = ActorIsolation::forNonisolated(false);
+      } else {
+        actorIsolation =
+            getActorIsolationOfContext(constant->getInnermostDeclContext());
+      }
+    }
     DestructureInputs destructurer(expansionContext, TC, conventions,
-                                   foreignInfo, inputs);
+                                   foreignInfo, actorIsolation, inputs);
     destructurer.destructure(origType, substFnInterfaceType.getParams(),
                              extInfoBuilder, unimplementable);
   }
@@ -2561,8 +2589,9 @@ static CanSILFunctionType getSILFunctionTypeForInitAccessor(
   {
     bool unimplementable = false;
     ForeignInfo foreignInfo;
+    std::optional<ActorIsolation> actorIsolation; // For now always null.
     DestructureInputs destructurer(context, TC, conventions, foreignInfo,
-                                   inputs);
+                                   actorIsolation, inputs);
     destructurer.destructure(
         origType, substAccessorType.getParams(),
         extInfoBuilder.withRepresentation(SILFunctionTypeRepresentation::Thin),

lib/SILGen/SILGenApply.cpp

@@ -4783,6 +4783,8 @@ struct ParamLowering {
     return ClaimedParamsRef(result, (unsigned)-1);
   }
 
+  void claimImplicitParameters() { Params = Params.drop_front(); }
+
   ArrayRef<SILParameterInfo>
   claimCaptureParams(ArrayRef<ManagedValue> captures) {
     auto firstCapture = Params.size() - captures.size();
@@ -5445,6 +5447,18 @@ ApplyOptions CallEmission::emitArgumentsForNormalApply(
       options |= ApplyFlags::DoesNotAwait;
     }
 
+    // Before we do anything, claim the implicit parameters. This prevents us
+    // from attempting to handle the implicit parameters when we emit explicit
+    // parameters.
+    //
+    // NOTE: The actual work needs to be done /after/ we emit the normal
+    // parameters since we are going to reverse the order.
+    if (auto isolated = substFnType->maybeGetIsolatedParameter();
+        isolated && isolated->hasOption(SILParameterInfo::ImplicitLeading)) {
+      assert(SGF.ExpectedExecutor.isNecessary());
+      paramLowering.claimImplicitParameters();
+    }
+
     // Collect the captures, if any.
     if (callee.hasCaptures()) {
       (void)paramLowering.claimCaptureParams(callee.getCaptures());
@@ -5476,6 +5490,18 @@ ApplyOptions CallEmission::emitArgumentsForNormalApply(
                               args.back(), delayedArgs, siteForeignError);
   }
 
+  // Now, actually handle the implicit parameters.
+  if (auto isolated = substFnType->maybeGetIsolatedParameter();
+      isolated && isolated->hasOption(SILParameterInfo::ImplicitLeading)) {
+    auto executor =
+        ManagedValue::forBorrowedObjectRValue(SGF.ExpectedExecutor.getEager());
+    args.push_back({});
+    // NOTE: Even though this calls emitActorInstanceIsolation, this also
+    // handles glboal actor isolated cases.
+    args.back().push_back(SGF.emitActorInstanceIsolation(
+        callSite->Loc, executor, executor.getType().getASTType()));
+  }
+
   uncurriedLoc = callSite->Loc;
 
   // Emit any delayed arguments: formal accesses to inout arguments, etc.

lib/SILGen/SILGenConcurrency.cpp

@@ -46,23 +46,48 @@ static void setExpectedExecutorForLocalVar(SILGenFunction &SGF,
   SGF.ExpectedExecutor.set(SGF.emitLoadActorExecutor(loc, actorInstance));
 }
 
-static void setExpectedExecutorForParameterIsolation(SILGenFunction &SGF,
-                                             ActorIsolation actorIsolation) {
+static void
+setExpectedExecutorForParameterIsolation(SILGenFunction &SGF,
+                                         ActorIsolation actorIsolation) {
   auto loc = RegularLocation::getAutoGeneratedLocation(SGF.F.getLocation());
-  ManagedValue actorArg;
-  if (actorIsolation.isActorInstanceForSelfParameter()) {
-    ManagedValue selfMV;
-    auto selfArg = SGF.F.getSelfArgument();
-    if (selfArg->getOwnershipKind() == OwnershipKind::Guaranteed) {
-      selfMV = ManagedValue::forBorrowedRValue(selfArg);
-    } else {
-      selfMV = ManagedValue::forUnmanagedOwnedValue(selfArg);
+
+  if (actorIsolation.isActorInstanceIsolated()) {
+    if (actorIsolation.isActorInstanceForSelfParameter()) {
+      ManagedValue selfMV;
+      auto selfArg = SGF.F.getSelfArgument();
+      if (selfArg->getOwnershipKind() == OwnershipKind::Guaranteed) {
+        selfMV = ManagedValue::forBorrowedRValue(selfArg);
+      } else {
+        selfMV = ManagedValue::forUnmanagedOwnedValue(selfArg);
+      }
+      SGF.ExpectedExecutor.set(SGF.emitLoadActorExecutor(loc, selfMV));
+      return;
+    }
+
+    // See if our actorIsolation actually has an actor instance associated with
+    // it.
+    if (auto param = actorIsolation.getActorInstance()) {
+      return setExpectedExecutorForLocalVar(SGF, param);
+    }
+  }
+
+  // If we have caller isolation inheriting... just grab from our isolated
+  // argument.
+  if (actorIsolation.getKind() == ActorIsolation::CallerIsolationInheriting) {
+    if (auto *isolatedArg = SGF.F.maybeGetIsolatedArgument()) {
+      ManagedValue isolatedMV;
+      if (isolatedArg->getOwnershipKind() == OwnershipKind::Guaranteed) {
+        isolatedMV = ManagedValue::forBorrowedRValue(isolatedArg);
+      } else {
+        isolatedMV = ManagedValue::forUnmanagedOwnedValue(isolatedArg);
+      }
+
+      SGF.ExpectedExecutor.set(SGF.emitLoadActorExecutor(loc, isolatedMV));
+      return;
     }
-    SGF.ExpectedExecutor.set(SGF.emitLoadActorExecutor(loc, selfMV));
-  } else {
-    auto param = actorIsolation.getActorInstance();
-    setExpectedExecutorForLocalVar(SGF, param);
   }
+
+  llvm_unreachable("Unhandled case?!");
 }
 
 void SILGenFunction::emitExpectedExecutorProlog() {
@@ -139,7 +164,6 @@ void SILGenFunction::emitExpectedExecutorProlog() {
     switch (actorIsolation.getKind()) {
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
-    case ActorIsolation::CallerIsolationInheriting:
     case ActorIsolation::NonisolatedUnsafe:
       break;
 
@@ -163,6 +187,11 @@ void SILGenFunction::emitExpectedExecutorProlog() {
       break;
     }
 
+    case ActorIsolation::CallerIsolationInheriting:
+      assert(F.isAsync());
+      setExpectedExecutorForParameterIsolation(*this, actorIsolation);
+      break;
+
     case ActorIsolation::GlobalActor:
       if (F.isAsync() || wantDataRaceChecks) {
         setExpectedExecutorForGlobalActor(*this, actorIsolation.getGlobalActor());

lib/Sema/TypeCheckConcurrency.cpp

@@ -5608,6 +5608,15 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
         checkClassGlobalActorIsolation(classDecl, *isolationFromAttr);
     }
 
+    if (ctx.LangOpts.hasFeature(
+            Feature::NonIsolatedAsyncInheritsIsolationFromContext)) {
+      if (auto *func = dyn_cast<AbstractFunctionDecl>(value);
+          func && func->hasAsync() && isolationFromAttr->isNonisolated() &&
+          func->getModuleContext() == ctx.MainModule) {
+        return {ActorIsolation::forCallerIsolationInheriting(), {}};
+      }
+    }
+
     return {*isolationFromAttr,
             IsolationSource(/*source*/ nullptr, IsolationSource::Explicit)};
   }
@@ -5624,6 +5633,16 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
     defaultIsolation = ActorIsolation::forMainActor(ctx);
   }
 
+  // If we have an async function... by default we inherit isolation.
+  if (ctx.LangOpts.hasFeature(
+          Feature::NonIsolatedAsyncInheritsIsolationFromContext)) {
+    if (auto *func = dyn_cast<AbstractFunctionDecl>(value);
+        func && func->hasAsync() &&
+        func->getModuleContext() == ctx.MainModule) {
+      defaultIsolation = ActorIsolation::forCallerIsolationInheriting();
+    }
+  }
+
   if (auto func = dyn_cast<AbstractFunctionDecl>(value)) {
     // A @Sendable function is assumed to be actor-independent.
     if (func->isSendable()) {

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 = 910; // unsafe conformances
+const uint16_t SWIFTMODULE_VERSION_MINOR = 911; // caller inheriting isolation
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

test/Concurrency/nonisolated_inherits_isolation_sema.swift

@@ -0,0 +1,24 @@
+// RUN: %target-typecheck-verify-swift -swift-version 6 -enable-experimental-feature NonIsolatedAsyncInheritsIsolationFromContext -parse-as-library
+
+class NonSendable {} // expected-note {{}}
+
+@MainActor var global = NonSendable()
+
+@MainActor
+struct MainActorIsolatedStruct {
+  init() {}
+
+  func syncMethod() {}
+  func asyncMethod() {}
+}
+
+struct NonisolatedStruct {
+  // Validate we can still not access global state.
+  func asyncMethod() async {
+    let _ = await global // expected-error {{non-sendable type 'NonSendable' of var 'global' cannot exit main actor-isolated context}}
+
+    let x = await MainActorIsolatedStruct()
+    await x.syncMethod()
+    await x.asyncMethod()
+  }
+}