Sink ConcurrentValue into the standard library as a marker protocol

By making ConcurrentValue a marker protocol, it no longer has any ABI
impact whatsoever. Sink it down into the Standard Library so it's
easier to use, even from code that isn't building with concurrency
enabled.

Author: DougGregor

lib/AST/ASTContext.cpp

@@ -971,7 +971,6 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
     M = getLoadedModule(Id_Differentiation);
     break;
   case KnownProtocolKind::Actor:
-  case KnownProtocolKind::ConcurrentValue:
   case KnownProtocolKind::AsyncSequence:
   case KnownProtocolKind::AsyncIteratorProtocol:
     M = getLoadedModule(Id_Concurrency);

stdlib/public/Concurrency/CMakeLists.txt

@@ -37,7 +37,6 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   Actor.cpp
   Actor.swift
   CheckedContinuation.swift
-  ConcurrentValue.swift
   GlobalExecutor.cpp
   AsyncIteratorProtocol.swift
   AsyncSequence.swift

stdlib/public/core/CMakeLists.txt

@@ -45,6 +45,7 @@ set(SWIFTLIB_ESSENTIAL
   CollectionAlgorithms.swift
   Comparable.swift
   CompilerProtocols.swift
+  ConcurrentValue.swift
   ContiguousArray.swift
   ContiguouslyStored.swift
   ClosedRange.swift

stdlib/public/Concurrency/ConcurrentValue.swift renamed to stdlib/public/core/ConcurrentValue.swift

@@ -14,7 +14,7 @@ import Swift
 
 /// The ConcurrentValue protocol indicates that value of the given type can
 /// be safely used in concurrent code.
-public protocol ConcurrentValue { }
+@_marker public protocol ConcurrentValue { }
 
 extension Array: ConcurrentValue where Element: ConcurrentValue { }
 extension ArraySlice: ConcurrentValue where Element: ConcurrentValue { }
@@ -115,40 +115,13 @@ extension Mirror: ConcurrentValue { }
 extension Mirror.AncestorRepresentation: ConcurrentValue { }
 extension Mirror.DisplayStyle: ConcurrentValue { }
 
-// FIXME: Float16 when available
-extension Float: ConcurrentValue { }
-extension Double: ConcurrentValue { }
-// FIXME: Float80 when available
-
-// FIXME: hacks to enumerate integer types, and ".Words", and "SIMDnStorage"
-extension UInt8: ConcurrentValue { }
-extension Int8: ConcurrentValue { }
-extension UInt16: ConcurrentValue { }
-extension Int16: ConcurrentValue { }
-extension UInt32: ConcurrentValue { }
-extension Int32: ConcurrentValue { }
-extension UInt64: ConcurrentValue { }
-extension Int64: ConcurrentValue { }
-extension UInt: ConcurrentValue { }
-extension Int: ConcurrentValue { }
-
 extension UnsafeMutableBufferPointer: ConcurrentValue { }
 extension UnsafeBufferPointer: ConcurrentValue { }
 extension UnsafeBufferPointer.Iterator: ConcurrentValue { }
 extension UnsafeMutableRawBufferPointer: ConcurrentValue { }
 extension UnsafeRawBufferPointer: ConcurrentValue { }
 extension UnsafeRawBufferPointer.Iterator: ConcurrentValue { }
 
-extension SIMDMask: ConcurrentValue where Storage: ConcurrentValue { }
-// FIXME: enumerate SIMD types
-extension SIMD2: ConcurrentValue where Scalar: ConcurrentValue { }
-extension SIMD3: ConcurrentValue where Scalar: ConcurrentValue { }
-extension SIMD4: ConcurrentValue where Scalar: ConcurrentValue { }
-extension SIMD8: ConcurrentValue where Scalar: ConcurrentValue { }
-extension SIMD16: ConcurrentValue where Scalar: ConcurrentValue { }
-extension SIMD32: ConcurrentValue where Scalar: ConcurrentValue { }
-extension SIMD64: ConcurrentValue where Scalar: ConcurrentValue { }
-
 extension PartialKeyPath: ConcurrentValue where Root: ConcurrentValue { }
 
 extension FloatingPointSign: ConcurrentValue { }
@@ -158,4 +131,3 @@ extension FloatingPointRoundingRule: ConcurrentValue { }
 extension Optional: ConcurrentValue where Wrapped: ConcurrentValue { }
 extension Never: ConcurrentValue { }
 extension Result: ConcurrentValue where Success: ConcurrentValue, Failure: ConcurrentValue { }
-

stdlib/public/core/FloatingPointTypes.swift.gyb

@@ -1343,6 +1343,9 @@ internal struct _${Self}AnyHashableBox: _AnyHashableBox {
 }
 % end
 
+${Availability(bits)}
+extension ${Self} : ConcurrentValue { }
+
 //===----------------------------------------------------------------------===//
 // Deprecated operators
 //===----------------------------------------------------------------------===//

stdlib/public/core/GroupInfo.json

@@ -199,6 +199,7 @@
   ],
   "Misc": [
     "AtomicInt.swift",
+    "ConcurrentValue.swift",
     "ErrorType.swift",
     "Identifiable.swift",
     "InputStream.swift",

stdlib/public/core/IntegerTypes.swift.gyb

@@ -1399,7 +1399,7 @@ ${assignmentOperatorComment(x.operator, True)}
 
   /// A type that represents the words of this integer.
   @frozen
-  public struct Words: RandomAccessCollection {
+  public struct Words: RandomAccessCollection, ConcurrentValue {
     public typealias Indices = Range<Int>
     public typealias SubSequence = Slice<${Self}.Words>
 
@@ -1709,6 +1709,8 @@ ${operatorComment(x.operator, True)}
 }
 
 
+extension ${Self}: ConcurrentValue { }
+
 % if signed:
 // TODO: Consider removing the underscore.
 /// Returns the argument and specifies that the value is not negative.

stdlib/public/core/SIMDVectorTypes.swift.gyb

@@ -186,6 +186,8 @@ extension SIMD${n} where Scalar: BinaryFloatingPoint {
   }
 }
 
+extension SIMD${n}: ConcurrentValue where Scalar: ConcurrentValue { }
+
 %end
 
 extension SIMD3 {
@@ -217,7 +219,7 @@ extension ${Self}: SIMDScalar {
   /// Storage for a vector of ${spelledNumbers[n]} integers.
   @frozen
   @_alignment(${bytes if bytes <= 16 else 16})
-  public struct SIMD${n}Storage: SIMDStorage {
+  public struct SIMD${n}Storage: SIMDStorage, ConcurrentValue {
 
     public var _value: Builtin.Vec${n}x${BuiltinName}
 
@@ -266,7 +268,7 @@ extension ${Self} : SIMDScalar {
   /// Storage for a vector of ${spelledNumbers[n]} floating-point values.
   @frozen
   @_alignment(${bytes if bytes <= 16 else 16})
-  public struct SIMD${n}Storage: SIMDStorage {
+  public struct SIMD${n}Storage: SIMDStorage, ConcurrentValue {
 
     public var _value: Builtin.Vec${n}xFPIEEE${bits}