[TaskLocals] remove TaskLocalInheritance, we'll introduce when needed

Author: ktoso

include/swift/ABI/Task.h

@@ -222,9 +222,8 @@ class AsyncTask : public Job {
     Local.pushValue(this, key, value, valueType);
   }
 
-  OpaqueValue* localValueGet(const HeapObject *key,
-                             TaskLocal::TaskLocalInheritance inherit) {
-    return Local.getValue(this, key, inherit);
+  OpaqueValue* localValueGet(const HeapObject *key) {
+    return Local.getValue(this, key);
   }
 
   void localValuePop() {

include/swift/ABI/TaskLocal.h

@@ -46,28 +46,6 @@ class TaskLocal {
     IsParent = 0b01,
   };
 
-  /// Values must match `TaskLocalInheritance` declared in `TaskLocal.swift`.
-  enum class TaskLocalInheritance : uint8_t {
-    /// Default task local value behavior
-    ///
-    /// Values declared with a default-inherited key are accessible from:
-    /// - the current task that has bound the value,
-    /// - any child task of the current task (e.g. created by async let or groups)
-    ///
-    /// Such values are *not* carried through detached tasks.
-    Default = 0,
-
-    /// Special semantics which confine a task's local value to *only* the current
-    /// task. In other words, they ave never inherited by any child task created
-    /// by the current task.
-    ///
-    /// Values declared with a never-inherited key only accessible:
-    /// - specifically from the current task itself
-    ///
-    /// Such values are *not* accessible from child tasks or detached tasks.
-    Never = 1
-  };
-
   class Item {
   private:
     /// Mask used for the low status bits in a task local chain item.
@@ -204,9 +182,7 @@ class TaskLocal {
                    const HeapObject *key,
                    /* +1 */ OpaqueValue *value, const Metadata *valueType);
 
-    OpaqueValue* getValue(AsyncTask *task,
-                          const HeapObject *key,
-                          TaskLocalInheritance inheritance);
+    OpaqueValue* getValue(AsyncTask *task, const HeapObject *key);
 
     void popValue(AsyncTask *task);
 

include/swift/Runtime/Concurrency.h

@@ -359,15 +359,12 @@ void swift_task_reportIllegalTaskLocalBindingWithinWithTaskGroup(
 /// \code
 /// func _taskLocalValueGet<Key>(
 ///   _ task: Builtin.NativeObject,
-///   keyType: Any.Type /*Key.Type*/,
-///   inheritance: UInt8/*TaskLocalInheritance*/
+///   keyType: Any.Type /*Key.Type*/
 /// ) -> UnsafeMutableRawPointer? where Key: TaskLocalKey
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 OpaqueValue*
-swift_task_localValueGet(AsyncTask* task,
-                         const HeapObject *key,
-                         TaskLocal::TaskLocalInheritance inheritance);
+swift_task_localValueGet(AsyncTask* task, const HeapObject *key);
 
 /// Add a task local value to the passed in task.
 ///

stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def

@@ -200,9 +200,8 @@ OVERRIDE_TASK_LOCAL(task_localValuePush, void,
 OVERRIDE_TASK_LOCAL(task_localValueGet, OpaqueValue *,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                     swift::,
-                    (AsyncTask *task, const HeapObject *key,
-                     TaskLocal::TaskLocalInheritance inheritance),
-                    (task, key, inheritance))
+                    (AsyncTask *task, const HeapObject *key),
+                    (task, key))
 
 OVERRIDE_TASK_LOCAL(task_localValuePop, void,
                     SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),

stdlib/public/Concurrency/Task.cpp

@@ -35,7 +35,6 @@
 using namespace swift;
 using FutureFragment = AsyncTask::FutureFragment;
 using TaskGroup = swift::TaskGroup;
-using TaskLocalInheritance = TaskLocal::TaskLocalInheritance;
 
 void FutureFragment::destroy() {
   auto queueHead = waitQueue.load(std::memory_order_acquire);

stdlib/public/Concurrency/TaskLocal.cpp

@@ -41,9 +41,8 @@ static void swift_task_localValuePushImpl(AsyncTask *task,
 
 SWIFT_CC(swift)
 static OpaqueValue* swift_task_localValueGetImpl(AsyncTask *task,
-                                                 const HeapObject *key,
-                                                 TaskLocal::TaskLocalInheritance inheritance) {
-  return task->localValueGet(key, inheritance);
+                                                 const HeapObject *key) {
+  return task->localValueGet(key);
 }
 
 SWIFT_CC(swift)
@@ -249,8 +248,7 @@ void TaskLocal::Storage::popValue(AsyncTask *task) {
 }
 
 OpaqueValue* TaskLocal::Storage::getValue(AsyncTask *task,
-                                          const HeapObject *key,
-                                          const TaskLocalInheritance inherit) {
+                                          const HeapObject *key) {
   assert(key && "TaskLocal key must not be null.");
 
   auto item = head;
@@ -259,12 +257,6 @@ OpaqueValue* TaskLocal::Storage::getValue(AsyncTask *task,
       return item->getStoragePtr();
     }
 
-    // if the key is an `inherit = .never` type, we stop our search the first
-    // time we would be jumping to a parent task to continue the search.
-    if (item->getNextLinkType() == NextLinkType::IsParent &&
-        inherit == TaskLocalInheritance::Never)
-      return nullptr;
-
     item = item->getNext();
   }
 

stdlib/public/Concurrency/TaskLocal.swift

@@ -19,17 +19,10 @@ import Swift
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
 public final class TaskLocal<Value>: CustomStringConvertible {
   var defaultValue: Value
-  var inherit: TaskLocalInheritance
 
   // Note: could overload with additional parameters to support other features
   public init(wrappedValue: Value) {
     self.defaultValue = wrappedValue
-    self.inherit = .default
-  }
-
-  public init(wrappedValue: Value, inherit: TaskLocalInheritance) {
-    self.defaultValue = wrappedValue
-    self.inherit = inherit
   }
 
   public var wrappedValue: Value {
@@ -40,7 +33,7 @@ public final class TaskLocal<Value>: CustomStringConvertible {
         }
 
         let value = _taskLocalValueGet(
-            task._task, key: unsafeBitCast(self, to: Builtin.RawPointer.self), inheritance: inherit.rawValue)
+            task._task, key: unsafeBitCast(self, to: Builtin.RawPointer.self))
 
         guard let rawValue = value else {
           return self.defaultValue
@@ -63,6 +56,7 @@ public final class TaskLocal<Value>: CustomStringConvertible {
     self
   }
 
+  /// Execute the `body` closure
   @discardableResult
   public func withValue<R>(_ valueDuringBody: Value, do body: () async throws -> R,
                            file: String = #file, line: UInt = #line) async rethrows -> R {
@@ -87,55 +81,6 @@ public final class TaskLocal<Value>: CustomStringConvertible {
 
 }
 
-/// A `TaskLocalKey` is used to identify, bind and get a task local value from
-/// a `Task` in which a function is currently executing.
-///
-/// - SeeAlso: `Task.withLocal(_:boundTo:operation:)`
-/// - SeeAlso: `TaskLocal(_:)`
-@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
-public protocol TaskLocalKey {
-  /// The type of `Value` uniquely identified by this key.
-  associatedtype Value
-
-  /// If a task local value is not present in a given context, its `defaultValue`
-  /// will be returned instead.
-  ///
-  /// A common pattern is to use an `Optional<T>` type and use `nil` as default value,
-  /// if the type itself does not have a good "undefined" or "zero" value that could
-  /// be used here.
-  static var defaultValue: Value { get }
-
-  /// Allows configuring specialized inheritance strategies for task local values.
-  ///
-  /// By default, task local values are accessible by the current or any of its
-  /// child tasks (with this rule applying recursively).
-  ///
-  /// Some, rare yet important, use-cases may require specialized inheritance
-  /// strategies, and this property allows them to configure these for their keys.
-  static var inherit: TaskLocalInheritance { get }
-}
-
-@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
-extension TaskLocalKey {
-  public static var inherit: TaskLocalInheritance { .default }
-}
-
-/// Determines task local value behavior in child tasks.
-// TODO: should likely remain extensible
-@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
-public enum TaskLocalInheritance: UInt8, Equatable {
-  /// The default inheritance strategy.
-  ///
-  /// Task local values whose keys are `default` inherited are available to the
-  /// task which declared them, as well as recursively by any child tasks
-  case `default` = 0
-
-  /// Causes task local values to never be inherited.
-  /// If the parent task has a value bound using this key, and a child task
-  /// attempts to look up a value of that key, it will return `defaultValue`.
-  case never = 1
-}
-
 // ==== ------------------------------------------------------------------------
 
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
@@ -156,8 +101,7 @@ public func _taskLocalValuePop(
 @_silgen_name("swift_task_localValueGet")
 public func _taskLocalValueGet(
   _ task: Builtin.NativeObject,
-  key: Builtin.RawPointer/*Key*/,
-  inheritance: UInt8/*TaskLocalInheritance*/
+  key: Builtin.RawPointer/*Key*/
 ) -> UnsafeMutableRawPointer? // where Key: TaskLocal
 
 // ==== Checks -----------------------------------------------------------------

test/Concurrency/Runtime/async_task_locals_inherit_never.swift

@@ -13,10 +13,6 @@ enum TL {
   @TaskLocal
   @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
   static var number: Int  = 0
-
-  @TaskLocal(inherit: .never)
-  @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
-  static var string: String = "<unknown>"
 }
 
 @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)

test/Concurrency/Runtime/async_task_locals_wrapper.swift

@@ -213,8 +213,7 @@ TEST_F(CompatibilityOverrideConcurrencyTest, test_swifttask_localValuePush) {
 }
 
 TEST_F(CompatibilityOverrideConcurrencyTest, test_swift_task_localValueGet) {
-  swift_task_localValueGet(nullptr, nullptr,
-                           swift::TaskLocal::TaskLocalInheritance());
+  swift_task_localValueGet(nullptr, nullptr);
 }
 
 TEST_F(CompatibilityOverrideConcurrencyTest, test_swift_task_localValuePop) {