[SILGen] Emit expected executor preconditions for synchronous isolated @preconcurrency witness thunks

For `@preconcurrency` conformance witness thunks replace hop to
executor with a precondition to make sure that the thunk is always
called in the expected context.

Author: xedin

lib/SILGen/SILGenFunction.h

@@ -946,12 +946,16 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   ///
   /// This is used for both concrete witness thunks and default witness
   /// thunks.
+  ///
+  /// \param isPreconcurrency If the conformance is marked as `@preconcurrency`
+  /// instead of a hop (when entering isolation) emit a dynamic check to make
+  /// sure that witness has been unsed in the expected context.
   void emitProtocolWitness(AbstractionPattern reqtOrigTy,
                            CanAnyFunctionType reqtSubstTy,
                            SILDeclRef requirement, SubstitutionMap reqtSubs,
                            SILDeclRef witness, SubstitutionMap witnessSubs,
                            IsFreeFunctionWitness_t isFree,
-                           bool isSelfConformance,
+                           bool isSelfConformance, bool isPreconcurrency,
                            llvm::Optional<ActorIsolation> enterIsolation);
 
   /// Generates subscript arguments for keypath. This function handles lowering

lib/SILGen/SILGenPoly.cpp

@@ -6861,7 +6861,8 @@ void SILGenFunction::emitProtocolWitness(
     AbstractionPattern reqtOrigTy, CanAnyFunctionType reqtSubstTy,
     SILDeclRef requirement, SubstitutionMap reqtSubs, SILDeclRef witness,
     SubstitutionMap witnessSubs, IsFreeFunctionWitness_t isFree,
-    bool isSelfConformance, llvm::Optional<ActorIsolation> enterIsolation) {
+    bool isSelfConformance, bool isPreconcurrency,
+    llvm::Optional<ActorIsolation> enterIsolation) {
   // FIXME: Disable checks that the protocol witness carries debug info.
   // Should we carry debug info for witnesses?
   F.setBare(IsBare);
@@ -6905,7 +6906,13 @@ void SILGenFunction::emitProtocolWitness(
       actorSelf = actorSelfVal;
     }
 
-    emitHopToTargetActor(loc, enterIsolation, actorSelf);
+    if (!F.isAsync()) {
+      assert(isPreconcurrency);
+      auto executor = emitExecutor(loc, *enterIsolation, actorSelf);
+      emitPreconditionCheckExpectedExecutor(loc, *executor);
+    } else {
+      emitHopToTargetActor(loc, enterIsolation, actorSelf);
+    }
   }
 
   // Get the type of the witness.

lib/SILGen/SILGenType.cpp

@@ -834,9 +834,21 @@ SILFunction *SILGenModule::emitProtocolWitness(
   // archetypes of the witness thunk generic environment.
   auto witnessSubs = witness.getSubstitutions();
 
+  // If the conformance is marked as `@preconcurrency` instead of
+  // emitting a hop to the executor (when needed) emit a dynamic check
+  // to make sure that witness has been unsed in the expected context.
+  bool isPreconcurrency = false;
+  if (conformance.isConcrete()) {
+    if (auto *C =
+            dyn_cast<NormalProtocolConformance>(conformance.getConcrete()))
+      isPreconcurrency = C->isPreconcurrency();
+  }
+
   SGF.emitProtocolWitness(AbstractionPattern(reqtOrigTy), reqtSubstTy,
                           requirement, reqtSubMap, witnessRef,
-                          witnessSubs, isFree, /*isSelfConformance*/ false,
+                          witnessSubs, isFree,
+                          /*isSelfConformance*/ false,
+                          isPreconcurrency,
                           witness.getEnterIsolation());
 
   emitLazyConformancesForFunction(f);
@@ -910,7 +922,8 @@ static SILFunction *emitSelfConformanceWitness(SILGenModule &SGM,
 
   SGF.emitProtocolWitness(AbstractionPattern(reqtOrigTy), reqtSubstTy,
                           requirement, reqtSubs, requirement, witnessSubs,
-                          isFree, /*isSelfConformance*/ true, llvm::None);
+                          isFree, /*isSelfConformance*/ true,
+                          /*isPreconcurrency*/ false, llvm::None);
 
   SGM.emitLazyConformancesForFunction(f);
 

test/Interpreter/preconcurrency_conformances.swift

@@ -0,0 +1,97 @@
+// RUN: %empty-directory(%t/src)
+// RUN: split-file %s %t/src
+
+// RUN: %target-build-swift %t/src/Interface.swift -swift-version 5 -emit-module -emit-library \
+// RUN:    -enable-library-evolution \
+// RUN:    -module-name Interface \
+// RUN:    -o %t/%target-library-name(Interface) \
+// RUN:    -emit-module-interface-path %t/Interface.swiftinterface
+
+// RUN: %target-build-swift %t/src/Types.swift -swift-version 5 -emit-module -emit-library -enable-library-evolution -module-name Types -o %t/%target-library-name(Types) \
+// RUN:    -I %t -L %t -l Interface \
+// RUN:    -emit-module-interface-path %t/Types.swiftinterface \
+// RUN:    -Xfrontend -enable-experimental-feature -Xfrontend PreconcurrencyConformances
+
+// RUN: %target-build-swift -Xfrontend -enable-experimental-feature -Xfrontend PreconcurrencyConformances -I %t -L %t -l Types %t/src/Crash1.swift -o %t/crash1.out
+// RUN: %target-codesign %t/crash1.out
+// RUN: not --crash env SWIFT_UNEXPECTED_EXECUTOR_LOG_LEVEL=2 %target-run %t/crash1.out 2>&1 | %FileCheck %t/src/Crash1.swift
+
+// RUN: %target-build-swift -Xfrontend -enable-experimental-feature -Xfrontend PreconcurrencyConformances -I %t -L %t -l Types %t/src/Crash2.swift -o %t/crash2.out
+// RUN: %target-codesign %t/crash2.out
+// RUN: not --crash env SWIFT_UNEXPECTED_EXECUTOR_LOG_LEVEL=2 %target-run %t/crash2.out 2>&1 | %FileCheck %t/src/Crash2.swift
+
+// RUN: %target-build-swift -Xfrontend -enable-experimental-feature -Xfrontend PreconcurrencyConformances -I %t -L %t -l Types %t/src/Crash3.swift -o %t/crash3.out
+// RUN: %target-codesign %t/crash3.out
+// RUN: not --crash env SWIFT_UNEXPECTED_EXECUTOR_LOG_LEVEL=2 %target-run %t/crash3.out 2>&1 | %FileCheck %t/src/Crash3.swift
+
+// RUN: %target-build-swift -Xfrontend -enable-experimental-feature -Xfrontend PreconcurrencyConformances -I %t -L %t -l Types %t/src/Crash4.swift -o %t/crash4.out
+// RUN: %target-codesign %t/crash4.out
+// RUN: not --crash env SWIFT_UNEXPECTED_EXECUTOR_LOG_LEVEL=2 %target-run %t/crash4.out 2>&1 | %FileCheck %t/src/Crash4.swift
+
+// REQUIRES: asserts
+// REQUIRES: concurrency
+// REQUIRES: executable_test
+
+//--- Interface.swift
+public protocol P {
+  init()
+
+  var prop: [String] { get set }
+  func test() -> Int
+}
+
+//--- Types.swift
+import Interface
+
+public func runTest<T: P>(_ type: T.Type) async -> Int {
+  let v = type.init()
+  return v.test()
+}
+
+public func runAccessors<T: P>(_ type: T.Type) async -> [String] {
+  var v = type.init()
+  v.prop = ["a", "b", "c"]
+  return v.prop
+}
+
+public final class Test : @preconcurrency P {
+  @MainActor public var prop: [String] = []
+  @MainActor public func test() -> Int { 42 }
+
+  public init() {}
+}
+
+public actor ActorTest {
+  var x: Int = 0
+
+  public init() {}
+}
+
+extension ActorTest : @preconcurrency P {
+  public var prop: [String] {
+    get { [] }
+    set { }
+  }
+
+  public func test() -> Int { x }
+}
+
+//--- Crash1.swift
+import Types
+print(await runTest(Test.self))
+// CHECK: error: data race detected: @MainActor function at Types/Types.swift:16 was not called on the main thread
+
+//--- Crash2.swift
+import Types
+print(await runAccessors(Test.self))
+// CHECK: error: data race detected: @MainActor function at Types/Types.swift:15 was not called on the main thread
+
+//--- Crash3.swift
+import Types
+print(await runTest(ActorTest.self))
+// CHECK: error: data race detected: actor-isolated function at Types/Types.swift:33 was not called on the same actor
+
+//--- Crash4.swift
+import Types
+print(await runAccessors(ActorTest.self))
+// CHECK: error: data race detected: actor-isolated function at Types/Types.swift:30 was not called on the same actor