Shift operators to concrete Instant types to avoid complexity in solver resolution

Author: phausler

stdlib/public/Concurrency/ContinuousClock.swift

@@ -94,4 +94,44 @@ extension ContinuousClock.Instant: InstantProtocol {
   ) -> Bool {
     return lhs._value < rhs._value
   }
+
+  @_alwaysEmitIntoClient
+  @inlinable  
+  public static func + (
+    _ lhs: ContinuousClock.Instant, _ rhs: Duration
+  ) -> ContinuousClock.Instant {
+    lhs.advanced(by: rhs)
+  }
+  
+  @_alwaysEmitIntoClient
+  @inlinable
+  public static func += (
+    _ lhs: inout ContinuousClock.Instant, _ rhs: Duration
+  ) {
+    lhs = lhs.advanced(by: rhs)
+  }
+  
+  @_alwaysEmitIntoClient
+  @inlinable
+  public static func - (
+    _ lhs: ContinuousClock.Instant, _ rhs: Duration
+  ) -> ContinuousClock.Instant {
+    lhs.advanced(by: .zero - rhs)
+  }
+  
+  @_alwaysEmitIntoClient
+  @inlinable
+  public static func -= (
+    _ lhs: inout ContinuousClock.Instant, _ rhs: Duration
+  ) {
+    lhs = lhs.advanced(by: .zero - rhs)
+  }
+  
+  @_alwaysEmitIntoClient
+  @inlinable
+  public static func - (
+    _ lhs: ContinuousClock.Instant, _ rhs: ContinuousClock.Instant
+  ) -> Duration {
+    rhs.duration(to: lhs)
+  }
 }

stdlib/public/Concurrency/SuspendingClock.swift

@@ -41,7 +41,7 @@ extension SuspendingClock: Clock {
     _getClockRes(
       seconds: &seconds, 
       nanoseconds: &nanoseconds, 
-      clock: .continuous)
+      clock: .suspending)
     return SuspendingClock.Instant(_value:
       .seconds(seconds) + .nanoseconds(nanoseconds))
   }
@@ -52,7 +52,7 @@ extension SuspendingClock: Clock {
     _getClockRes(
       seconds: &seconds, 
       nanoseconds: &nanoseconds, 
-      clock: .continuous)
+      clock: .suspending)
     return .seconds(seconds) + .nanoseconds(nanoseconds)
   }
 
@@ -93,5 +93,45 @@ extension SuspendingClock.Instant: InstantProtocol {
   ) -> Bool {
     return lhs._value < rhs._value
   }
+  
+  @_alwaysEmitIntoClient
+  @inlinable  
+  public static func + (
+    _ lhs: SuspendingClock.Instant, _ rhs: Duration
+  ) -> SuspendingClock.Instant {
+    lhs.advanced(by: rhs)
+  }
+  
+  @_alwaysEmitIntoClient
+  @inlinable
+  public static func += (
+    _ lhs: inout SuspendingClock.Instant, _ rhs: Duration
+  ) {
+    lhs = lhs.advanced(by: rhs)
+  }
+  
+  @_alwaysEmitIntoClient
+  @inlinable
+  public static func - (
+    _ lhs: SuspendingClock.Instant, _ rhs: Duration
+  ) -> SuspendingClock.Instant {
+    lhs.advanced(by: .zero - rhs)
+  }
+  
+  @_alwaysEmitIntoClient
+  @inlinable
+  public static func -= (
+    _ lhs: inout SuspendingClock.Instant, _ rhs: Duration
+  ) {
+    lhs = lhs.advanced(by: .zero - rhs)
+  }
+  
+  @_alwaysEmitIntoClient
+  @inlinable
+  public static func - (
+    _ lhs: SuspendingClock.Instant, _ rhs: SuspendingClock.Instant
+  ) -> Duration {
+    rhs.duration(to: lhs)
+  }
 }
 

stdlib/public/core/Instant.swift

@@ -16,25 +16,37 @@ public protocol InstantProtocol: Comparable, Hashable, Sendable {
   func duration(to other: Self) -> Interval
 }
 
+/*
+disabled for now - this perturbs operator resolution 
 extension InstantProtocol {
+  @_alwaysEmitIntoClient
+  @inlinable  
   public static func + (_ lhs: Self, _ rhs: Interval) -> Self {
     lhs.advanced(by: rhs)
   }
 
+  @_alwaysEmitIntoClient
+  @inlinable
   public static func += (_ lhs: inout Self, _ rhs: Interval) {
     lhs = lhs.advanced(by: rhs)
   }
 
+  @_alwaysEmitIntoClient
+  @inlinable
   public static func - (_ lhs: Self, _ rhs: Interval) -> Self {
     lhs.advanced(by: .zero - rhs)
   }
 
+  @_alwaysEmitIntoClient
+  @inlinable
   public static func -= (_ lhs: inout Self, _ rhs: Interval) {
     lhs = lhs.advanced(by: .zero - rhs)
   }
 
+  @_alwaysEmitIntoClient
+  @inlinable
   public static func - (_ lhs: Self, _ rhs: Self) -> Interval {
     rhs.duration(to: lhs)
   }
 }
-
+*/