Attachment: Download

relates to:

• SR-1956 withUnsafePointer shouldn't take its argument as inout

Issue Description:

Summary: When bridging to a struct imported from C, getting the address of an
object means the method needs to be mutable, which it should not be.

//------------------------------------------------------------------------------
// Bitset: A set of points on a Go board as a C struct.

const int NumWords = 6;

struct Bitset {
uint64_t bits[NumWords];
};

//------------------------------------------------------------------------------
// PointSet: A set of points on a Go board as a Swift struct. Would like to use
// a Swift array, but that incurs a heap allocation we can't afford.

struct PointSet {

var bits = Bitset()

mutating func include(_ p: Int) {
setBitRaw(&bits, bit: p)
}

// BUG: This method should not be 'mutating', but needs to be because can't
// pass the address of bits to UnsafeRawPointer without using &, which
// tells the compiler that 'bits' get mutated. This 'mutating' then
// causes ripple effects throughout the client code.
mutating func contains(_ p: Int) -> Bool {
return testBitRaw(&bits, bit: p)
}
}

//------------------------------------------------------------------------------
// bit functions

typealias Word = UInt64
let BitsPerWord = 64
let Log2of64 = 6
let NumWords = 6

func wordWithBit(_ bit: Int) -> Int {
return Int(bit >> Log2of64)
}

func bitInWord(_ bit: Int) -> Word {
return Word(bit) & Word(BitsPerWord-1)
}

func setBitRaw(_ pointer: UnsafeMutableRawPointer, bit: Int) {
let a = pointer.bindMemory(to: Word.self, capacity: NumWords)
a[wordWithBit(bit)] |= (1 << bitInWord(bit))
}

func testBitRaw(_ pointer: UnsafeRawPointer, bit: Int) -> Bool {
let a = pointer.bindMemory(to: Word.self, capacity: NumWords)
return (a[wordWithBit(bit)] & (1 << bitInWord(bit))) != 0
}

See the attached sample project. Would love to find out that there's a less ugly way to do this (without losing performance).