Make BufferView prototype more realistic

Author: meg-gupta

test/SIL/buffer_view_prototype.swift

@@ -4,36 +4,131 @@
 // RUN:   -enable-experimental-feature NoncopyableGenerics \
 // RUN:   -enable-experimental-lifetime-dependence-inference \ 
 // RUN:   -Xllvm -enable-lifetime-dependence-diagnostics
+
+// REQUIRES: asserts
+// REQUIRES: swift_in_compiler
 // REQUIRES: noncopyable_generics
 
+// Incrementally testing https://github.pie.apple.com/guillaume-l/BufferView with lifetime dependence
+
+// TODO: Use real Range
+public struct FakeRange<Bound> {
+  public let lowerBound: Bound
+  public let upperBound: Bound
+}
+
+// TODO: Use real Optional
+public enum FakeOptional<T> {
+  case none
+  case some(T)
+}
+
+public struct BufferViewIndex<Element> {
+  let _rawValue: UnsafeRawPointer
+
+  internal init(rawValue: UnsafeRawPointer) {
+    _rawValue = rawValue
+  }
+
+  var isAligned: Bool {
+    (Int(bitPattern: _rawValue) & (MemoryLayout<Element>.alignment-1)) == 0
+  }
+}
+
+extension BufferViewIndex: Equatable {}
+
+extension BufferViewIndex: Hashable {}
+
+extension BufferViewIndex: Strideable {
+  public typealias Stride = Int
+
+  public func distance(to other: BufferViewIndex) -> Int {
+    let bytes = _rawValue.distance(to: other._rawValue)
+    let (q, r) = bytes.quotientAndRemainder(dividingBy: MemoryLayout<Element>.stride)
+    precondition(r == 0)
+    return q
+  }
+
+  public func advanced(by n: Int) -> BufferViewIndex {
+    .init(rawValue: _rawValue.advanced(by: n &* MemoryLayout<Element>.stride))
+  }
+}
+
+extension BufferViewIndex: Comparable {
+  public static func <(lhs: BufferViewIndex, rhs: BufferViewIndex) -> Bool {
+    lhs._rawValue < rhs._rawValue
+  }
+}
+
 public struct BufferView<Element> : ~Escapable {
-  public typealias Index = Int
-  public typealias Pointer = UnsafePointer<Element>
-  public let baseAddress: Pointer
+  let start: BufferViewIndex<Element>
   public let count: Int
-
-  // TODO: This should be a failable initializer
-  // Currently optional is Escapable, so we cant yet write it.
-  public init<Storage>(unsafeBuffer: UnsafeBufferPointer<Element>,
-                       storage: borrowing Storage)
-    -> _borrow(storage) Self {
-    let baseAddress = unsafeBuffer.baseAddress!
-    self = BufferView<Element>(baseAddress: baseAddress,
-                               count: unsafeBuffer.count)
-    return self
-  }
-  // unsafe private API
+  private var baseAddress: UnsafeRawPointer { start._rawValue }
+  
+  public init<Owner>(
+      baseAddress: UnsafeRawPointer,
+      count: Int,
+      dependsOn owner: borrowing Owner
+    ) {
+      self.init(
+        start: .init(rawValue: baseAddress), count: count, dependsOn: owner
+      )
+  }
+  init<Owner>(
+    start index: BufferViewIndex<Element>,
+    count: Int,
+    dependsOn owner: borrowing Owner
+  ) {
+    precondition(count >= 0, "Count must not be negative")
+    if !_isPOD(Element.self) {
+      precondition(
+        index.isAligned,
+        "baseAddress must be properly aligned for \(Element.self)"
+      )
+    }
+    self.start = index
+    self.count = count
+  }
   @_unsafeNonescapableResult
-  init(baseAddress: Pointer, count: Int) {
+  init(start index: BufferViewIndex<Element>,
+    count: Int) {
     precondition(count >= 0, "Count must not be negative")
-    self.baseAddress = baseAddress
+    if !_isPOD(Element.self) {
+      precondition(
+        index.isAligned,
+        "baseAddress must be properly aligned for \(Element.self)"
+      )
+    }
+    self.start = index
     self.count = count
   }
-  subscript(_ index: Index) -> Element? {
-    if (index < 0 || index >= count) {
-      return nil
+}
+// TODO: extend  Collection, BidirectionalCollection, RandomAccessCollection {
+extension BufferView {
+  public typealias Index = BufferViewIndex<Element>
+  public typealias SubSequence = Self
+
+  public var startIndex: Index { start }
+  public var endIndex: Index { start.advanced(by: count) }  
+ 
+  public subscript(position: Index) -> Element {
+    get {
+      if _isPOD(Element.self) {
+        return position._rawValue.loadUnaligned(as: Element.self)
+      }
+      else {
+        return position._rawValue.load(as: Element.self)
+      }
+    }
+  }
+ 
+  public subscript(bounds: FakeRange<BufferViewIndex<Element>>) -> Self {
+    get {
+      BufferView(
+        start: bounds.lowerBound,
+        count: bounds.upperBound.distance(to:bounds.lowerBound) / MemoryLayout<Element>.stride
+      )
     }
-    return baseAddress[index]
   }
 }
 
@@ -47,14 +142,17 @@ extension Array {
   // rdar://123071321
   var view: BufferView<Element> {
     var _view : BufferView<Element>? 
-    withUnsafeBufferPointer {
-      _view = BufferView(unsafeBuffer: $0, storage: self)
+    withUnsafePointer(to:self) {
+      _view = BufferView(baseAddress: $0, count: self.count, dependsOn: self)
     }
     return _view!
   }
 }
 
-public func array_view_element(a: [Int] , i: Int) -> Int {
-  a.view[i]!
+public func array_view_element(a: [Int] , i: BufferViewIndex<Int>) -> Int {
+  a.view[i]
 }
 
+public func array_view_slice_element(a: [Int] , sliceIdx: FakeRange<BufferViewIndex<Int>>, Idx: BufferViewIndex<Int>) -> Int {
+  a.view[sliceIdx][Idx]
+}