1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
|
// RUN: %target-swift-frontend %s -emit-sil \
// RUN: -o /dev/null \
// RUN: -verify \
// RUN: -sil-verify-all \
// RUN: -module-name test \
// RUN: -enable-experimental-feature LifetimeDependence
// REQUIRES: swift_in_compiler
// REQUIRES: swift_feature_LifetimeDependence
struct MutableSpan : ~Escapable, ~Copyable {
let base: UnsafeMutableRawPointer
let count: Int
@lifetime(borrow p)
init(_ p: UnsafeMutableRawPointer, _ c: Int) {
self.base = p
self.count = c
}
subscript(position: Int) -> Int {
get {
let offset = position * MemoryLayout<Int>.stride
return base.loadUnaligned(fromByteOffset: offset, as: Int.self)
}
nonmutating set(newValue) {
let offset = position * MemoryLayout<Int>.stride
base.storeBytes(of: newValue, toByteOffset: offset,
as: Int.self)
}
}
struct Iter: ~Escapable {
var base: UnsafeMutableRawPointer
var count: Int
@lifetime(borrow base)
init(base: UnsafeMutableRawPointer, count: Int) {
self.base = base
self.count = count
}
mutating func next() -> Int? {
guard count > 0 else { return nil }
count -= 1
let n = base.load(as: Int.self)
base = base + MemoryLayout<Int>.stride
return n
}
}
var iterator: Iter { Iter(base: base, count: count) }
}
extension Array where Element == Int {
// TODO: comment out dependsOn(scoped)
mutating func mutspan() -> /* dependsOn(scoped self) */ MutableSpan {
/* not the real implementation */
let p = self.withUnsafeMutableBufferPointer { $0.baseAddress! }
return MutableSpan(p, count)
}
}
struct NC : ~Copyable {
let p: UnsafeMutableRawPointer
let c: Int
// Requires a mutable borrow.
@lifetime(borrow self)
mutating func getMutableSpan() -> MutableSpan {
MutableSpan(p, c)
}
}
func mbv_set_element(nc: inout NC, e: Int) {
nc.getMutableSpan()[3] = e
}
func test_mutate_iterate() {
var array = [1,2,3]
// mutable 'array' access
let mutatingSpan = array.mutspan()
var iterator = mutatingSpan.iterator
var i = 0
while let n = iterator.next() {
_ = n
if i < mutatingSpan.count {
mutatingSpan[i+1] = mutatingSpan[i]
i += 1
}
}
// end mutable 'array' access
}
|
