At the SIL level, allow synchronous functions to be nonisolated(nonsending).

Author: rjmccall

lib/SIL/IR/SILFunctionType.cpp

@@ -1262,6 +1262,11 @@ class Conventions {
 
   ConventionsKind getKind() const { return kind; }
 
+  bool hasCallerIsolationParameter() const {
+    return kind == ConventionsKind::Default ||
+           kind == ConventionsKind::Deallocator;
+  }
+
   virtual ParameterConvention
   getIndirectParameter(unsigned index,
                        const AbstractionPattern &type,
@@ -1706,14 +1711,10 @@ class DestructureInputs {
       };
     }
 
-    // If we are an async function that is unspecified or nonisolated, insert an
-    // isolated parameter if NonisolatedNonsendingByDefault is enabled.
-    //
-    // NOTE: The parameter is not inserted for async functions imported
-    // from ObjC because they are handled in a special way that doesn't
-    // require it.
+    // If the function has nonisolated(nonsending) isolation, insert the
+    // implicit isolation parameter.
     if (IsolationInfo && IsolationInfo->isCallerIsolationInheriting() &&
-        extInfoBuilder.isAsync() && !Foreign.async) {
+        Convs.hasCallerIsolationParameter()) {
       auto actorProtocol = TC.Context.getProtocol(KnownProtocolKind::Actor);
       auto actorType =
           ExistentialType::get(actorProtocol->getDeclaredInterfaceType());

lib/SILGen/SILGenConcurrency.cpp

@@ -190,7 +190,7 @@ void SILGenFunction::emitExpectedExecutorProlog() {
     }
 
     case ActorIsolation::CallerIsolationInheriting:
-      assert(F.isAsync());
+      assert(F.isAsync() || F.isDefer());
       setExpectedExecutorForParameterIsolation(*this, actorIsolation);
       break;
 
@@ -255,7 +255,7 @@ void SILGenFunction::emitExpectedExecutorProlog() {
           RegularLocation::getDebugOnlyLocation(F.getLocation(), getModule()),
           executor,
           /*mandatory*/ false);
-    } else {
+    } else if (wantDataRaceChecks) {
       // For a synchronous function, check that we're on the same executor.
       // Note: if we "know" that the code is completely Sendable-safe, this
       // is unnecessary. The type checker will need to make this determination.

lib/SILGen/SILGenExpr.cpp

@@ -2871,12 +2871,22 @@ SILGenFunction::emitApplyOfDefaultArgGenerator(SILLocation loc,
       ResultPlanBuilder::computeResultPlan(*this, calleeTypeInfo, loc, C);
   ArgumentScope argScope(*this, loc);
 
-  SmallVector<ManagedValue, 4> captures;
+  SmallVector<ManagedValue, 4> args;
+
+  // Add the implicit leading isolation argument for a
+  // nonisolated(nonsending) default argument generator.
+  if (fnType->maybeGetIsolatedParameter()) {
+    auto executor = emitExpectedExecutor(loc);
+    args.push_back(emitActorInstanceIsolation(
+                     loc, executor, executor.getType().getASTType()));
+  }
+
+  // If there are captures, those come at the end.
   emitCaptures(loc, generator, CaptureEmission::ImmediateApplication,
-               captures);
+               args);
 
   return emitApply(std::move(resultPtr), std::move(argScope), loc, fnRef, subs,
-                   captures, calleeTypeInfo, ApplyOptions(), C, std::nullopt);
+                   args, calleeTypeInfo, ApplyOptions(), C, std::nullopt);
 }
 
 RValue SILGenFunction::emitApplyOfStoredPropertyInitializer(

test/SILGen/isolated_default_arguments.swift

@@ -28,6 +28,10 @@ func main_actor_int_pair() -> (Int, Int) {
   return (0,0)
 }
 
+func make_int(isolated isolation: (any Actor)? = #isolation) -> Int {
+  return 0
+}
+
 // This test breaks because the intermediate argument is `nil`, which
 // we treat as non-isolated.
 @MainActor
@@ -121,3 +125,39 @@ func tupleIsolatedDefaultArg(x: (Int,Int) = main_actor_int_pair(),
 func testTupleIsolatedDefaultArg() async {
   await tupleIsolatedDefaultArg(y: 0)
 }
+
+// When a function is caller-isolated, its default argument generators
+// should probably also be caller-isolated and forward their isolation
+// properly when #isolation is used. Currently, however, that's not what
+// we're doing, so test for the current behavior.
+
+nonisolated(nonsending)
+func callerIsolatedDefaultArg(x: Int = make_int()) async {}
+
+@MainActor
+func useCallerIsolatedDefaultArg() async {
+  await callerIsolatedDefaultArg()
+}
+
+//   Check that the default argument generator isn't caller-isolated.
+// CHECK-LABEL: // default argument 0 of test.callerIsolatedDefaultArg
+// CHECK-NEXT:  // Isolation: unspecified
+// CHECK-NEXT:  sil hidden [ossa] @$s4test24callerIsolatedDefaultArg1xySi_tYaFfA_ :
+// CHECK:       bb0:
+//   Check that we provide a nil isolation for #isolation
+// CHECK-NEXT:    [[NIL_ISOLATION:%.*]] = enum $Optional<any Actor>, #Optional.none
+// CHECK-NEXT:    // function_ref test.make_int
+// CHECK-NEXT:    [[FN:%.*]] = function_ref @$s4test8make_int8isolatedSiScA_pSg_tF :
+// CHECK-NEXT:    [[RESULT:%.*]] = apply [[FN]]([[NIL_ISOLATION]])
+// CHECK-NEXT:    return [[RESULT]]
+
+//   Check that we pass the right isolation to the generator.
+// CHECK-LABEL: sil hidden [ossa] @$s4test27useCallerIsolatedDefaultArgyyYaF :
+//   Get the main actor reference.
+// CHECK:         [[GET_MAIN_ACTOR:%.*]] = function_ref @$sScM6sharedScMvgZ :
+// CHECK-NEXT:    [[T0:%.*]] = apply [[GET_MAIN_ACTOR]](
+// CHECK-NEXT:    [[MAIN_ACTOR:%.*]] = begin_borrow [[T0]]
+//   Call the accessor.
+// CHECK:         // function_ref default argument 0 of
+// CHECK-NEXT:    [[GEN:%.*]] = function_ref @$s4test24callerIsolatedDefaultArg1xySi_tYaFfA_ :
+// CHECK-NEXT:    [[ARG:%.*]] = apply [[GEN]]()

test/SILGen/objc_async_from_swift.swift

@@ -466,7 +466,7 @@ func testAutoclosureInStaticMethod() {
     //
     // Get standard.
     // CHECK: [[METATYPE:%.*]] = metatype $@objc_metatype SlowServer.Type
-    // CHECK: [[GET_STANDARD_FUNC:%.*]] = objc_method %1 : $@objc_metatype SlowServer.Type, #SlowServer.standard!getter.foreign : (SlowServer.Type) -> () -> SlowServer, $@convention(objc_method) (@objc_metatype SlowServer.Type) -> @autoreleased SlowServer
+    // CHECK: [[GET_STANDARD_FUNC:%.*]] = objc_method [[METATYPE]] : $@objc_metatype SlowServer.Type, #SlowServer.standard!getter.foreign : (SlowServer.Type) -> () -> SlowServer, $@convention(objc_method) (@objc_metatype SlowServer.Type) -> @autoreleased SlowServer
     // CHECK: [[STANDARD:%.*]] = apply [[GET_STANDARD_FUNC]]([[METATYPE]])
     //
     // Then grab value.
@@ -592,7 +592,7 @@ func testAutoclosureInStaticMethod() {
     //
     // Get standard.
     // CHECK: [[METATYPE:%.*]] = metatype $@objc_metatype SlowServer.Type
-    // CHECK: [[GET_STANDARD_FUNC:%.*]] = objc_method %1 : $@objc_metatype SlowServer.Type, #SlowServer.standard!getter.foreign : (SlowServer.Type) -> () -> SlowServer, $@convention(objc_method) (@objc_metatype SlowServer.Type) -> @autoreleased SlowServer
+    // CHECK: [[GET_STANDARD_FUNC:%.*]] = objc_method [[METATYPE]] : $@objc_metatype SlowServer.Type, #SlowServer.standard!getter.foreign : (SlowServer.Type) -> () -> SlowServer, $@convention(objc_method) (@objc_metatype SlowServer.Type) -> @autoreleased SlowServer
     // CHECK: [[STANDARD:%.*]] = apply [[GET_STANDARD_FUNC]]([[METATYPE]])
     //
     // Then grab value.