[concurrency] Make sure both with and without the flag, we codegen execution(caller|concurrent) correctly.

The flag is specifically NonIsolatedAsyncInheritsIsolationFromContext.

I noticed that we were not codegening @execution(caller) when the flag was
disabled, so I fixed it and added this test.

Author: gottesmm

lib/SIL/IR/SILFunctionType.cpp

@@ -1649,9 +1649,7 @@ 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 &&
+    if (IsolationInfo &&
         IsolationInfo->getKind() == ActorIsolation::CallerIsolationInheriting &&
         extInfoBuilder.isAsync()) {
       auto actorProtocol = TC.Context.getProtocol(KnownProtocolKind::Actor);

lib/SILGen/SILGenConcurrency.cpp

@@ -74,17 +74,18 @@ setExpectedExecutorForParameterIsolation(SILGenFunction &SGF,
   // 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;
+    auto *isolatedArg = SGF.F.maybeGetIsolatedArgument();
+    assert(isolatedArg &&
+           "Caller Isolation Inheriting without isolated parameter");
+    ManagedValue isolatedMV;
+    if (isolatedArg->getOwnershipKind() == OwnershipKind::Guaranteed) {
+      isolatedMV = ManagedValue::forBorrowedRValue(isolatedArg);
+    } else {
+      isolatedMV = ManagedValue::forUnmanagedOwnedValue(isolatedArg);
     }
+
+    SGF.ExpectedExecutor.set(SGF.emitLoadActorExecutor(loc, isolatedMV));
+    return;
   }
 
   llvm_unreachable("Unhandled case?!");

test/SILGen/execution_attr.swift

@@ -0,0 +1,21 @@
+// RUN: %target-swift-emit-silgen %s | %FileCheck %s
+// RUN: %target-swift-emit-silgen %s -enable-experimental-feature NonIsolatedAsyncInheritsIsolationFromContext | %FileCheck %s
+
+// REQUIRES: concurrency
+// REQUIRES: asserts
+// REQUIRES: swift_feature_NonIsolatedAsyncInheritsIsolationFromContext
+
+// Validate that both with and without the experimental flag we properly codegen
+// execution(caller) and execution(concurrent).
+
+// CHECK-LABEL: // executionCaller()
+// CHECK-NEXT: // Isolation: caller_isolation_inheriting
+// CHECK-NEXT: sil hidden [ossa] @$s14execution_attr0A6CalleryyYaF : $@convention(thin) @async (@sil_isolated @sil_implicit_leading_param @guaranteed Optional<any Actor>) -> () {
+@execution(caller)
+func executionCaller() async {}
+
+// CHECK-LABEL: // executionConcurrent()
+// CHECK: // Isolation: nonisolated
+// CHECK: sil hidden [ossa] @$s14execution_attr0A10ConcurrentyyYaF : $@convention(thin) @async () -> () {
+@execution(concurrent)
+func executionConcurrent() async {}