When is `UnsafeMutableBufferPointer.baseAddress` `nil`?

Lantua · December 31, 2019, 6:34pm

A recent discussion (How can I call the specialized version of a generic function? - #12 by Lantua) makes me wonder when UnsafeMutableBuffer.baseAddress can be nil. I just quickly checked:

Array.init(unsafeUninitializedCapacity:initializingWith:) with unsafeUninitializedCapacity = 0
UnsafeMutableBufferPointer.allocate(capacity:) with capacity = 0

Are these cases guaranteed to be non-nil? Is there a case that leads to nil other than manually assign nil to the pointer?

Nevin · December 31, 2019, 6:48pm

SE–0055: Make unsafe pointer nullability explicit using Optional

Joe_Groff · January 2, 2020, 8:58pm

The only time when the base address can be nil is if the buffer is empty. If the count is greater than zero, then the base address is guaranteed not to be nil.

Lantua · January 3, 2020, 4:20pm

Perhaps my actual question is where in the standard library are utilising this fact. Amongst the standard library functions that vent out UnsafeMutable<Raw>BufferPointer in one way or another:

UnsafeMutable<Raw><Buffer>.allocate
Array.init(unsafeUninitializedCapacity:initializingWith:)

None of them are using nil even if the the size is 0. It makes me wonder if I need to check for it at all.

There're also Unsafe<Raw>BufferPointer.init(start:count:) that can manually take nil. So I suppose I need to be wary of third-party initialising it that way, but such worry seems to be unneeded for standard library.

Karl · January 3, 2020, 5:02pm

It's in Foundation, rather than the standard library, but EmptyCollection<T>.withUnsafeBytes:

github.com

apple/swift-corelibs-foundation/blob/4a255655c298450416d388a58c2b50f4057c3346/Foundation/ContiguousBytes.swift#L74


      
              @inlinable
              public func withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R {
                  return try body(UnsafeRawBufferPointer(self))
              }
          }
          
          
// FIXME: When possible, expand conformance to `where Element : Trivial`.
          extension EmptyCollection : ContiguousBytes where Element == UInt8 {
              @inlinable
              public func withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R {
                  return try body(UnsafeRawBufferPointer(start: nil, count: 0))
              }
          }
          
          
// FIXME: When possible, expand conformance to `where Element : Trivial`.
          extension CollectionOfOne : ContiguousBytes where Element == UInt8 {
              @inlinable
              public func withUnsafeBytes<R>(_ body: (UnsafeRawBufferPointer) throws -> R) rethrows -> R {
                  let element = self.first!
                  return try Swift.withUnsafeBytes(of: element) {
                      return try body($0)

Joe_Groff · January 3, 2020, 5:35pm

User code, including C code, is allowed to create buffers that use nil as the base address, regardless of whether the standard library utilizes the ability.