@effekt-lang/effekt 0.24.0 → 0.26.0

package/libraries/common/array.effekt

@@ -8,14 +8,54 @@ import option
 /// A mutable 0-indexed fixed-sized array.
 extern type Array[T]
 
+/** We represent arrays like positive types.
+ *  The tag is 0 and the obj points to memory with the following layout:
+ *
+ *   +--[ Header ]--+------+------------+
+ *   | Rc  | Eraser | Size | Fields ... |
+ *   +--------------+------+------------+
+ */
+
+extern llvm """
+declare noalias ptr @calloc(i64, i64)
+
+define void @array_erase_fields(ptr %array_pointer) {
+entry:
+    %data_pointer = getelementptr inbounds i64, ptr %array_pointer, i64 1
+    %size = load i64, ptr %array_pointer, align 8
+    %size_eq_0 = icmp eq i64 %size, 0
+    br i1 %size_eq_0, label %exit, label %loop
+loop:
+    %loop_phi = phi i64 [ %inc, %loop ], [ 0, %entry ]
+
+    %element_pointer = getelementptr inbounds %Pos, ptr %data_pointer, i64 %loop_phi
+    %element = load %Pos, ptr %element_pointer
+
+    call void @erasePositive(%Pos %element)
+    %inc = add nuw i64 %loop_phi, 1
+    %cmp = icmp ult i64 %inc, %size
+    br i1 %cmp, label %loop, label %exit
+exit:
+    ret void
+}
+"""
+
 /// Allocates a new array of size `size`, keeping its values _undefined_.
 /// Prefer using `array` constructor instead to ensure that values are defined.
 extern global def allocate[T](size: Int): Array[T] =
   js "(new Array(${size}))"
   chez "(make-vector ${size})" // creates an array filled with 0s on CS
   llvm """
-    %z = call %Pos @c_array_new(%Int ${size})
-    ret %Pos %z
+    %size0 = shl i64 ${size}, 4
+    %size1 = add i64 %size0, 24
+    %calloc = tail call noalias ptr @calloc(i64 %size1, i64 1)
+    %eraser_pointer = getelementptr ptr, ptr %calloc, i64 1
+    %size_pointer = getelementptr ptr, ptr %calloc, i64 2
+    store i64 0, ptr %calloc
+    store ptr @array_erase_fields, ptr %eraser_pointer
+    store i64 ${size}, ptr %size_pointer
+    %ret_pos = insertvalue %Pos { i64 0, ptr poison }, ptr %calloc, 1
+    ret %Pos %ret_pos
   """
   vm "array::allocate(Int)"
 
@@ -49,8 +89,12 @@ extern pure def size[T](arr: Array[T]): Int =
   js "${arr}.length"
   chez "(vector-length ${arr})"
   llvm """
-    %z = call %Int @c_array_size(%Pos ${arr})
-    ret %Int %z
+    %pos_data = extractvalue %Pos ${arr}, 1
+    %size_pointer = getelementptr inbounds i64, ptr %pos_data, i64 2
+    %size = load i64, ptr %size_pointer
+
+    tail call void @erasePositive(%Pos ${arr})
+    ret i64 %size
   """
   vm "array::size[T](Array[T])"
 
@@ -62,8 +106,15 @@ extern global def unsafeGet[T](arr: Array[T], index: Int): T =
   js "${arr}[${index}]"
   chez "(vector-ref ${arr} ${index})"
   llvm """
-    %z = call %Pos @c_array_get(%Pos ${arr}, %Int ${index})
-    ret %Pos %z
+    %pos_data = extractvalue %Pos ${arr}, 1
+
+    %data_pointer = getelementptr inbounds ptr, ptr %pos_data, i64 3
+    %element_pointer = getelementptr inbounds %Pos, ptr %data_pointer, i64 ${index}
+    %element = load %Pos, ptr %element_pointer
+
+    tail call void @sharePositive(%Pos %element)
+    tail call void @erasePositive(%Pos ${arr})
+    ret %Pos %element
   """
   vm "array::unsafeGet[T](Array[T], Int)"
 
@@ -82,8 +133,15 @@ extern global def unsafeSet[T](arr: Array[T], index: Int, value: T): Unit =
   js "array$set(${arr}, ${index}, ${value})"
   chez "(begin (vector-set! ${arr} ${index} ${value}) #f)"
   llvm """
-    %z = call %Pos @c_array_set(%Pos ${arr}, %Int ${index}, %Pos ${value})
-    ret %Pos %z
+    %array_data = extractvalue %Pos ${arr}, 1
+
+    %data_pointer = getelementptr inbounds i64, ptr %array_data, i64 3
+    %element_pointer = getelementptr inbounds %Pos, ptr %data_pointer, i64 ${index}
+    %element = load %Pos, ptr %element_pointer, align 8
+    tail call void @erasePositive(%Pos %element)
+    store %Pos ${value}, ptr %element_pointer, align 8
+    tail call void @erasePositive(%Pos ${arr})
+    ret %Pos zeroinitializer
   """
   vm "array::unsafeSet[T](Array[T], Int, T)"
 

package/libraries/common/buffer.effekt

@@ -3,7 +3,6 @@ module buffer
 import array
 
 // TODO (in Effekt compiler)
-// - [ ] fix allocating into actually global region
 // - [ ] fix exceptions on objects
 // - [X] allow omitting braces after `at` for singleton regions
 
@@ -35,12 +34,12 @@ def emptyBuffer[T](capacity: Int): Buffer[T] at {global} = {
 def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
   // TODO allocate buffer (and array) into a region r.
   val contents = array::allocate[T](initialCapacity)
-  var head in global = 0
-  var tail in global = 0
+  val head = ref(0)
+  val tail = ref(0)
 
   def size(): Int =
-    if (tail >= head) { tail - head }
-    else { initialCapacity - head + tail }
+    if (tail.get >= head.get) { tail.get - head.get }
+    else { initialCapacity - head.get + tail.get }
 
   def capacity(): Int = initialCapacity - size()
 
@@ -51,36 +50,36 @@ def arrayBuffer[T](initialCapacity: Int): Buffer[T] at {global} = {
     def read() = {
       if (buffer.empty?) None()
       else {
-        val result: T = contents.unsafeGet(head);
-        head = mod(head + 1, initialCapacity)
+        val result: T = contents.unsafeGet(head.get)
+        head.set(mod(head.get + 1, initialCapacity))
         Some(result)
       }
     }
     def write(el: T) = {
       if (buffer.full?) <> // raise(BufferOverflow())
 
-      contents.unsafeSet(tail, el)
-      tail = mod(tail + 1, initialCapacity)
+      contents.unsafeSet(tail.get, el)
+      tail.set(mod(tail.get + 1, initialCapacity))
     }
   }
   buffer
 }
 def refBuffer[T](): Buffer[T] at {global} = {
-  var content: Option[T] in global = None()
+  val content = ref(None())
   new Buffer[T] {
-    def capacity() = if (content.isEmpty) 1 else 0
-    def full?() = content.isDefined
-    def empty?() = isEmpty(content)
+    def capacity() = if (content.get.isEmpty) 1 else 0
+    def full?() = content.get.isDefined
+    def empty?() = isEmpty(content.get)
     def read() = {
-      val res = content
-      content = None()
+      val res = content.get
+      content.set(None())
       res
     }
-    def write(el: T) = content match {
+    def write(el: T) = content.get match {
       case Some(v) =>
         <> // do raise(BufferOverflow(), "Cannot read element from buffer")
       case None() =>
-        content = Some(el)
+        content.set(Some(el))
     }
   }
 }
@@ -88,24 +87,24 @@ def refBuffer[T](): Buffer[T] at {global} = {
 namespace examples {
   def main() = ignore[BufferOverflow] {
     // Buffer with capacity 1
-    def b = emptyBuffer[Int](1);
-    println(b.capacity);
-    println(b.full?);
+    def b = emptyBuffer[Int](1)
+    println(b.capacity)
+    println(b.full?)
 
-    b.write(17);
-    println(b.read());
+    b.write(17)
+    println(b.read())
 
     // buffer with capacity 3
-    def ringbuffer = emptyBuffer[Int](3);
-    ringbuffer.write(1);
-    ringbuffer.write(2);
-    println(ringbuffer.read());
-    ringbuffer.write(3);
-    println(ringbuffer.read());
-    println(ringbuffer.read());
-    ringbuffer.write(4);
-    ringbuffer.write(5);
-    println(ringbuffer.read());
-    println(ringbuffer.read());
+    def ringbuffer = emptyBuffer[Int](3)
+    ringbuffer.write(1)
+    ringbuffer.write(2)
+    println(ringbuffer.read())
+    ringbuffer.write(3)
+    println(ringbuffer.read())
+    println(ringbuffer.read())
+    ringbuffer.write(4)
+    ringbuffer.write(5)
+    println(ringbuffer.read())
+    println(ringbuffer.read())
   }
 }

package/libraries/common/bytearray.effekt

@@ -2,6 +2,17 @@ module bytearray
 
 /**
  * A memory managed, mutable, fixed-length array of bytes.
+ *
+ * We represent bytearrays like positive types.
+ *
+ *  - The field `tag` contains the size
+ *  - The field `obj` points to memory with the following layout:
+ *
+ *       +--[ Header ]--+--------------+
+ *       | Rc  | Eraser | Contents ... |
+ *       +--------------+--------------+
+ *
+ * The eraser does nothing.
  */
 extern type ByteArray
   // = llvm "%Pos"
@@ -12,32 +23,47 @@ extern type ByteArray
 extern global def allocate(size: Int): ByteArray =
   js "(new Uint8Array(${size}))"
   llvm """
-    %arr = call %Pos @c_bytearray_new(%Int ${size})
-    ret %Pos %arr
+    %object_size = add i64 ${size}, 16
+    %object_alloc = tail call noalias ptr @malloc(i64 noundef %object_size)
+    store i64 0, ptr %object_alloc, align 8
+    %object_data_ptr = getelementptr inbounds i8, ptr %object_alloc, i64 8
+    store ptr @bytearray_erase_noop, ptr %object_data_ptr, align 8
+    %ret_object1 = insertvalue %Pos poison, i64 ${size}, 0
+    %ret_object2 = insertvalue %Pos %ret_object1, ptr %object_alloc, 1
+    ret %Pos %ret_object2
   """
   chez "(make-bytevector ${size})"
 
 extern pure def size(arr: ByteArray): Int =
   js "${arr}.length"
   llvm """
-    %size = call %Int @c_bytearray_size(%Pos ${arr})
-    ret %Int %size
+    %size = extractvalue %Pos ${arr}, 0
+    tail call void @erasePositive(%Pos ${arr})
+    ret i64 %size
   """
   chez "(bytevector-length ${arr})"
 
 extern global def unsafeGet(arr: ByteArray, index: Int): Byte =
   js "(${arr})[${index}]"
   llvm """
-    %byte = call %Byte @c_bytearray_get(%Pos ${arr}, %Int ${index})
-    ret %Byte %byte
+    %arr_ptr = extractvalue %Pos ${arr}, 1
+    %arr_data_ptr = getelementptr inbounds i8, ptr %arr_ptr, i64 16
+    %element_ptr = getelementptr inbounds i8, ptr %arr_data_ptr, i64 ${index}
+    %element = load i8, ptr %element_ptr, align 1
+    tail call void @erasePositive(%Pos ${arr})
+    ret i8 %element
   """
   chez "(bytevector-u8-ref ${arr} ${index})"
 
 extern global def unsafeSet(arr: ByteArray, index: Int, value: Byte): Unit =
   js "bytearray$set(${arr}, ${index}, ${value})"
   llvm """
-    %z = call %Pos @c_bytearray_set(%Pos ${arr}, %Int ${index}, %Byte ${value})
-    ret %Pos %z
+    %arr_ptr = extractvalue %Pos ${arr}, 1
+    %arr_data_ptr = getelementptr inbounds i8, ptr %arr_ptr, i64 16
+    %element_ptr = getelementptr inbounds i8, ptr %arr_data_ptr, i64 ${index}
+    store i8 ${value}, ptr %element_ptr, align 1
+    tail call void @erasePositive(%Pos ${arr})
+    ret %Pos zeroinitializer
   """
   chez "(bytevector-u8-set! ${arr} ${index} ${value})"
 
@@ -121,6 +147,12 @@ extern js """
   }
 """
 
+extern llvm """
+define void @bytearray_erase_noop(ptr readnone %0) {
+  ret void
+}
+"""
+
 extern chez """
   (define (bytearray$compare b1 b2)
     (let ([len1 (bytevector-length b1)]

package/libraries/common/queue.effekt

@@ -25,82 +25,82 @@ def emptyQueue[T](): Queue[T] at {global} =
 
 def emptyQueue[T](initialCapacity: Int): Queue[T] at {global} = {
 
-  var contents in global = array[Option[T]](initialCapacity, None())
-  var head in global = 0
-  var tail in global = 0
-  var size in global = 0
-  var capacity in global = initialCapacity
+  val contents = ref(array[Option[T]](initialCapacity, None()))
+  val head = ref(0)
+  val tail = ref(0)
+  val size = ref(0)
+  val capacity = ref(initialCapacity)
 
   def remove(arr: Array[Option[T]], index: Int): Option[T] = {
-    with on[OutOfBounds].default { None() };
-    val value = arr.get(index);
-    arr.set(index, None());
+    with on[OutOfBounds].default { None() }
+    val value = arr.get(index)
+    arr.set(index, None())
     value
   }
 
   def nonEmpty[T] { p: => Option[T] / Exception[OutOfBounds] }: Option[T] =
-    if (size <= 0) None() else on[OutOfBounds].default { None() } { p() }
+    if (size.get <= 0) None() else on[OutOfBounds].default { None() } { p() }
 
   // Exponential back-off
   def resizeTo(requiredSize: Int): Unit =
-    if (requiredSize <= capacity) () else {
+    if (requiredSize <= capacity.get) () else {
       with on[OutOfBounds].ignore // should not happen
 
-      val oldSize = capacity
-      val newSize = capacity * 2
-      val oldContents = contents
+      val oldSize = capacity.get
+      val newSize = capacity.get * 2
+      val oldContents = contents.get
       val newContents = array::allocate[Option[T]](newSize)
 
-      if (head < tail) {
+      if (head.get < tail.get) {
         // The queue does not wrap around; direct copy is possible.
-        copy(oldContents, head, newContents, 0, size) // changed tail to size
-      } else if (size > 0) {
+        copy(oldContents, head.get, newContents, 0, size.get) // changed tail to size
+      } else if (size.get > 0) {
         // The queue wraps around; copy in two segments.
-        copy(oldContents, head, newContents, 0, oldSize - head) // changed oldSize to oldSize - head
-        copy(oldContents, 0, newContents, oldSize - head, tail) // changed oldSize - head to oldSize - head
+        copy(oldContents, head.get, newContents, 0, oldSize - head.get) // changed oldSize to oldSize - head
+        copy(oldContents, 0, newContents, oldSize - head.get, tail.get) // changed oldSize - head to oldSize - head
       }
 
-      contents = newContents
-      capacity = newSize
-      head = 0
-      tail = oldSize
+      contents.set(newContents)
+      capacity.set(newSize)
+      head.set(0)
+      tail.set(oldSize)
     }
 
   def queue = new Queue[T] {
-    def empty?() = size <= 0
+    def empty?() = size.get <= 0
 
     def popFront() =
       nonEmpty {
-        val result = contents.remove(head)
-        head = mod(head + 1, capacity)
-        size = size - 1
+        val result = contents.get.remove(head.get)
+        head.set(mod(head.get + 1, capacity.get))
+        size.set(size.get - 1)
         result
       }
 
     def popBack() =
       nonEmpty {
-        tail = mod(tail - 1 + capacity, capacity)
-        val result = contents.remove(tail)
-        size = size - 1
+        tail.set(mod(tail.get - 1 + capacity.get, capacity.get))
+        val result = contents.get.remove(tail.get)
+        size.set(size.get - 1)
         result
       }
 
-    def peekFront() = nonEmpty { contents.get(head) }
+    def peekFront() = nonEmpty { contents.get.get(head.get) }
 
-    def peekBack() = nonEmpty { contents.get(tail) }
+    def peekBack() = nonEmpty { contents.get.get(tail.get) }
 
     def pushFront(el: T) = {
-      resizeTo(size + 1);
-      head = mod(head - 1 + capacity, capacity);
-      size = size + 1;
-      contents.unsafeSet(head, Some(el))
+      resizeTo(size.get + 1)
+      head.set(mod(head.get - 1 + capacity.get, capacity.get))
+      size.set(size.get + 1)
+      contents.get.unsafeSet(head.get, Some(el))
     }
 
     def pushBack(el: T) = {
-      resizeTo(size + 1);
-      contents.unsafeSet(tail, Some(el));
-      size = size + 1;
-      tail = mod(tail + 1, capacity)
+      resizeTo(size.get + 1)
+      contents.get.unsafeSet(tail.get, Some(el))
+      size.set(size.get + 1)
+      tail.set(mod(tail.get + 1, capacity.get))
     }
   }
   queue
@@ -109,30 +109,30 @@ def emptyQueue[T](initialCapacity: Int): Queue[T] at {global} = {
 namespace examples {
   def main() = {
     // queue with initial capacity 4
-    def b = emptyQueue[Int](4);
-    println(b.empty?);
-    b.pushFront(1);
-    b.pushBack(2);
-    b.pushFront(3);
-    b.pushBack(4);
+    def b = emptyQueue[Int](4)
+    println(b.empty?)
+    b.pushFront(1)
+    b.pushBack(2)
+    b.pushFront(3)
+    b.pushBack(4)
     // this will cause resizing:
-    b.pushBack(5);
-    b.pushBack(6);
-    b.pushBack(7);
-    b.pushBack(8);
+    b.pushBack(5)
+    b.pushBack(6)
+    b.pushBack(7)
+    b.pushBack(8)
     // and again:
-    b.pushBack(9);
-
-    println(b.empty?);
-    println(b.popFront()); // Some(3)
-    println(b.popFront()); // Some(1)
-    println(b.popFront()); // Some(2)
-    println(b.popFront()); // Some(4)
-    println(b.popFront()); // Some(5)
-    println(b.popFront()); // Some(6)
-    println(b.popFront()); // Some(7)
-    println(b.popFront()); // Some(8)
-    println(b.popFront()); // Some(9)
-    println(b.popFront()); // None()
+    b.pushBack(9)
+
+    println(b.empty?)
+    println(b.popFront()) // Some(3)
+    println(b.popFront()) // Some(1)
+    println(b.popFront()) // Some(2)
+    println(b.popFront()) // Some(4)
+    println(b.popFront()) // Some(5)
+    println(b.popFront()) // Some(6)
+    println(b.popFront()) // Some(7)
+    println(b.popFront()) // Some(8)
+    println(b.popFront()) // Some(9)
+    println(b.popFront()) // None()
   }
 }

package/libraries/common/ref.effekt

@@ -9,17 +9,44 @@ extern js """
   }
 """
 
+extern llvm """
+define void @c_ref_erase_field(ptr %0) {
+  %field = load %Pos, ptr %0, align 8
+  tail call void @erasePositive(%Pos %field)
+  ret void
+}
+"""
+
 /// Global, mutable references
 extern type Ref[T]
 
+/** We represent references like positive types in LLVM
+ *  The tag is 0 and the obj points to memory with the following layout:
+ *
+ *   +--[ Header ]--------------+------------+
+ *   | ReferenceCount  | Eraser | Field      |
+ *   +--------------------------+------------+
+ */
+
 /// Allocates a new reference, keeping its value _undefined_.
 /// Prefer using `ref` constructor instead to ensure that the value is defined.
 extern global def allocate[T](): Ref[T] =
   js "{ value: undefined }"
   chez "(box #f)"
   llvm """
-    %z = call %Pos @c_ref_fresh(%Pos zeroinitializer)
-    ret %Pos %z
+    ; sizeof Header + sizeof Pos = 32
+    %ref = tail call noalias ptr @malloc(i64 noundef 32)
+    %refEraser = getelementptr ptr, ptr %ref, i64 1
+    %fieldTag = getelementptr ptr, ptr %ref, i64 2
+    %fieldData_pointer = getelementptr ptr, ptr %ref, i64 3
+
+    store i64 0, ptr %ref, align 8
+    store ptr @c_ref_erase_field, ptr %refEraser, align 8
+    store i64 0, ptr %fieldTag, align 8
+    store ptr null, ptr %fieldData_pointer, align 8 
+
+    %refWrap = insertvalue %Pos { i64 0, ptr poison }, ptr %ref, 1
+    ret %Pos %refWrap
   """
 
 /// Creates a new reference with the initial value `init`.
@@ -27,8 +54,20 @@ extern global def ref[T](init: T): Ref[T] =
   js "{ value: ${init} }"
   chez "(box ${init})"
   llvm """
-    %z = call %Pos @c_ref_fresh(%Pos ${init})
-    ret %Pos %z
+    %initTag = extractvalue %Pos ${init}, 0
+    %initObject_pointer = extractvalue %Pos ${init}, 1
+    ; sizeof Header + sizeof Pos = 32
+    %ref = tail call noalias ptr @malloc(i64 noundef 32)
+    %refEraser = getelementptr ptr, ptr %ref, i64 1
+    %refField = getelementptr ptr, ptr %ref, i64 2
+
+    store i64 0, ptr %ref, align 8
+    store ptr @c_ref_erase_field, ptr %refEraser, align 8
+    store %Pos ${init}, ptr %refField, align 8
+
+    %refWrap = insertvalue %Pos { i64 0, ptr poison }, ptr %ref, 1
+
+    ret %Pos %refWrap
   """
   vm "ref::ref[T](T)"
 
@@ -36,9 +75,15 @@ extern global def ref[T](init: T): Ref[T] =
 extern global def get[T](ref: Ref[T]): T =
   js "${ref}.value"
   chez "(unbox ${ref})"
-  llvm """
-    %z = call %Pos @c_ref_get(%Pos ${ref})
-    ret %Pos %z
+llvm """
+    %ref_pointer = extractvalue %Pos ${ref}, 1
+    %refField_pointer = getelementptr inbounds ptr, ptr %ref_pointer, i64 2
+    %refField = load %Pos, ptr %refField_pointer, align 8
+
+    tail call void @sharePositive(%Pos %refField)
+    tail call void @erasePositive(%Pos ${ref})
+
+    ret %Pos %refField
   """
   vm "ref::get[T](Ref[T])"
 
@@ -47,7 +92,15 @@ extern global def set[T](ref: Ref[T], value: T): Unit =
   js "set$impl(${ref}, ${value})"
   chez "(set-box! ${ref} ${value})"
   llvm """
-    %z = call %Pos @c_ref_set(%Pos ${ref}, %Pos ${value})
-    ret %Pos %z
+    %refField_pointer = extractvalue %Pos ${ref}, 1
+
+    %field_pointer = getelementptr ptr, ptr %refField_pointer, i64 2
+    %field = load %Pos, ptr %field_pointer, align 8
+
+    tail call void @erasePositive(%Pos %field)
+    store %Pos ${value}, ptr %field_pointer
+    tail call void @erasePositive(%Pos ${ref}) 
+
+    ret %Pos zeroinitializer
   """
   vm "ref::set[T](Ref[T], T)"

package/libraries/common/stringbuffer.effekt

@@ -14,7 +14,7 @@ def stringBuffer[A] { prog: => A / StringBuffer }: A = {
   var pos = 0
 
   def ensureCapacity(sizeToAdd: Int): Unit = {
-    val cap = buffer.size - pos + 1
+    val cap = buffer.size - pos
     if (sizeToAdd <= cap) ()
     else {
       // Double the capacity while ensuring the required capacity