mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
32ff6de1cb
With more recent versions of LLVM (e.g., used with master-next) the argument of REQUIRES is parsed as an expression. Do not use "rdar" URLS for these since it confuses lit.
888 lines
31 KiB
Swift
888 lines
31 KiB
Swift
// RUN: rm -rf %t && mkdir -p %t
|
|
// RUN: %target-build-swift %s -Xfrontend -enable-experimental-keypaths -o %t/a.out
|
|
// RUN: %target-run %t/a.out
|
|
// REQUIRES: executable_test
|
|
// REQUIRES: PTRSIZE=64
|
|
|
|
// Disabled for now
|
|
// REQUIRES: rdar31776015
|
|
|
|
|
|
import StdlibUnittest
|
|
|
|
var keyPathImpl = TestSuite("key path implementation")
|
|
|
|
class C<T> {
|
|
var x: Int
|
|
var y: LifetimeTracked?
|
|
var z: T
|
|
|
|
init(x: Int, y: LifetimeTracked?, z: T) {
|
|
self.x = x
|
|
self.y = y
|
|
self.z = z
|
|
}
|
|
}
|
|
|
|
struct Point: Equatable {
|
|
var x: Double
|
|
var y: Double
|
|
var trackLifetime = LifetimeTracked(123)
|
|
|
|
init(x: Double, y: Double) {
|
|
self.x = x
|
|
self.y = y
|
|
}
|
|
|
|
static func ==(a: Point, b: Point) -> Bool {
|
|
return a.x == b.x && a.y == b.y
|
|
}
|
|
}
|
|
|
|
struct S<T: Equatable>: Equatable {
|
|
var x: Int
|
|
var y: LifetimeTracked?
|
|
var z: T
|
|
var p: Point
|
|
var c: C<T>
|
|
|
|
static func ==(a: S, b: S) -> Bool {
|
|
return a.x == b.x
|
|
&& a.y === b.y
|
|
&& a.z == b.z
|
|
&& a.p == b.p
|
|
&& a.c === b.c
|
|
}
|
|
}
|
|
|
|
class Oroborous {
|
|
var o: Oroborous
|
|
|
|
init() { fatalError() }
|
|
}
|
|
|
|
struct CratePair<T, U> {
|
|
var left: Crate<T>
|
|
var right: Crate<U>
|
|
}
|
|
class Crate<T> {
|
|
var value: T
|
|
|
|
init(value: T) { self.value = value }
|
|
}
|
|
|
|
// Helper to build keypaths with specific layouts
|
|
struct TestKeyPathBuilder {
|
|
var buffer: UnsafeMutableRawBufferPointer
|
|
var state: State = .header
|
|
var hasReferencePrefix = false
|
|
|
|
init(buffer: UnsafeMutableRawBufferPointer) {
|
|
self.buffer = buffer
|
|
}
|
|
|
|
enum State {
|
|
case header, component, type
|
|
|
|
mutating func advance() {
|
|
switch self {
|
|
case .header, .type: self = .component
|
|
case .component: self = .type
|
|
}
|
|
}
|
|
}
|
|
|
|
func finish() {
|
|
assert(buffer.count == 0,
|
|
"Did not fill entire buffer")
|
|
assert(state == .type, "should end expecting a type")
|
|
assert(!hasReferencePrefix, "unterminated reference prefix")
|
|
}
|
|
|
|
mutating func push(_ value: UInt32) {
|
|
assert(buffer.count >= 4, "not enough room")
|
|
buffer.storeBytes(of: value, as: UInt32.self)
|
|
buffer = .init(start: buffer.baseAddress! + 4, count: buffer.count - 4)
|
|
}
|
|
|
|
mutating func addHeader(trivial: Bool, hasReferencePrefix: Bool) {
|
|
assert(state == .header, "not expecting a header")
|
|
let size = buffer.count - 4
|
|
assert(buffer.count > 0 && buffer.count <= 0x3FFF_FFFF,
|
|
"invalid buffer size")
|
|
let header: UInt32 = UInt32(size)
|
|
| (trivial ? 0x8000_0000 : 0)
|
|
| (hasReferencePrefix ? 0x4000_0000 : 0)
|
|
push(header)
|
|
self.hasReferencePrefix = hasReferencePrefix
|
|
state.advance()
|
|
}
|
|
|
|
mutating func addOffsetComponent(offset: Int,
|
|
kindMask: UInt32,
|
|
forceOverflow: Bool,
|
|
endsReferencePrefix: Bool) {
|
|
assert(state == .component, "not expecting a component")
|
|
assert(offset >= 0 && offset <= 0x7FFF_FFFF,
|
|
"invalid offset")
|
|
let referencePrefixMask: UInt32 = endsReferencePrefix ? 0x8000_0000 : 0
|
|
if forceOverflow || offset >= 0x1FFF_FFFF {
|
|
// Offset is overflowed into another word
|
|
push(referencePrefixMask | kindMask | 0x1FFF_FFFF)
|
|
push(UInt32(offset))
|
|
} else {
|
|
// Offset is packed in-line
|
|
push(referencePrefixMask | kindMask | UInt32(offset))
|
|
}
|
|
if endsReferencePrefix {
|
|
assert(hasReferencePrefix, "ending nonexistent reference prefix")
|
|
hasReferencePrefix = false
|
|
}
|
|
state.advance()
|
|
}
|
|
|
|
mutating func addStructComponent(offset: Int,
|
|
forceOverflow: Bool = false,
|
|
endsReferencePrefix: Bool = false) {
|
|
addOffsetComponent(offset: offset, kindMask: 0,
|
|
forceOverflow: forceOverflow,
|
|
endsReferencePrefix: endsReferencePrefix)
|
|
}
|
|
|
|
mutating func addClassComponent(offset: Int,
|
|
forceOverflow: Bool = false,
|
|
endsReferencePrefix: Bool = false) {
|
|
addOffsetComponent(offset: offset, kindMask: 0x4000_0000,
|
|
forceOverflow: forceOverflow,
|
|
endsReferencePrefix: endsReferencePrefix)
|
|
}
|
|
|
|
mutating func addType(_ type: Any.Type) {
|
|
assert(state == .type, "not expecting a type")
|
|
if MemoryLayout<Int>.size == 8 {
|
|
// Components are 4-byte aligned, but pointers are 8-byte aligned, so
|
|
// we have to store word-by-word
|
|
let words = unsafeBitCast(type, to: (UInt32, UInt32).self)
|
|
push(words.0)
|
|
push(words.1)
|
|
} else if MemoryLayout<Int>.size == 4 {
|
|
let word = unsafeBitCast(type, to: UInt32.self)
|
|
push(word)
|
|
} else {
|
|
fatalError("unsupported architecture")
|
|
}
|
|
state.advance()
|
|
}
|
|
}
|
|
|
|
// FIXME: Should return Self, but the closure specializer doesn't like that.
|
|
// rdar://problem/31725007
|
|
extension AnyKeyPath {
|
|
static func build(capacityInBytes: Int,
|
|
withBuilder: (inout TestKeyPathBuilder) -> Void) -> AnyKeyPath {
|
|
return _create(capacityInBytes: capacityInBytes) {
|
|
var builder = TestKeyPathBuilder(buffer: $0)
|
|
withBuilder(&builder)
|
|
builder.finish()
|
|
}
|
|
}
|
|
}
|
|
|
|
keyPathImpl.test("struct components") {
|
|
let intSize = MemoryLayout<Int>.size
|
|
let stringSize = MemoryLayout<String>.size
|
|
let s_x = WritableKeyPath<S<String>, Int>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: 0)
|
|
} as! WritableKeyPath<S<String>, Int>
|
|
|
|
let s_y = WritableKeyPath<S<String>, LifetimeTracked?>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: intSize)
|
|
} as! WritableKeyPath<S<String>, LifetimeTracked?>
|
|
|
|
let s_z = WritableKeyPath<S<String>, String>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: intSize*2)
|
|
} as! WritableKeyPath<S<String>, String>
|
|
|
|
let s_p = WritableKeyPath<S<String>, Point>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
} as! WritableKeyPath<S<String>, Point>
|
|
|
|
let twoComponentSize = 12 + intSize
|
|
let s_p_x = WritableKeyPath<S<String>, Double>
|
|
.build(capacityInBytes: twoComponentSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
$0.addStructComponent(offset: 0)
|
|
} as! WritableKeyPath<S<String>, Double>
|
|
|
|
let s_p_y = WritableKeyPath<S<String>, Double>
|
|
.build(capacityInBytes: twoComponentSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
$0.addStructComponent(offset: MemoryLayout<Double>.size)
|
|
} as! WritableKeyPath<S<String>, Double>
|
|
|
|
|
|
// \("") forces the string to be computed at runtime (and therefore allocated)
|
|
let c = C(x: 679, y: nil, z: "buffalo\("")")
|
|
var value = S(x: 1738, y: nil, z: "bottles of beer\("")",
|
|
p: .init(x: 0.5, y: -0.5), c: c)
|
|
expectEqual(value[keyPath: s_x], 1738)
|
|
value[keyPath: s_x] = 679
|
|
expectEqual(value[keyPath: s_x], 679)
|
|
|
|
expectTrue(value[keyPath: s_y] === nil)
|
|
|
|
let object1 = LifetimeTracked(1739)
|
|
value[keyPath: s_y] = object1
|
|
expectTrue(value[keyPath: s_y] === object1)
|
|
expectTrue(value.y === object1)
|
|
|
|
let object2 = LifetimeTracked(1740)
|
|
value[keyPath: s_y] = object2
|
|
expectTrue(value[keyPath: s_y] === object2)
|
|
expectTrue(value.y === object2)
|
|
|
|
expectEqual(value[keyPath: s_z], "bottles of beer")
|
|
value[keyPath: s_z] = "cans of lemonade\("")"
|
|
expectEqual(value[keyPath: s_z], "cans of lemonade")
|
|
expectEqual(value.z, "cans of lemonade")
|
|
|
|
expectEqual(value[keyPath: s_p], Point(x: 0.5, y: -0.5))
|
|
expectEqual(value.p, Point(x: 0.5, y: -0.5))
|
|
expectEqual(value[keyPath: s_p_x], 0.5)
|
|
expectEqual(value.p.x, 0.5)
|
|
expectEqual(value[keyPath: s_p_y], -0.5)
|
|
expectEqual(value.p.y, -0.5)
|
|
|
|
value[keyPath: s_p] = Point(x: -3.0, y: 4.0)
|
|
expectEqual(value[keyPath: s_p], Point(x: -3.0, y: 4.0))
|
|
expectEqual(value.p, Point(x: -3.0, y: 4.0))
|
|
expectEqual(value[keyPath: s_p_x], -3.0)
|
|
expectEqual(value.p.x, -3.0)
|
|
expectEqual(value[keyPath: s_p_y], 4.0)
|
|
expectEqual(value.p.y, 4.0)
|
|
|
|
value[keyPath: s_p_x] = 5.0
|
|
expectEqual(value[keyPath: s_p], Point(x: 5.0, y: 4.0))
|
|
expectEqual(value.p, Point(x: 5.0, y: 4.0))
|
|
expectEqual(value[keyPath: s_p_x], 5.0)
|
|
expectEqual(value.p.x, 5.0)
|
|
expectEqual(value[keyPath: s_p_y], 4.0)
|
|
expectEqual(value.p.y, 4.0)
|
|
|
|
value[keyPath: s_p_y] = -11.0
|
|
expectEqual(value[keyPath: s_p], Point(x: 5.0, y: -11.0))
|
|
expectEqual(value.p, Point(x: 5.0, y: -11.0))
|
|
expectEqual(value[keyPath: s_p_x], 5.0)
|
|
expectEqual(value.p.x, 5.0)
|
|
expectEqual(value[keyPath: s_p_y], -11.0)
|
|
expectEqual(value.p.y, -11.0)
|
|
|
|
value[keyPath: s_p].x = 65.0
|
|
expectEqual(value[keyPath: s_p], Point(x: 65.0, y: -11.0))
|
|
expectEqual(value.p, Point(x: 65.0, y: -11.0))
|
|
expectEqual(value[keyPath: s_p_x], 65.0)
|
|
expectEqual(value.p.x, 65.0)
|
|
expectEqual(value[keyPath: s_p_y], -11.0)
|
|
expectEqual(value.p.y, -11.0)
|
|
}
|
|
|
|
keyPathImpl.test("class components") {
|
|
let intSize = MemoryLayout<Int>.size
|
|
let classHeaderSize = intSize * 2
|
|
|
|
let c_x = ReferenceWritableKeyPath<C<String>, Int>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
} as! ReferenceWritableKeyPath<C<String>, Int>
|
|
|
|
let c_y = ReferenceWritableKeyPath<C<String>, LifetimeTracked?>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addClassComponent(offset: classHeaderSize + intSize)
|
|
} as! ReferenceWritableKeyPath<C<String>, LifetimeTracked?>
|
|
|
|
let c_z = ReferenceWritableKeyPath<C<String>, String>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addClassComponent(offset: classHeaderSize + 2*intSize)
|
|
} as! ReferenceWritableKeyPath<C<String>, String>
|
|
|
|
let c = C(x: 679, y: nil, z: "buffalo\("")")
|
|
let value = c
|
|
|
|
expectEqual(value[keyPath: c_x], 679)
|
|
value[keyPath: c_x] = 1738
|
|
expectEqual(value[keyPath: c_x], 1738)
|
|
expectEqual(value.x, 1738)
|
|
|
|
expectTrue(value[keyPath: c_y] === nil)
|
|
|
|
let object1 = LifetimeTracked(680)
|
|
value[keyPath: c_y] = object1
|
|
expectTrue(value[keyPath: c_y] === object1)
|
|
expectTrue(value.y === object1)
|
|
|
|
let object2 = LifetimeTracked(681)
|
|
value[keyPath: c_y] = object2
|
|
expectTrue(value[keyPath: c_y] === object2)
|
|
expectTrue(value.y === object2)
|
|
|
|
expectEqual(value[keyPath: c_z], "buffalo")
|
|
value[keyPath: c_z] = "water buffalo\("")"
|
|
expectEqual(value[keyPath: c_z], "water buffalo")
|
|
expectEqual(value.z, "water buffalo")
|
|
|
|
var mutValue = value
|
|
let value_c_x: WritableKeyPath = c_x
|
|
let value_c_y: WritableKeyPath = c_y
|
|
|
|
expectEqual(value[keyPath: value_c_x], 1738)
|
|
mutValue[keyPath: value_c_x] = 86
|
|
expectTrue(value === mutValue)
|
|
expectEqual(value[keyPath: c_x], 86)
|
|
expectEqual(value[keyPath: value_c_x], 86)
|
|
expectEqual(value.x, 86)
|
|
|
|
expectTrue(value[keyPath: value_c_y] === object2)
|
|
mutValue[keyPath: value_c_y] = object1
|
|
expectTrue(value === mutValue)
|
|
expectTrue(value[keyPath: c_y] === object1)
|
|
expectTrue(value[keyPath: value_c_y] === object1)
|
|
expectTrue(value.y === object1)
|
|
}
|
|
|
|
keyPathImpl.test("reference prefix") {
|
|
let intSize = MemoryLayout<Int>.size
|
|
let stringSize = MemoryLayout<String>.size
|
|
let pointSize = MemoryLayout<Point>.size
|
|
let classHeaderSize = intSize * 2
|
|
|
|
let s_c_x = ReferenceWritableKeyPath<S<String>, Int>
|
|
.build(capacityInBytes: 12 + intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize + pointSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<String>.self)
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
} as! ReferenceWritableKeyPath<S<String>, Int>
|
|
|
|
let s_c_y = ReferenceWritableKeyPath<S<String>, LifetimeTracked?>
|
|
.build(capacityInBytes: 12 + intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize + pointSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<String>.self)
|
|
$0.addClassComponent(offset: classHeaderSize + intSize)
|
|
} as! ReferenceWritableKeyPath<S<String>, LifetimeTracked?>
|
|
|
|
let s_c_z = ReferenceWritableKeyPath<S<String>, String>
|
|
.build(capacityInBytes: 12 + intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize + pointSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<String>.self)
|
|
$0.addClassComponent(offset: classHeaderSize + 2*intSize)
|
|
} as! ReferenceWritableKeyPath<S<String>, String>
|
|
|
|
let c = C(x: 679, y: nil, z: "buffalo\("")")
|
|
let value = S(x: 1738, y: nil, z: "bottles of beer\("")",
|
|
p: .init(x: 0.5, y: -0.5), c: c)
|
|
|
|
expectEqual(value[keyPath: s_c_x], 679)
|
|
value[keyPath: s_c_x] = 6
|
|
expectEqual(value[keyPath: s_c_x], 6)
|
|
expectEqual(value.c.x, 6)
|
|
expectTrue(value.c.y === nil)
|
|
expectEqual(value.c.z, "buffalo")
|
|
|
|
let object1 = LifetimeTracked(7)
|
|
let object2 = LifetimeTracked(8)
|
|
expectTrue(value[keyPath: s_c_y] === nil)
|
|
|
|
value[keyPath: s_c_y] = object1
|
|
expectTrue(value[keyPath: s_c_y] === object1)
|
|
expectTrue(value.c.y === object1)
|
|
expectEqual(value.c.x, 6)
|
|
expectEqual(value.c.z, "buffalo")
|
|
|
|
value[keyPath: s_c_y] = object2
|
|
expectTrue(value[keyPath: s_c_y] === object2)
|
|
expectTrue(value.c.y === object2)
|
|
expectEqual(value.c.x, 6)
|
|
expectEqual(value.c.z, "buffalo")
|
|
|
|
expectEqual(value[keyPath: s_c_z], "buffalo")
|
|
value[keyPath: s_c_z] = "antelope"
|
|
expectTrue(value[keyPath: s_c_z] == "antelope")
|
|
expectTrue(value.c.z == "antelope")
|
|
expectEqual(value.c.x, 6)
|
|
expectTrue(value.c.y === object2)
|
|
|
|
let value_s_c_x: WritableKeyPath = s_c_x
|
|
let value_s_c_y: WritableKeyPath = s_c_y
|
|
let value_s_c_z: WritableKeyPath = s_c_z
|
|
|
|
var mutValue = value
|
|
|
|
mutValue[keyPath: value_s_c_x] = 7
|
|
expectEqual(value, mutValue)
|
|
expectEqual(value[keyPath: s_c_x], 7)
|
|
expectEqual(value.c.x, 7)
|
|
expectTrue(value.c.y === object2)
|
|
expectEqual(value.c.z, "antelope")
|
|
|
|
mutValue[keyPath: value_s_c_y] = object1
|
|
expectEqual(value, mutValue)
|
|
expectTrue(value[keyPath: s_c_y] === object1)
|
|
expectTrue(value.c.y === object1)
|
|
expectEqual(value.c.x, 7)
|
|
expectEqual(value.c.z, "antelope")
|
|
|
|
mutValue[keyPath: value_s_c_z] = "elk"
|
|
expectEqual(value, mutValue)
|
|
expectTrue(value[keyPath: s_c_z] == "elk")
|
|
expectTrue(value.c.z == "elk")
|
|
expectEqual(value.c.x, 7)
|
|
expectTrue(value.c.y === object1)
|
|
}
|
|
|
|
keyPathImpl.test("overflowed offsets") {
|
|
let intSize = MemoryLayout<Int>.size
|
|
let stringSize = MemoryLayout<String>.size
|
|
let classHeaderSize = intSize * 2
|
|
|
|
let s_p = WritableKeyPath<S<String>, Point>
|
|
.build(capacityInBytes: 12) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize,
|
|
forceOverflow: true)
|
|
} as! WritableKeyPath<S<String>, Point>
|
|
|
|
let c_z = ReferenceWritableKeyPath<C<String>, String>
|
|
.build(capacityInBytes: 12) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addClassComponent(offset: classHeaderSize + 2*intSize,
|
|
forceOverflow: true)
|
|
} as! ReferenceWritableKeyPath<C<String>, String>
|
|
|
|
let c = C(x: 679, y: LifetimeTracked(42), z: "buffalo\("")")
|
|
var sValue = S(x: 1738, y: LifetimeTracked(43),
|
|
z: "bottles of beer\("")",
|
|
p: .init(x: 0.5, y: -0.5), c: c)
|
|
let cValue = c
|
|
|
|
expectEqual(sValue[keyPath: s_p], Point(x: 0.5, y: -0.5))
|
|
sValue[keyPath: s_p] = Point(x: 1.0, y: -1.0)
|
|
expectEqual(sValue.p, Point(x: 1.0, y: -1.0))
|
|
expectEqual(sValue[keyPath: s_p], Point(x: 1.0, y: -1.0))
|
|
|
|
expectEqual(cValue[keyPath: c_z], "buffalo")
|
|
cValue[keyPath: c_z] = "dik dik"
|
|
expectEqual(cValue.z, "dik dik")
|
|
expectEqual(cValue[keyPath: c_z], "dik dik")
|
|
}
|
|
|
|
keyPathImpl.test("equality") {
|
|
let intSize = MemoryLayout<Int>.size
|
|
let stringSize = MemoryLayout<String>.size
|
|
let ssSize = MemoryLayout<S<S<String>>>.size
|
|
let pointSize = MemoryLayout<Point>.size
|
|
let classHeaderSize = intSize * 2
|
|
|
|
let s_c_z_p_x = ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
.build(capacityInBytes: 20 + 3 * intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
// S<S<String>>.c
|
|
$0.addStructComponent(offset: intSize*2 + ssSize + pointSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<S<String>>.self)
|
|
// C<S<String>>.z
|
|
$0.addClassComponent(offset: classHeaderSize + intSize*2)
|
|
$0.addType(S<String>.self)
|
|
// S<String>.p
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
// Point.x
|
|
$0.addStructComponent(offset: 0)
|
|
} as! ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
|
|
expectEqual(s_c_z_p_x, s_c_z_p_x)
|
|
expectEqual(s_c_z_p_x.hashValue, s_c_z_p_x.hashValue)
|
|
|
|
// Structurally equivalent to s_c_z_p_x
|
|
let s_c_z_p_x_2 = ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
.build(capacityInBytes: 20 + 3 * intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
// S<S<String>>.c
|
|
$0.addStructComponent(offset: intSize*2 + ssSize + pointSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<S<String>>.self)
|
|
// C<S<String>>.z
|
|
$0.addClassComponent(offset: classHeaderSize + intSize*2)
|
|
$0.addType(S<String>.self)
|
|
// S<String>.p
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
// Point.x
|
|
$0.addStructComponent(offset: 0)
|
|
} as! ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
|
|
expectEqual(s_c_z_p_x, s_c_z_p_x_2)
|
|
expectEqual(s_c_z_p_x.hashValue, s_c_z_p_x_2.hashValue)
|
|
|
|
expectEqual(s_c_z_p_x_2, s_c_z_p_x)
|
|
expectEqual(s_c_z_p_x_2.hashValue, s_c_z_p_x.hashValue)
|
|
|
|
// Structurally equivalent, force-overflowed offset components
|
|
let s_c_z_p_x_3 = ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
.build(capacityInBytes: 36 + 3 * intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
// S<S<String>>.c
|
|
$0.addStructComponent(offset: intSize*2 + ssSize + pointSize,
|
|
forceOverflow: true,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<S<String>>.self)
|
|
// C<S<String>>.z
|
|
$0.addClassComponent(offset: classHeaderSize + intSize*2,
|
|
forceOverflow: true)
|
|
$0.addType(S<String>.self)
|
|
// S<String>.p
|
|
$0.addStructComponent(offset: intSize*2 + stringSize,
|
|
forceOverflow: true)
|
|
$0.addType(Point.self)
|
|
// Point.x
|
|
$0.addStructComponent(offset: 0,
|
|
forceOverflow: true)
|
|
} as! ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
|
|
expectEqual(s_c_z_p_x, s_c_z_p_x_3)
|
|
expectEqual(s_c_z_p_x.hashValue, s_c_z_p_x_3.hashValue)
|
|
|
|
expectEqual(s_c_z_p_x_3, s_c_z_p_x)
|
|
expectEqual(s_c_z_p_x_3.hashValue, s_c_z_p_x.hashValue)
|
|
|
|
// Same path type, different suffixes
|
|
let s_c_z_p_y = ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
.build(capacityInBytes: 20 + 3 * intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
// S<S<String>>.c
|
|
$0.addStructComponent(offset: intSize*2 + ssSize + pointSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<S<String>>.self)
|
|
// C<S<String>>.z
|
|
$0.addClassComponent(offset: classHeaderSize + intSize*2)
|
|
$0.addType(S<String>.self)
|
|
// S<String>.p
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
// Point.y
|
|
$0.addStructComponent(offset: 8)
|
|
} as! ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
|
|
expectNotEqual(s_c_z_p_x, s_c_z_p_y)
|
|
expectNotEqual(s_c_z_p_y, s_c_z_p_x)
|
|
|
|
// Different path type
|
|
let s_c_z_p = ReferenceWritableKeyPath<S<S<String>>, Point>
|
|
.build(capacityInBytes: 16 + 2 * intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
// S<S<String>>.c
|
|
$0.addStructComponent(offset: intSize*2 + ssSize + pointSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<S<String>>.self)
|
|
// C<S<String>>.z
|
|
$0.addClassComponent(offset: classHeaderSize + intSize*2)
|
|
$0.addType(S<String>.self)
|
|
// S<String>.p
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
} as! ReferenceWritableKeyPath<S<S<String>>, Point>
|
|
|
|
expectNotEqual(s_c_z_p_x, s_c_z_p)
|
|
expectNotEqual(s_c_z_p, s_c_z_p_x)
|
|
|
|
// Same path, no reference prefix
|
|
let s_c_z_p_x_readonly = KeyPath<S<S<String>>, Double>
|
|
.build(capacityInBytes: 20 + 3 * intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
// S<S<String>>.c
|
|
$0.addStructComponent(offset: intSize*2 + ssSize + pointSize)
|
|
$0.addType(C<S<String>>.self)
|
|
// C<S<String>>.z
|
|
$0.addClassComponent(offset: classHeaderSize + intSize*2)
|
|
$0.addType(S<String>.self)
|
|
// S<String>.p
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
// Point.x
|
|
$0.addStructComponent(offset: 0)
|
|
} as! KeyPath<S<S<String>>, Double>
|
|
|
|
expectNotEqual(s_c_z_p_x, s_c_z_p_x_readonly)
|
|
expectNotEqual(s_c_z_p_x_readonly, s_c_z_p_x)
|
|
|
|
// Same path type, different paths
|
|
let s_p_y_readonly = KeyPath<S<S<String>>, Double>
|
|
.build(capacityInBytes: 12 + intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
// S<S<String>>.p
|
|
$0.addStructComponent(offset: intSize*2 + ssSize)
|
|
$0.addType(Point.self)
|
|
// Point.y
|
|
$0.addStructComponent(offset: 8)
|
|
} as! KeyPath<S<S<String>>, Double>
|
|
|
|
expectNotEqual(s_p_y_readonly, s_c_z_p_x_readonly)
|
|
expectNotEqual(s_c_z_p_x_readonly, s_p_y_readonly)
|
|
|
|
let o_o_o_o = ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
.build(capacityInBytes: 16 + 2*intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
$0.addType(Oroborous.self)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
$0.addType(Oroborous.self)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
} as! ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
|
|
// Different reference prefix length
|
|
let o_o_o_o_rp1 = ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
.build(capacityInBytes: 16 + 2*intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(Oroborous.self)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
$0.addType(Oroborous.self)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
} as! ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
let o_o_o_o_rp2 = ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
.build(capacityInBytes: 16 + 2*intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
$0.addType(Oroborous.self)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(Oroborous.self)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
} as! ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
let o_o_o_o_rp2_2 = ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
.build(capacityInBytes: 16 + 2*intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
$0.addType(Oroborous.self)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(Oroborous.self)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
} as! ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
|
|
expectNotEqual(o_o_o_o, o_o_o_o_rp1)
|
|
expectNotEqual(o_o_o_o_rp1, o_o_o_o)
|
|
|
|
expectNotEqual(o_o_o_o_rp1, o_o_o_o_rp2)
|
|
expectNotEqual(o_o_o_o_rp2, o_o_o_o_rp1)
|
|
|
|
expectNotEqual(o_o_o_o, o_o_o_o_rp2)
|
|
expectNotEqual(o_o_o_o_rp2, o_o_o_o)
|
|
|
|
expectEqual(o_o_o_o_rp2, o_o_o_o_rp2_2)
|
|
expectEqual(o_o_o_o_rp2_2, o_o_o_o_rp2)
|
|
expectEqual(o_o_o_o_rp2.hashValue, o_o_o_o_rp2_2.hashValue)
|
|
|
|
// Same type, different length of components with same prefix
|
|
let o_o_o = ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
.build(capacityInBytes: 12 + intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
$0.addType(Oroborous.self)
|
|
// O.o
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
} as! ReferenceWritableKeyPath<Oroborous, Oroborous>
|
|
|
|
expectNotEqual(o_o_o, o_o_o_o)
|
|
expectNotEqual(o_o_o_o, o_o_o)
|
|
}
|
|
|
|
keyPathImpl.test("appending") {
|
|
let intSize = MemoryLayout<Int>.size
|
|
let stringSize = MemoryLayout<String>.size
|
|
let pointSize = MemoryLayout<Point>.size
|
|
let ssSize = MemoryLayout<S<String>>.size
|
|
let classHeaderSize = intSize * 2
|
|
|
|
let s_p = WritableKeyPath<S<String>, Point>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
} as! WritableKeyPath<S<String>, Point>
|
|
let p_y = WritableKeyPath<Point, Double>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: 8)
|
|
} as! WritableKeyPath<Point, Double>
|
|
|
|
let s_p_y = s_p.appending(path: p_y)
|
|
|
|
let c = C(x: 679, y: nil, z: "buffalo\("")")
|
|
var value = S(x: 1738, y: nil, z: "bottles of beer\("")",
|
|
p: .init(x: 0.5, y: -0.5), c: c)
|
|
|
|
expectEqual(value[keyPath: s_p_y], -0.5)
|
|
value[keyPath: s_p_y] = 4.0
|
|
expectEqual(value[keyPath: s_p_y], 4.0)
|
|
expectEqual(value.p.x, 0.5)
|
|
expectEqual(value.p.y, 4.0)
|
|
|
|
let s_p_y2 = s_p.appending(path: p_y)
|
|
expectEqual(s_p_y, s_p_y2)
|
|
expectEqual(s_p_y2, s_p_y)
|
|
expectEqual(s_p_y.hashValue, s_p_y2.hashValue)
|
|
|
|
let s_p_y_manual = WritableKeyPath<S<String>, Double>
|
|
.build(capacityInBytes: 12 + intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
$0.addStructComponent(offset: 8)
|
|
} as! WritableKeyPath<S<String>, Double>
|
|
expectEqual(s_p_y, s_p_y_manual)
|
|
expectEqual(s_p_y_manual, s_p_y)
|
|
expectEqual(s_p_y.hashValue, s_p_y_manual.hashValue)
|
|
|
|
let c_z = ReferenceWritableKeyPath<C<S<String>>, S<String>>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addClassComponent(offset: classHeaderSize + 2*intSize)
|
|
} as! ReferenceWritableKeyPath<C<S<String>>, S<String>>
|
|
|
|
let value2 = C(x: 17, y: LifetimeTracked(38), z: value)
|
|
|
|
let c_z_p_y = c_z.appending(path: s_p_y)
|
|
|
|
expectEqual(value2[keyPath: c_z_p_y], 4.0)
|
|
value2[keyPath: c_z_p_y] = 5.0
|
|
expectEqual(value2[keyPath: c_z_p_y], 5.0)
|
|
expectEqual(value2.z.p.y, 5.0)
|
|
expectEqual(value2.z.p.x, 0.5)
|
|
|
|
let c_z_p_y_manual = ReferenceWritableKeyPath<C<S<String>>, Double>
|
|
.build(capacityInBytes: 16 + intSize * 2) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addClassComponent(offset: classHeaderSize + 2*intSize)
|
|
$0.addType(S<String>.self)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
$0.addStructComponent(offset: 8)
|
|
} as! ReferenceWritableKeyPath<C<S<String>>, Double>
|
|
|
|
expectEqual(c_z_p_y, c_z_p_y_manual)
|
|
expectEqual(c_z_p_y_manual, c_z_p_y)
|
|
expectEqual(c_z_p_y.hashValue, c_z_p_y_manual.hashValue)
|
|
|
|
let s_c = WritableKeyPath<S<S<String>>, C<S<String>>>
|
|
.build(capacityInBytes: 8) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: false)
|
|
$0.addStructComponent(offset: intSize*2 + ssSize + pointSize)
|
|
} as! WritableKeyPath<S<S<String>>, C<S<String>>>
|
|
|
|
let s_c_z_p_y = s_c.appending(path: c_z_p_y)
|
|
|
|
let value3 = S(x: 679, y: nil, z: value,
|
|
p: value.p, c: value2)
|
|
expectEqual(value3[keyPath: s_c_z_p_y], 5.0)
|
|
value3[keyPath: s_c_z_p_y] = 11.0
|
|
expectEqual(value3[keyPath: s_c_z_p_y], 11.0)
|
|
expectEqual(value2[keyPath: c_z_p_y], 11.0)
|
|
|
|
let s_c_z_p_y_manual = ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
.build(capacityInBytes: 20 + intSize * 3) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
$0.addStructComponent(offset: intSize*2 + ssSize + pointSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<S<String>>.self)
|
|
$0.addClassComponent(offset: classHeaderSize + 2*intSize)
|
|
$0.addType(S<String>.self)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
$0.addStructComponent(offset: 8)
|
|
} as! ReferenceWritableKeyPath<S<S<String>>, Double>
|
|
|
|
expectEqual(s_c_z_p_y, s_c_z_p_y_manual)
|
|
expectEqual(s_c_z_p_y_manual, s_c_z_p_y)
|
|
expectEqual(s_c_z_p_y_manual.hashValue, s_c_z_p_y.hashValue)
|
|
|
|
typealias CP = CratePair<S<S<String>>, Int>
|
|
let cratePair_left_value = ReferenceWritableKeyPath<CP, S<S<String>>>
|
|
.build(capacityInBytes: 12 + intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
$0.addStructComponent(offset: 0,
|
|
endsReferencePrefix: true)
|
|
$0.addType(Crate<S<S<String>>>.self)
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
} as! ReferenceWritableKeyPath<CP, S<S<String>>>
|
|
|
|
let cratePair_left_value_c_z_p_y
|
|
= cratePair_left_value.appending(path: s_c_z_p_y)
|
|
|
|
let crate1 = Crate(value: value3)
|
|
let crate2 = Crate(value: 9)
|
|
let cratePair = CratePair(left: crate1, right: crate2)
|
|
expectEqual(cratePair[keyPath: cratePair_left_value_c_z_p_y], 11.0)
|
|
cratePair[keyPath: cratePair_left_value_c_z_p_y] = 13.0
|
|
expectEqual(cratePair[keyPath: cratePair_left_value_c_z_p_y], 13.0)
|
|
expectEqual(value3[keyPath: s_c_z_p_y], 13.0)
|
|
expectEqual(value2[keyPath: c_z_p_y], 13.0)
|
|
|
|
let cratePair_left_value_c_z_p_y_manual
|
|
= ReferenceWritableKeyPath<CP, Double>
|
|
.build(capacityInBytes: 28 + 5*intSize) {
|
|
$0.addHeader(trivial: true, hasReferencePrefix: true)
|
|
$0.addStructComponent(offset: 0)
|
|
$0.addType(Crate<S<S<String>>>.self)
|
|
$0.addClassComponent(offset: classHeaderSize)
|
|
$0.addType(S<S<String>>.self)
|
|
$0.addStructComponent(offset: intSize*2 + ssSize + pointSize,
|
|
endsReferencePrefix: true)
|
|
$0.addType(C<S<String>>.self)
|
|
$0.addClassComponent(offset: classHeaderSize + 2*intSize)
|
|
$0.addType(S<String>.self)
|
|
$0.addStructComponent(offset: intSize*2 + stringSize)
|
|
$0.addType(Point.self)
|
|
$0.addStructComponent(offset: 8)
|
|
} as! ReferenceWritableKeyPath<CP, Double>
|
|
expectEqual(cratePair_left_value_c_z_p_y,
|
|
cratePair_left_value_c_z_p_y_manual)
|
|
expectEqual(cratePair_left_value_c_z_p_y_manual,
|
|
cratePair_left_value_c_z_p_y)
|
|
expectEqual(cratePair_left_value_c_z_p_y_manual.hashValue,
|
|
cratePair_left_value_c_z_p_y.hashValue)
|
|
}
|
|
|
|
runAllTests()
|