Metadata and runtime support for checking isolated conformances at runtime

Extend the metadata representation of protocol conformance descriptors
to include information about the global actor to which the conformance is
isolated (when there is one), as well as the conformance of that type to
the GlobalActor protocol. Emit this metadata whenever a conformance is
isolated.

When performing a conforms-to-protocol check at runtime, check whether
the conformance that was found is isolated. If so, extract the serial
executor for the global actor and check whether we are running on that
executor. If not, the conformance fails.

Author: DougGregor

include/swift/ABI/Metadata.h

@@ -2734,6 +2734,17 @@ struct TargetResilientWitnessesHeader {
 };
 using ResilientWitnessesHeader = TargetResilientWitnessesHeader<InProcess>;
 
+/// Describes a reference to a global actor type and its conformance to the
+/// global actor protocol.
+template<typename Runtime>
+struct TargetGlobalActorReference {
+  /// The type of the global actor.
+  RelativeDirectPointer<const char, /*nullable*/ false> type;
+
+  /// The conformance of the global actor to the GlobalActor protocol.
+  TargetRelativeProtocolConformanceDescriptorPointer<Runtime> conformance;
+};
+
 /// The structure of a protocol conformance.
 ///
 /// This contains enough static information to recover the witness table for a
@@ -2747,7 +2758,8 @@ struct TargetProtocolConformanceDescriptor final
              GenericPackShapeDescriptor,
              TargetResilientWitnessesHeader<Runtime>,
              TargetResilientWitness<Runtime>,
-             TargetGenericWitnessTable<Runtime>> {
+             TargetGenericWitnessTable<Runtime>,
+             TargetGlobalActorReference<Runtime>> {
 
   using TrailingObjects = swift::ABI::TrailingObjects<
                              TargetProtocolConformanceDescriptor<Runtime>,
@@ -2756,7 +2768,8 @@ struct TargetProtocolConformanceDescriptor final
                              GenericPackShapeDescriptor,
                              TargetResilientWitnessesHeader<Runtime>,
                              TargetResilientWitness<Runtime>,
-                             TargetGenericWitnessTable<Runtime>>;
+                             TargetGenericWitnessTable<Runtime>,
+                             TargetGlobalActorReference<Runtime>>;
   friend TrailingObjects;
 
   template<typename T>
@@ -2892,6 +2905,32 @@ struct TargetProtocolConformanceDescriptor final
     return this->template getTrailingObjects<GenericWitnessTable>();
   }
 
+  /// Whether this conformance has any conditional requirements that need to
+  /// be evaluated.
+  bool hasGlobalActorIsolation() const {
+    return Flags.hasGlobalActorIsolation();
+  }
+
+  /// Retrieve the global actor type to which this conformance is isolated, if
+  /// any.
+  llvm::StringRef
+  getGlobalActorType() const {
+    if (!Flags.hasGlobalActorIsolation())
+      return llvm::StringRef();
+
+    return Demangle::makeSymbolicMangledNameStringRef(this->template getTrailingObjects<TargetGlobalActorReference<Runtime>>()->type);
+  }
+
+  /// Retrieve the protocol conformance of the global actor type to the
+  /// GlobalActor protocol.
+  const TargetProtocolConformanceDescriptor<Runtime> *
+  getGlobalActorConformance() const {
+    if (!Flags.hasGlobalActorIsolation())
+      return nullptr;
+
+    return this->template getTrailingObjects<TargetGlobalActorReference<Runtime>>()->conformance;
+  }
+
 #if !defined(NDEBUG) && SWIFT_OBJC_INTEROP
   void dump() const;
 #endif
@@ -2934,6 +2973,10 @@ struct TargetProtocolConformanceDescriptor final
   size_t numTrailingObjects(OverloadToken<GenericWitnessTable>) const {
     return Flags.hasGenericWitnessTable() ? 1 : 0;
   }
+
+  size_t numTrailingObjects(OverloadToken<RelativeDirectPointer<const char, /*nullable*/ true>>) const {
+    return Flags.hasGlobalActorIsolation() ? 1 : 0;
+  }
 };
 using ProtocolConformanceDescriptor
   = TargetProtocolConformanceDescriptor<InProcess>;

include/swift/ABI/MetadataValues.h

@@ -709,6 +709,7 @@ class ConformanceFlags {
     HasResilientWitnessesMask = 0x01u << 16,
     HasGenericWitnessTableMask = 0x01u << 17,
     IsConformanceOfProtocolMask = 0x01u << 18,
+    HasGlobalActorIsolation = 0x01u << 19,
 
     NumConditionalPackDescriptorsMask = 0xFFu << 24,
     NumConditionalPackDescriptorsShift = 24
@@ -768,6 +769,14 @@ class ConformanceFlags {
                                  : 0));
   }
 
+  ConformanceFlags withHasGlobalActorIsolation(
+                                           bool hasGlobalActorIsolation) const {
+    return ConformanceFlags((Value & ~HasGlobalActorIsolation)
+                            | (hasGlobalActorIsolation
+                                 ? HasGlobalActorIsolation
+                                 : 0));
+  }
+  
   /// Retrieve the type reference kind kind.
   TypeReferenceKind getTypeReferenceKind() const {
     return TypeReferenceKind(
@@ -806,7 +815,12 @@ class ConformanceFlags {
   bool isConformanceOfProtocol() const {
     return Value & IsConformanceOfProtocolMask;
   }
-  
+
+  /// Does this conformance have a global actor to which it is isolated?
+  bool hasGlobalActorIsolation() const {
+    return Value & HasGlobalActorIsolation;
+  }
+
   /// Retrieve the # of conditional requirements.
   unsigned getNumConditionalRequirements() const {
     return (Value & NumConditionalRequirementsMask)

lib/IRGen/GenProto.cpp

@@ -30,6 +30,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/CanTypeVisitor.h"
 #include "swift/AST/Types.h"
+#include "swift/AST/ConformanceLookup.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsIRGen.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -93,6 +94,11 @@
 using namespace swift;
 using namespace irgen;
 
+namespace swift {
+  // FIXME: Move this on to ProtocolConformance?
+  ActorIsolation getConformanceIsolation(ProtocolConformance *conformance);
+}
+
 namespace {
 
 /// A class for computing how to pass arguments to a polymorphic
@@ -2164,6 +2170,7 @@ namespace {
       addConditionalRequirements();
       addResilientWitnesses();
       addGenericWitnessTable();
+      addGlobalActorIsolation();
 
       // We fill the flags last, since we continue filling them in
       // after the call to addFlags() deposits the placeholder.
@@ -2200,6 +2207,7 @@ namespace {
         Flags = Flags.withIsRetroactive(conf->isRetroactive());
         Flags = Flags.withIsSynthesizedNonUnique(conf->isSynthesizedNonUnique());
         Flags = Flags.withIsConformanceOfProtocol(conf->isConformanceOfProtocol());
+        Flags = Flags.withHasGlobalActorIsolation(conf->isIsolated());
       } else {
         Flags = Flags.withIsRetroactive(false)
                      .withIsSynthesizedNonUnique(false);
@@ -2387,6 +2395,42 @@ namespace {
         B.addRelativeAddress(privateData);
       }
     }
+
+    void addGlobalActorIsolation() {
+      if (!Flags.hasGlobalActorIsolation())
+        return;
+
+      auto normal = cast<NormalProtocolConformance>(Conformance);
+      assert(normal->isIsolated());
+      auto nominal = normal->getDeclContext()->getSelfNominalTypeDecl();
+
+      // Add global actor type.
+      auto sig = nominal->getGenericSignatureOfContext();
+      auto isolation = getConformanceIsolation(
+          const_cast<RootProtocolConformance *>(Conformance));
+      assert(isolation.isGlobalActor());
+      Type globalActorType = isolation.getGlobalActor();
+      auto globalActorTypeName = IGM.getTypeRef(
+          globalActorType, sig, MangledTypeRefRole::Metadata).first;
+      B.addRelativeAddress(globalActorTypeName);
+
+      // Add conformance of the global actor type to the GlobalActor protocol.
+      SmallVector<ProtocolConformance *, 1> globalActorConformances;
+      auto globalActorProtocol =
+          IGM.Context.getProtocol(KnownProtocolKind::GlobalActor);
+      auto globalActorConformance = lookupConformance(
+          globalActorType, globalActorProtocol);
+
+      auto rootGlobalActorConformance = globalActorConformance.getConcrete()
+        ->getRootConformance();
+      IGM.IRGen.addLazyWitnessTable(rootGlobalActorConformance);
+
+      auto globalActorConformanceDescriptor =
+          IGM.getAddrOfLLVMVariableOrGOTEquivalent(
+            LinkEntity::forProtocolConformanceDescriptor(
+              rootGlobalActorConformance));
+      B.addRelativeAddress(globalActorConformanceDescriptor);
+    }
   };
 }
 

stdlib/public/Concurrency/Task.swift

@@ -1518,6 +1518,15 @@ func _taskIsCurrentExecutor(_ executor: Builtin.Executor) -> Bool
 internal func _taskIsCurrentExecutor(
   executor: Builtin.Executor, flags: UInt64) -> Bool
 
+extension GlobalActor {
+  @available(SwiftStdlib 6.2, *)
+  @_silgen_name("swift_task_isCurrentGlobalActor")
+  @usableFromInline
+  internal static func _taskIsCurrentGlobalActor() -> Bool {
+    let executor = unsafe sharedUnownedExecutor
+    return unsafe _taskIsCurrentExecutor(executor: executor.executor, flags: 0)
+  }
+}
 #endif
 
 @available(SwiftStdlib 5.1, *)

stdlib/public/runtime/ProtocolConformance.cpp

@@ -1154,6 +1154,50 @@ swift_conformsToProtocolMaybeInstantiateSuperclasses(
   return {foundWitness, hasUninstantiatedSuperclass};
 }
 
+/// Determine if
+static bool isExecutingInIsolationOfConformance(
+    const Metadata *const type,
+    const ProtocolConformanceDescriptor *description,
+    const WitnessTable *table
+) {
+  // Resolve the global actor type.
+  SubstGenericParametersFromMetadata substitutions(type);
+  auto result = swift_getTypeByMangledName(
+     MetadataState::Abstract, description->getGlobalActorType(),
+     /*FIXME:conditionalArgs.data()*/{ },
+     [&substitutions](unsigned depth, unsigned index) {
+        return substitutions.getMetadata(depth, index).Ptr;
+      },
+    [&substitutions](const Metadata *type, unsigned index) {
+      return substitutions.getWitnessTable(type, index);
+    });
+  if (result.isError())
+    return false;
+
+  const Metadata *globalActorType = result.getType().getMetadata();
+  if (!globalActorType)
+    return false;
+
+  auto globalActorConformance = description->getGlobalActorConformance();
+  if (!globalActorConformance)
+    return false;
+
+  auto globalActorWitnessTable =
+      globalActorConformance->getWitnessTable(globalActorType);
+  if (!globalActorWitnessTable)
+    return false;
+
+  // The concurrency library provides a function to check whether we
+  // are executing on the given global actor.
+  auto isCurrentGlobalActor = SWIFT_LAZY_CONSTANT(reinterpret_cast<bool (*)(const Metadata *, const WitnessTable *)>(
+      dlsym(RTLD_DEFAULT, "swift_task_isCurrentGlobalActor")));
+  if (!isCurrentGlobalActor)
+    return false;
+
+  // Check whether we are running on this global actor.
+  return isCurrentGlobalActor(globalActorType, globalActorWitnessTable);
+}
+
 static const WitnessTable *
 swift_conformsToProtocolCommonImpl(const Metadata *const type,
                                    const ProtocolDescriptor *protocol) {
@@ -1178,6 +1222,18 @@ swift_conformsToProtocolCommonImpl(const Metadata *const type,
         swift_conformsToProtocolMaybeInstantiateSuperclasses(
             type, protocol, true /*instantiateSuperclassMetadata*/);
 
+  // If the conformance is isolated to a global actor, check whether we are
+  // currently executing on that global actor. Otherwise, the type does not
+  // conform.
+  if (table) {
+    if (auto description = table->getDescription()) {
+      if (description->hasGlobalActorIsolation() &&
+          !isExecutingInIsolationOfConformance(type, description, table)) {
+        return nullptr;
+      }
+    }
+  }
+
   return table;
 }
 

test/Concurrency/Runtime/isolated_conformance.swift

@@ -0,0 +1,79 @@
+// RUN: %target-run-simple-swift(-enable-experimental-feature IsolatedConformances -target %target-swift-5.1-abi-triple) | %FileCheck %s
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: concurrency_runtime
+// REQUIRES: swift_feature_IsolatedConformances
+// UNSUPPORTED: back_deployment_runtime
+
+protocol P {
+  func f()
+}
+
+@MainActor
+class MyClass: isolated P {
+  func f() {
+    print("MyClass.f()")
+
+    // Make sure we're on the main actor.
+    MainActor.assumeIsolated { }
+  }
+}
+
+struct Wrapper<T> {
+  var wrapped: T
+}
+
+extension Wrapper: P where T: P {
+  func f() {
+    print("Wrapper for ", terminator: "")
+    wrapped.f()
+  }
+}
+
+func tryCastToP(_ value: any Sendable) -> Bool {
+  if let p = value as? any P {
+    p.f()
+    return true
+  }
+
+  print("Conformance did not match")
+  return false
+}
+
+// CHECK: Testing on the main actor
+// CHECK-NEXT: MyClass.f()
+// CHECK-NEXT: Wrapper for MyClass.f()
+print("Testing on the main actor")
+let mc = MyClass()
+let wrappedMC = Wrapper(wrapped: mc)
+precondition(tryCastToP(mc))
+precondition(tryCastToP(wrappedMC))
+
+// CHECK: Testing a separate task on the main actor
+// CHECK-NEXT: MyClass.f()
+// CHECK-NEXT: Wrapper for MyClass.f()
+print("Testing a separate task on the main actor")
+await Task.detached { @MainActor in
+  precondition(tryCastToP(mc))
+  precondition(tryCastToP(wrappedMC))
+}.value
+
+// FIXME: Currently not handling the wrapper case appropriately, because
+// we don't track whether we used an isolated conformance to satisfy another
+// conformance at runtime.
+
+// CHECK: Testing a separate task off the main actor
+print("Testing a separate task off the main actor")
+await Task.detached {
+  if #available(SwiftStdlib 6.2, *) {
+    precondition(!tryCastToP(mc))
+  // precondition(!tryCastToP(wrappedMC))
+  } else {
+    print("Cast succeeds, but shouldn't")
+    precondition(tryCastToP(mc))
+  }
+}.value
+
+// Ensure that we access mc later
+print(mc)

test/Concurrency/isolated_conformance.swift

@@ -1,6 +1,7 @@
 // RUN: %target-swift-frontend -typecheck -verify -target %target-swift-5.1-abi-triple -swift-version 6 -enable-experimental-feature IsolatedConformances %s
 
 // REQUIRES: swift_feature_IsolatedConformances
+// REQUIRES: concurrency
 
 protocol P {
   func f() // expected-note 2{{mark the protocol requirement 'f()' 'async' to allow actor-isolated conformances}}

test/IRGen/isolated_conformance.swift

@@ -0,0 +1,21 @@
+// RUN: %target-swift-frontend -primary-file %s -emit-ir -swift-version 6 -enable-experimental-feature IsolatedConformances | %FileCheck %s -DINT=i%target-ptrsize
+
+// REQUIRES: PTRSIZE=64
+// REQUIRES: concurrency
+// UNSUPPORTED: CPU=arm64e
+
+protocol P {
+  func f()
+}
+
+// CHECK-LABEL: @"$s20isolated_conformance1XVyxGAA1PAAMc" =
+// CHECK-SAME: ptr @"$s20isolated_conformance1PMp"
+// CHECK-SAME: ptr @"$s20isolated_conformance1XVMn"
+// CHECK-SAME: ptr @"$s20isolated_conformance1XVyxGAA1PAAWP
+// CHECK-SAME: i32 524288
+// CHECK-SAME: @"symbolic ScM"
+// CHECK-SAME: ptr @"$sScMs11GlobalActorsMc"
+@MainActor
+struct X<T>: isolated P {
+  func f() { }
+}