mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
1a1f79c0de
Introduce checking of ConcurrentValue conformances: - For structs, check that each stored property conforms to ConcurrentValue - For enums, check that each associated value conforms to ConcurrentValue - For classes, check that each stored property is immutable and conforms to ConcurrentValue Because all of the stored properties / associated values need to be visible for this check to work, limit ConcurrentValue conformances to be in the same source file as the type definition. This checking can be disabled by conforming to a new marker protocol, UnsafeConcurrentValue, that refines ConcurrentValue. UnsafeConcurrentValue otherwise his no specific meaning. This allows both "I know what I'm doing" for types that manage concurrent access themselves as well as enabling retroactive conformance, both of which are fundamentally unsafe but also quite necessary. The bulk of this change ended up being to the standard library, because all conformances of standard library types to the ConcurrentValue protocol needed to be sunk down into the standard library so they would benefit from the checking above. There were numerous little mistakes in the initial pass through the stsandard library types that have now been corrected.
117 lines
3.7 KiB
Swift
117 lines
3.7 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// A unique identifier for a class instance or metatype.
|
|
///
|
|
/// This unique identifier is only valid for comparisons during the lifetime
|
|
/// of the instance.
|
|
///
|
|
/// In Swift, only class instances and metatypes have unique identities. There
|
|
/// is no notion of identity for structs, enums, functions, or tuples.
|
|
@frozen // trivial-implementation
|
|
public struct ObjectIdentifier: ConcurrentValue {
|
|
@usableFromInline // trivial-implementation
|
|
internal let _value: Builtin.RawPointer
|
|
|
|
/// Creates an instance that uniquely identifies the given class instance.
|
|
///
|
|
/// The following example creates an example class `IntegerRef` and compares
|
|
/// instances of the class using their object identifiers and the identical-to
|
|
/// operator (`===`):
|
|
///
|
|
/// class IntegerRef {
|
|
/// let value: Int
|
|
/// init(_ value: Int) {
|
|
/// self.value = value
|
|
/// }
|
|
/// }
|
|
///
|
|
/// let x = IntegerRef(10)
|
|
/// let y = x
|
|
///
|
|
/// print(ObjectIdentifier(x) == ObjectIdentifier(y))
|
|
/// // Prints "true"
|
|
/// print(x === y)
|
|
/// // Prints "true"
|
|
///
|
|
/// let z = IntegerRef(10)
|
|
/// print(ObjectIdentifier(x) == ObjectIdentifier(z))
|
|
/// // Prints "false"
|
|
/// print(x === z)
|
|
/// // Prints "false"
|
|
///
|
|
/// - Parameter x: An instance of a class.
|
|
@inlinable // trivial-implementation
|
|
public init(_ x: AnyObject) {
|
|
self._value = Builtin.bridgeToRawPointer(x)
|
|
}
|
|
|
|
/// Creates an instance that uniquely identifies the given metatype.
|
|
///
|
|
/// - Parameter: A metatype.
|
|
@inlinable // trivial-implementation
|
|
public init(_ x: Any.Type) {
|
|
self._value = unsafeBitCast(x, to: Builtin.RawPointer.self)
|
|
}
|
|
}
|
|
|
|
extension ObjectIdentifier: CustomDebugStringConvertible {
|
|
/// A textual representation of the identifier, suitable for debugging.
|
|
public var debugDescription: String {
|
|
return "ObjectIdentifier(\(_rawPointerToString(_value)))"
|
|
}
|
|
}
|
|
|
|
extension ObjectIdentifier: Equatable {
|
|
@inlinable // trivial-implementation
|
|
public static func == (x: ObjectIdentifier, y: ObjectIdentifier) -> Bool {
|
|
return Bool(Builtin.cmp_eq_RawPointer(x._value, y._value))
|
|
}
|
|
}
|
|
|
|
extension ObjectIdentifier: Comparable {
|
|
@inlinable // trivial-implementation
|
|
public static func < (lhs: ObjectIdentifier, rhs: ObjectIdentifier) -> Bool {
|
|
return UInt(bitPattern: lhs) < UInt(bitPattern: rhs)
|
|
}
|
|
}
|
|
|
|
extension ObjectIdentifier: Hashable {
|
|
/// Hashes the essential components of this value by feeding them into the
|
|
/// given hasher.
|
|
///
|
|
/// - Parameter hasher: The hasher to use when combining the components
|
|
/// of this instance.
|
|
@inlinable
|
|
public func hash(into hasher: inout Hasher) {
|
|
hasher.combine(Int(Builtin.ptrtoint_Word(_value)))
|
|
}
|
|
}
|
|
|
|
extension UInt {
|
|
/// Creates an integer that captures the full value of the given object
|
|
/// identifier.
|
|
@inlinable // trivial-implementation
|
|
public init(bitPattern objectID: ObjectIdentifier) {
|
|
self.init(Builtin.ptrtoint_Word(objectID._value))
|
|
}
|
|
}
|
|
|
|
extension Int {
|
|
/// Creates an integer that captures the full value of the given object
|
|
/// identifier.
|
|
@inlinable // trivial-implementation
|
|
public init(bitPattern objectID: ObjectIdentifier) {
|
|
self.init(bitPattern: UInt(bitPattern: objectID))
|
|
}
|
|
}
|