[Concurrency] Remove custom global executors from 6.2.

The custom global executors work is not landing in 6.2, so make
sure it isn't public there.

rdar://151147606

Author: al45tair

lib/SILGen/SILGenFunction.cpp

@@ -1387,28 +1387,6 @@ void SILGenFunction::emitArtificialTopLevel(Decl *mainDecl) {
   }
 }
 
-static bool isCreateExecutorsFunctionAvailable(SILGenModule &SGM) {
-  FuncDecl *createExecutorsFuncDecl = SGM.getCreateExecutors();
-  if (!createExecutorsFuncDecl)
-    return false;
-
-  auto &ctx = createExecutorsFuncDecl->getASTContext();
-
-  if (ctx.LangOpts.hasFeature(Feature::Embedded))
-    return true;
-
-  if (!ctx.LangOpts.DisableAvailabilityChecking) {
-    auto deploymentAvailability = AvailabilityRange::forDeploymentTarget(ctx);
-    auto runtimeAvailability = AvailabilityRange::forRuntimeTarget(ctx);
-    auto declAvailability = ctx.getCustomGlobalExecutorsAvailability();
-    auto declRtAvailability = ctx.getCustomGlobalExecutorsRuntimeAvailability();
-    return deploymentAvailability.isContainedIn(declAvailability)
-      && runtimeAvailability.isContainedIn(declRtAvailability);
-  }
-
-  return true;
-}
-
 void SILGenFunction::emitAsyncMainThreadStart(SILDeclRef entryPoint) {
   auto moduleLoc = entryPoint.getAsRegularLocation();
   auto *entryBlock = B.getInsertionBB();
@@ -1424,46 +1402,6 @@ void SILGenFunction::emitAsyncMainThreadStart(SILDeclRef entryPoint) {
 
   B.setInsertionPoint(entryBlock);
 
-  // If we're using a new enough deployment target, and we can find a
-  // DefaultExecutorFactory type, call swift_createExecutors()
-  Type factoryNonCanTy = SGM.getConfiguredExecutorFactory();
-
-  if (isCreateExecutorsFunctionAvailable(SGM) && factoryNonCanTy) {
-    CanType factoryTy = factoryNonCanTy->getCanonicalType();
-
-    ProtocolDecl *executorFactoryProtocol
-      = ctx.getProtocol(KnownProtocolKind::ExecutorFactory);
-    auto conformance = lookupConformance(factoryTy, executorFactoryProtocol);
-
-    if (conformance.isInvalid()) {
-      // If this type doesn't conform, ignore it and use the default factory
-      SourceLoc loc = extractNearestSourceLoc(factoryTy);
-
-      ctx.Diags.diagnose(loc, diag::executor_factory_must_conform);
-
-      factoryTy = SGM.getDefaultExecutorFactory()->getCanonicalType();
-      conformance = lookupConformance(factoryTy, executorFactoryProtocol);
-
-      assert(!conformance.isInvalid());
-    }
-
-    FuncDecl *createExecutorsFuncDecl = SGM.getCreateExecutors();
-    assert(createExecutorsFuncDecl
-           && "Failed to find swift_createExecutors function decl");
-    SILFunction *createExecutorsSILFunc =
-      SGM.getFunction(SILDeclRef(createExecutorsFuncDecl, SILDeclRef::Kind::Func),
-                        NotForDefinition);
-    SILValue createExecutorsFunc =
-      B.createFunctionRefFor(moduleLoc, createExecutorsSILFunc);
-    MetatypeType *factoryThickMetaTy
-      = MetatypeType::get(factoryTy, MetatypeRepresentation::Thick);
-    SILValue factorySILMetaTy
-      = B.createMetatype(moduleLoc, getLoweredType(factoryThickMetaTy));
-    auto ceSubs = SubstitutionMap::getProtocolSubstitutions(
-      conformance.getProtocol(), factoryTy, conformance);
-    B.createApply(moduleLoc, createExecutorsFunc, ceSubs, { factorySILMetaTy });
-  }
-
   auto wrapCallArgs = [this, &moduleLoc](SILValue originalValue, FuncDecl *fd,
                             uint32_t paramIndex) -> SILValue {
     Type parameterType = fd->getParameters()->get(paramIndex)->getTypeInContext();

stdlib/public/Concurrency/CFExecutor.swift

@@ -44,7 +44,7 @@ enum CoreFoundation {
 // .. Main Executor ............................................................
 
 @available(StdlibDeploymentTarget 6.2, *)
-public final class CFMainExecutor: DispatchMainExecutor, @unchecked Sendable {
+final class CFMainExecutor: DispatchMainExecutor, @unchecked Sendable {
 
   override public func run() throws {
     CoreFoundation.CFRunLoopRun()
@@ -59,8 +59,8 @@ public final class CFMainExecutor: DispatchMainExecutor, @unchecked Sendable {
 // .. Task Executor ............................................................
 
 @available(StdlibDeploymentTarget 6.2, *)
-public final class CFTaskExecutor: DispatchGlobalTaskExecutor,
-                                   @unchecked Sendable {
+final class CFTaskExecutor: DispatchGlobalTaskExecutor,
+                            @unchecked Sendable {
 
 }
 

stdlib/public/Concurrency/Clock.swift

@@ -41,50 +41,6 @@ public protocol Clock<Duration>: Sendable {
 #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   func sleep(until deadline: Instant, tolerance: Instant.Duration?) async throws
 #endif
-
-  /// The traits associated with this clock instance.
-  @available(StdlibDeploymentTarget 6.2, *)
-  var traits: ClockTraits { get }
-
-  /// Convert a Clock-specific Duration to a Swift Duration
-  ///
-  /// Some clocks may define `C.Duration` to be something other than a
-  /// `Swift.Duration`, but that makes it tricky to convert timestamps
-  /// between clocks, which is something we want to be able to support.
-  /// This method will convert whatever `C.Duration` is to a `Swift.Duration`.
-  ///
-  /// Parameters:
-  ///
-  /// - from duration: The `Duration` to convert
-  ///
-  /// Returns: A `Swift.Duration` representing the equivalent duration, or
-  ///          `nil` if this function is not supported.
-  @available(StdlibDeploymentTarget 6.2, *)
-  func convert(from duration: Duration) -> Swift.Duration?
-
-  /// Convert a Swift Duration to a Clock-specific Duration
-  ///
-  /// Parameters:
-  ///
-  /// - from duration: The `Swift.Duration` to convert.
-  ///
-  /// Returns: A `Duration` representing the equivalent duration, or
-  ///          `nil` if this function is not supported.
-  @available(StdlibDeploymentTarget 6.2, *)
-  func convert(from duration: Swift.Duration) -> Duration?
-
-  /// Convert an `Instant` from some other clock's `Instant`
-  ///
-  /// Parameters:
-  ///
-  /// - instant:    The instant to convert.
-  //  - from clock: The clock to convert from.
-  ///
-  /// Returns: An `Instant` representing the equivalent instant, or
-  ///          `nil` if this function is not supported.
-  @available(StdlibDeploymentTarget 6.2, *)
-  func convert<OtherClock: Clock>(instant: OtherClock.Instant,
-                                  from clock: OtherClock) -> Instant?
 }
 
 @available(StdlibDeploymentTarget 5.7, *)
@@ -140,44 +96,6 @@ extension Clock {
   }
 }
 
-@available(StdlibDeploymentTarget 6.2, *)
-extension Clock {
-  // For compatibility, return `nil` if this is not implemented
-  public func convert(from duration: Duration) -> Swift.Duration? {
-    return nil
-  }
-
-  public func convert(from duration: Swift.Duration) -> Duration? {
-    return nil
-  }
-
-  public func convert<OtherClock: Clock>(instant: OtherClock.Instant,
-                                  from clock: OtherClock) -> Instant? {
-    let ourNow = now
-    let otherNow = clock.now
-    let otherDuration = otherNow.duration(to: instant)
-
-    // Convert to `Swift.Duration`
-    guard let duration = clock.convert(from: otherDuration) else {
-      return nil
-    }
-
-    // Convert from `Swift.Duration`
-    guard let ourDuration = convert(from: duration) else {
-      return nil
-    }
-
-    return ourNow.advanced(by: ourDuration)
-  }
-}
-
-@available(StdlibDeploymentTarget 6.2, *)
-extension Clock where Duration == Swift.Duration {
-  public func convert(from duration: Duration) -> Duration? {
-    return duration
-  }
-}
-
 #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 @available(StdlibDeploymentTarget 5.7, *)
 extension Clock {
@@ -196,44 +114,6 @@ extension Clock {
 }
 #endif
 
-/// Represents traits of a particular Clock implementation.
-///
-/// Clocks may be of a number of different varieties; executors will likely
-/// have specific clocks that they can use to schedule jobs, and will
-/// therefore need to be able to convert timestamps to an appropriate clock
-/// when asked to enqueue a job with a delay or deadline.
-///
-/// Choosing a clock in general requires the ability to tell which of their
-/// clocks best matches the clock that the user is trying to specify a
-/// time or delay in.  Executors are expected to do this on a best effort
-/// basis.
-@available(StdlibDeploymentTarget 6.2, *)
-public struct ClockTraits: OptionSet {
-  public let rawValue: UInt32
-
-  public init(rawValue: UInt32) {
-    self.rawValue = rawValue
-  }
-
-  /// Clocks with this trait continue running while the machine is asleep.
-  public static let continuous = ClockTraits(rawValue: 1 << 0)
-
-  /// Indicates that a clock's time will only ever increase.
-  public static let monotonic = ClockTraits(rawValue: 1 << 1)
-
-  /// Clocks with this trait are tied to "wall time".
-  public static let wallTime = ClockTraits(rawValue: 1 << 2)
-}
-
-@available(StdlibDeploymentTarget 6.2, *)
-extension Clock {
-  /// The traits associated with this clock instance.
-  @available(StdlibDeploymentTarget 6.2, *)
-  public var traits: ClockTraits {
-    return []
-  }
-}
-
 enum _ClockID: Int32 {
   case continuous = 1
   case suspending = 2

stdlib/public/Concurrency/ContinuousClock.swift

@@ -100,12 +100,6 @@ extension ContinuousClock: Clock {
     )
   }
 
-  /// The continuous clock is continuous and monotonic
-  @available(StdlibDeploymentTarget 6.2, *)
-  public var traits: ClockTraits {
-    return [.continuous, .monotonic]
-  }
-
 #if !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
   /// Suspend task execution until a given deadline within a tolerance.
   /// If no tolerance is specified then the system may adjust the deadline

stdlib/public/Concurrency/CooperativeExecutor.swift

@@ -193,7 +193,11 @@ extension CooperativeExecutor: SchedulableExecutor {
                                 after delay: C.Duration,
                                 tolerance: C.Duration? = nil,
                                 clock: C) {
-    let duration = Duration(from: clock.convert(from: delay)!)
+    guard let swiftDuration = delay as? Swift.Duration else {
+      fatalError("Unsupported clock")
+    }
+
+    let duration = Duration(from: swiftDuration)
     let deadline = self.currentTime + duration
 
     job.setupCooperativeExecutorTimestamp()

stdlib/public/Concurrency/DispatchExecutor.swift

@@ -24,7 +24,7 @@ import Swift
 // .. Main Executor ............................................................
 
 @available(StdlibDeploymentTarget 6.2, *)
-public class DispatchMainExecutor: RunLoopExecutor, @unchecked Sendable {
+class DispatchMainExecutor: RunLoopExecutor, @unchecked Sendable {
   var threaded = false
 
   public init() {}
@@ -91,8 +91,8 @@ extension DispatchMainExecutor: MainExecutor {}
 // .. Task Executor ............................................................
 
 @available(StdlibDeploymentTarget 6.2, *)
-public class DispatchGlobalTaskExecutor: TaskExecutor, SchedulableExecutor,
-                                         @unchecked Sendable {
+class DispatchGlobalTaskExecutor: TaskExecutor, SchedulableExecutor,
+                                  @unchecked Sendable {
   public init() {}
 
   public func enqueue(_ job: consuming ExecutorJob) {
@@ -172,28 +172,30 @@ extension DispatchExecutorProtocol {
 
   func timestamp<C: Clock>(for instant: C.Instant, clock: C)
     -> (clockID: DispatchClockID, seconds: Int64, nanoseconds: Int64) {
-    if clock.traits.contains(.continuous) {
-        let dispatchClock: ContinuousClock = .continuous
-        let instant = dispatchClock.convert(instant: instant, from: clock)!
-        let (seconds, attoseconds) = clamp(instant._value.components)
-        let nanoseconds = attoseconds / 1_000_000_000
-        return (clockID: .continuous,
-                seconds: Int64(seconds),
-                nanoseconds: Int64(nanoseconds))
+    if clock is ContinuousClock {
+      let instant = instant as! ContinuousClock.Instant
+      let (seconds, attoseconds) = clamp(instant._value.components)
+      let nanoseconds = attoseconds / 1_000_000_000
+      return (clockID: .continuous,
+              seconds: Int64(seconds),
+              nanoseconds: Int64(nanoseconds))
+    } else if clock is SuspendingClock {
+      let instant = instant as! SuspendingClock.Instant
+      let (seconds, attoseconds) = clamp(instant._value.components)
+      let nanoseconds = attoseconds / 1_000_000_000
+      return (clockID: .suspending,
+              seconds: Int64(seconds),
+              nanoseconds: Int64(nanoseconds))
     } else {
-        let dispatchClock: SuspendingClock = .suspending
-        let instant = dispatchClock.convert(instant: instant, from: clock)!
-        let (seconds, attoseconds) = clamp(instant._value.components)
-        let nanoseconds = attoseconds / 1_000_000_000
-        return (clockID: .suspending,
-                seconds: Int64(seconds),
-                nanoseconds: Int64(nanoseconds))
+      fatalError("Unknown clock")
     }
   }
 
   func delay<C: Clock>(from duration: C.Duration, clock: C)
     -> (seconds: Int64, nanoseconds: Int64) {
-    let swiftDuration = clock.convert(from: duration)!
+    guard let swiftDuration = duration as? Swift.Duration else {
+      fatalError("Unsupported clock")
+    }
     let (seconds, attoseconds) = clamp(swiftDuration.components)
     let nanoseconds = attoseconds / 1_000_000_000
     return (seconds: seconds, nanoseconds: nanoseconds)