Add Array to Hylo standard library

Library/Hylo/Array.hylo

@@ -0,0 +1,118 @@
+/// An ordered, random-access collection.
+public type Array<Element: Movable & Deinitializable>: Deinitializable {
+
+  /// The out-of-line storage of the array.
+  ///
+  /// The header of the buffer indicates the number of elements contained in the array.
+  var storage: DynamicBuffer<Int, Element>
+
+  /// Creates a new, empty array.
+  public init() {
+    &storage = .new()
+  }
+
+  /// Deinitializes `self`.
+  public fun deinit() sink {
+    var i = 0
+    while i < count() {
+      &pointer_to_element(at: i).unsafe_pointee().deinit()
+      &i += 1
+    }
+  }
+
+  /// The number of elements in the array.
+  public fun count() -> Int {
+    if storage.capacity() == 0 { 0 } else { storage.header.copy() }
+  }
+
+  /// The number of elements that can be stored in the array before new storage must be allocated.
+  public fun capacity() -> Int {
+    return storage.capacity()
+  }
+
+  /// Reserves enough space to store `n` elements
+  public fun reserve_capacity(_ n: Int) inout {
+    if n < capacity() { return }
+
+    var new_capacity = max[1, capacity()].copy()
+    while new_capacity < n {
+      &new_capacity += new_capacity.copy()
+    }
+
+    // TODO: Call `self.copy()` directly in the lambda.
+    let c = count()
+    var new_storage = DynamicBuffer<Int, Element>(
+      capacity: new_capacity,
+      initializing_header_with: fun (_ h: set Int) -> Void { &h = c.copy() })
+
+    var i = 0
+    var e = storage.first_element_address()
+    var f = new_storage.first_element_address()
+    while i < count() {
+      f.unsafe_initialize_pointee(e.unsafe_pointee())
+      &e = e.advance(by: 1)
+      &f = f.advance(by: 1)
+      &i += 1
+    }
+
+    // Deinitializing the `self.storage` is safe at this point because all its elements must have
+    // been moved to `new_storage`.
+    &storage = new_storage
+  }
+
+  /// Adds a new element at the end of the array.
+  public fun append(_ source: sink Element) inout {
+    &reserve_capacity(count() + 1)
+    pointer_to_element(at: count()).unsafe_initialize_pointee(source)
+    &storage.header += 1
+  }
+
+  /// Accesses the element at `position`.
+  ///
+  /// - Requires: `position` is in the range `0 ..< count()`.
+  public subscript(_ position: Int): Element {
+    let {
+      // precondition(position >= 0 && position < count())
+      pointer_to_element(at: position).unsafe[]
+    }
+    inout {
+      // precondition(position >= 0 && position < count())
+      pointer_to_element(at: position).unsafe[]
+    }
+  }
+
+  /// Returns the address of the element at `position`.
+  ///
+  /// - Requires: `position` is in the range `0 ..< capacity()`.
+  fun pointer_to_element(at position: Int) -> PointerToMutable<Element> {
+    storage.first_element_address().advance(by: position)
+  }
+
+}
+
+/*
+
+// TODO: Make Array conform to Regular instead of Deinitializable once #1002 is fixed.
+// Currently that issue prevents the copy() function below from compiling.
+//
+// Error is "type 'Element' does not conform to trait 'Movable'"
+
+public conformance Array: Equatable {
+
+  /// Returns `true` iff `other` has an equivalent value.
+  public fun infix== (_ other: Self) -> Bool {
+    // TODO
+    return true
+  }
+
+}
+
+public conformance Array: Copyable {
+  /// Returns an equivalent instance.
+  public fun copy() -> Self {
+    // TODO
+    .new()
+  }
+}
+
+*/

Library/Hylo/Core/PointerToMutable.hylo

@@ -34,10 +34,10 @@ public type PointerToMutable<Pointee>: Regular {
   }
 
   /// Returns `self` offset forward by `n` array elements of `Pointee` type.
-  public fun advance( by n: Int ) -> Self {
+  public fun advance(by n: Int) -> Self {
     let offset_in_bytes = MemoryLayout<Pointee>.stride() * n
     return PointerToMutable<Pointee>.new(
-      base: Builtin.advanced_by_bytes_word( base, offset_in_bytes.value ) )
+      base: Builtin.advanced_by_bytes_word(base, offset_in_bytes.value))
   }
 
   /// Creates an instance that does not address any usable storage.
@@ -82,3 +82,30 @@ public conformance PointerToMutable: Equatable {
   }
 
 }
+
+public extension PointerToMutable where Pointee: Movable {
+
+  /// Returns the value at the address represented by `self`, leaving the storage at this address
+  /// uninitialized.
+  ///
+  /// Note: This method should be deprecated once nonmutating subscripts are implemented.
+  public fun unsafe_pointee() -> Pointee {
+    return base as* (remote sink Pointee)
+  }
+
+  /// Initialize the value at the address represented by `self` to `value`.
+  ///
+  /// - Requires: the `MemoryLayout<Pointee>.size()` bytes starting at the address are uninitialized
+  ///   and suitably aligned for `Pointee`.
+  public fun unsafe_initialize_pointee(_ value: sink Pointee) {
+    initialize<Pointee>(&(base as* (remote set Pointee)), to: value)
+  }
+
+}
+
+/// Initializes `x` to `y`.
+///
+/// - Note: This function is a workaround for the lack of `set` bindings (see #925).
+fun initialize<T: Movable>(_ x: set T, to y: sink T) {
+  &x = y
+}

Library/Hylo/DynamicBuffer.hylo

@@ -4,7 +4,7 @@
 /// - Warning: The deinitializer of `DynamicBuffer` does not deinitialize the elements that may
 ///   be stored in its payload. You must ensure that they are properly deinitialized before
 ///   `deinit` is called.
-public type DynamicBuffer<Header: Deinitializable, Element>: Deinitializable {
+public type DynamicBuffer<Header: Deinitializable, Element>: Deinitializable, Movable {
 
   /// The description of payloads in `DynamicBuffer`s.
   typealias BufferHeader = {
@@ -16,7 +16,7 @@ public type DynamicBuffer<Header: Deinitializable, Element>: Deinitializable {
   static fun payload_offset() -> Int {
     let a = MemoryLayout<Element>.alignment()
     let s = MemoryLayout<BufferHeader>.size()
-    return s + (a - s % a)
+    return s + (a - s) % a
   }
 
   /// A pointer to the base of the buffer's out-of-line storage.
@@ -49,11 +49,12 @@ public type DynamicBuffer<Header: Deinitializable, Element>: Deinitializable {
   }
 
   /// Returns the address of the initial element.
-  /// - Precondition: `capacity != 0`
+  ///
+  /// - Requires: `capacity() > 0`.
   public fun first_element_address() -> PointerToMutable<Element> {
     // TODO: Uncomment the following line when #995 is fixed
-    // precondition(self.capacity() == 0)
-    return PointerToMutable<Element>(type_punning: storage.advance(by_bytes: payload_offset()))
+    // precondition(self.capacity() > 0)
+    PointerToMutable<Element>(type_punning: storage.advance(by_bytes: payload_offset()))
   }
 
   /// Deinitializes `self`.
@@ -73,4 +74,29 @@ public type DynamicBuffer<Header: Deinitializable, Element>: Deinitializable {
     return p.unsafe[].0.copy()
   }
 
+  /// Accesses the header of `self`.
+  ///
+  /// - Requires: `capacity() > 0`.
+  public property header: Header {
+    let { buffer_header().unsafe[].1 }
+    inout { &buffer_header().unsafe[].1 }
+  }
+
+  /// Returns the address of the `self`'s header.
+  fun buffer_header() -> PointerToMutable<BufferHeader> {
+    PointerToMutable<BufferHeader>(type_punning: storage)
+  }
+
+}
+
+// TODO: This trait was added as a workaround for #1002 since DynamicBuffer
+// is initialized in the Array constructor
+public conformance DynamicBuffer: Movable {
+
+  fun take_value(from source: sink Self) -> {self: Self, Void} {
+    // TODO: Fix defects preventing the following line from working
+    // &storage.base = source.storage.base
+    (self: source, ())
+  }
+
 }

Package.swift

@@ -16,6 +16,7 @@ let package = Package(
   products: [
     .executable(name: "hc", targets: ["hc"]),
     .executable(name: "hylo-demangle", targets: ["hylo-demangle"]),
+    .library(name: "Hylo", targets: ["Driver"]),
   ],
 
   dependencies: [

Sources/CodeGen/LLVM/Transpilation.swift

@@ -406,7 +406,7 @@ extension LLVM.Module {
     let transpilation = declareFunction(ir.base.mangled(f), .init(from: parameters, in: &self))
 
     configureAttributes(transpilation, transpiledFrom: f, of: m)
-    configureInputAttributes(transpilation.parameters.dropFirst(), transpiledFrom: f, in: m)
+    configureInputAttributes(transpilation.parameters.dropLast(), transpiledFrom: f, in: m)
 
     return transpilation
   }
@@ -903,10 +903,7 @@ extension LLVM.Module {
         let base = llvm(s.operands[0])
         let byteOffset = llvm(s.operands[1])
         register[.register(i)] = insertGetElementPointerInBounds(
-          of: base,
-          typed: ptr,
-          indices: [byteOffset],
-          at: insertionPoint)
+          of: base, typed: i8, indices: [byteOffset], at: insertionPoint)
 
       default:
         unreachable("unexpected LLVM instruction '\(s.instruction)'")

Sources/Core/AccessEffectSet.swift

@@ -30,8 +30,7 @@ public struct AccessEffectSet: OptionSet, Hashable {
 
   /// The weakest capability in `self`, or `nil` if `self` is empty.
   public var weakest: AccessEffect? {
-    var s = elements
-    return s.next()
+    elements.first
   }
 
   /// Returns the strongest capability in `self` including `k`.
@@ -74,33 +73,39 @@ public struct AccessEffectSet: OptionSet, Hashable {
 
 extension AccessEffectSet {
 
-  /// A sequence with the elements of an access effect set.
-  public struct Elements: Sequence, IteratorProtocol {
+  /// A collection with the elements of an access effect set.
+  public struct Elements: Collection {
+
+    public typealias Index = UInt8
+
+    public typealias Element = AccessEffect
 
     /// The contents of the set being iterated over.
     private let base: AccessEffectSet
 
-    /// The next effect returned by the iterator.
-    private var position: UInt8
-
     /// Creates an iterator over `s`.
     public init(_ s: AccessEffectSet) {
       self.base = s
-      self.position = s.rawValue & (~s.rawValue + 1)
-      if self.position == 0 {
-        self.position = 1 << 7
-      }
     }
 
-    /// Returns the next element in the sequence.
-    public mutating func next() -> AccessEffect? {
-      if position == (1 << 7) { return nil }
-      defer {
-        repeat {
-          position = position << 1
-        } while (position != (1 << 7)) && ((position & base.rawValue) != position)
-      }
-      return .init(rawValue: position)
+    public var startIndex: UInt8 {
+      base.rawValue & (~base.rawValue + 1)
+    }
+
+    public var endIndex: UInt8 {
+      1 << 7
+    }
+
+    public func index(after position: UInt8) -> UInt8 {
+      var next = position
+      repeat {
+        next = next << 1
+      } while (next != endIndex) && ((next & base.rawValue) != next)
+      return next
+    }
+
+    public subscript(position: UInt8) -> AccessEffect {
+      AccessEffect(rawValue: position)!
     }
 
   }

Sources/Core/NativeInstruction.swift

@@ -311,8 +311,8 @@ extension NativeInstruction: CustomStringConvertible {
       return "fptosi_\(l)_\(r)"
     case .zeroinitializer(let t):
       return "zeroinitializer_\(t)"
-    case .advancedByBytes(let byteOffset):
-      return "advanced_by_bytes_\(byteOffset)"
+    case .advancedByBytes(let t):
+      return "advanced_by_bytes_\(t)"
     }
   }
 

Sources/Core/Program.swift

@@ -311,7 +311,7 @@ extension Program {
     scopes(from: scope).first(TranslationUnit.self)!
   }
 
-  /// Returns the trait defining `d` iff `d` is a requirement. Otherwise, returns nil.
+  /// Returns the trait of which `d` is a member, or `nil` if `d` isn't member of a trait.
   public func trait<T: DeclID>(defining d: T) -> TraitDecl.ID? {
     switch d.kind {
     case AssociatedTypeDecl.self, AssociatedValueDecl.self:

Sources/Core/SourcePosition.swift

@@ -8,15 +8,15 @@ public struct SourcePosition: Hashable {
   public let index: String.Index
 
   /// Creates an instance with the given properties.
-  init(_ index: String.Index, in file: SourceFile) {
+  public init(_ index: String.Index, in file: SourceFile) {
     self.file = file
     self.index = index
   }
 
   /// Creates an instance referring to the given 1-based line and column numbers in `source`.
   ///
   /// - Precondition: `line` and `column` denote a valid position in `source`.
-  init(line: Int, column: Int, in file: SourceFile) {
+  public init(line: Int, column: Int, in file: SourceFile) {
     self.file = file
     self.index = file.index(line: line, column: column)
   }