@effekt-lang/effekt 0.78.0 → 0.80.0

package/libraries/common/test.effekt

@@ -1,102 +1,103 @@
 import tty
 import process
 import bench
+import sourcepos
 
 interface Assertion {
-  def assert(condition: Bool, msg: String): Unit
+  def assert(condition: Bool, msg: String, ?sourcePosition: SourcePosition): Unit
 }
 
-def assertTrue(condition: Bool, msg: String) =
-  do assert(condition, msg)
+def assertTrue(condition: Bool, msg: String, ?sourcePosition: SourcePosition) =
+  do assert(condition, msg, sourcePosition)
 
-def assertTrue(condition: Bool) =
-  do assert(condition, "Assertion failed")
+def assertTrue(condition: Bool, ?sourcePosition: SourcePosition) =
+  do assert(condition, "Assertion failed", sourcePosition)
 
-def assertFalse(condition: Bool, msg: String) =
-  do assert(not(condition), msg)
+def assertFalse(condition: Bool, msg: String, ?sourcePosition: SourcePosition) =
+  do assert(not(condition), msg, sourcePosition)
 
-def assertFalse(condition: Bool) =
-  do assert(not(condition), "Assertion failed")
+def assertFalse(condition: Bool, ?sourcePosition: SourcePosition) =
+  do assert(not(condition), "Assertion failed", sourcePosition)
 
-def assert(obtained: Int, expected: Int, msg: String): Unit / Assertion =
-  assertEqual(obtained, expected, msg) { (x, y) => x == y }
+def assert(obtained: Int, expected: Int, msg: String, ?sourcePosition: SourcePosition): Unit / Assertion =
+  assertEqual(obtained, expected, msg, sourcePosition) { (x, y) => x == y }
 
-def assert(obtained: Bool, expected: Bool, msg: String): Unit / Assertion =
-  assertEqual(obtained, expected, msg) { (x, y) => x == y }
+def assert(obtained: Bool, expected: Bool, msg: String, ?sourcePosition: SourcePosition): Unit / Assertion =
+  assertEqual(obtained, expected, msg, sourcePosition) { (x, y) => x == y }
 
-def assert(obtained: Char, expected: Char, msg: String): Unit / Assertion =
-  assertEqual(obtained, expected, msg) { (x, y) => x == y }
+def assert(obtained: Char, expected: Char, msg: String, ?sourcePosition: SourcePosition): Unit / Assertion =
+  assertEqual(obtained, expected, msg, sourcePosition) { (x, y) => x == y }
 
-def assert(obtained: String, expected: String, msg: String): Unit / Assertion =
-  assertEqual(obtained, expected, msg) { (x, y) => x == y }
+def assert(obtained: String, expected: String, msg: String, ?sourcePosition: SourcePosition): Unit / Assertion =
+  assertEqual(obtained, expected, msg, sourcePosition) { (x, y) => x == y }
 
-def assert(obtained: Int, expected: Int): Unit / { Assertion, Formatted } =
-  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+def assert(obtained: Int, expected: Int, ?sourcePosition: SourcePosition): Unit / { Assertion, Formatted } =
+  assertEqual(obtained, expected, sourcePosition) { (x, y) => x == y } { x => show(x) }
 
-def assert(obtained: Byte, expected: Byte): Unit / { Assertion, Formatted } =
-  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+def assert(obtained: Byte, expected: Byte, ?sourcePosition: SourcePosition): Unit / { Assertion, Formatted } =
+  assertEqual(obtained, expected, sourcePosition) { (x, y) => x == y } { x => show(x) }
 
-def assert(obtained: Bool, expected: Bool): Unit / { Assertion, Formatted } =
-  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+def assert(obtained: Bool, expected: Bool, ?sourcePosition: SourcePosition): Unit / { Assertion, Formatted } =
+  assertEqual(obtained, expected, sourcePosition) { (x, y) => x == y } { x => show(x) }
 
-def assert(obtained: Char, expected: Char): Unit / { Assertion, Formatted } =
-  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+def assert(obtained: Char, expected: Char, ?sourcePosition: SourcePosition): Unit / { Assertion, Formatted } =
+  assertEqual(obtained, expected, sourcePosition) { (x, y) => x == y } { x => show(x) }
 
-def assert(obtained: String, expected: String): Unit / { Assertion, Formatted } =
-  assertEqual(obtained, expected) { (x, y) => x == y } { x => show(x) }
+def assert(obtained: String, expected: String, ?sourcePosition: SourcePosition): Unit / { Assertion, Formatted } =
+  assertEqual(obtained, expected, sourcePosition) { (x, y) => x == y } { x => show(x) }
 
-def assertEqual[A](obtained: A, expected: A, msg: String): Unit / Assertion =
-  assertEqual(obtained, expected, msg) { (x, y) => x.genericEquals(y) }
+def assertEqual[A](obtained: A, expected: A, msg: String, ?sourcePosition: SourcePosition): Unit / Assertion =
+  assertEqual(obtained, expected, msg, sourcePosition) { (x, y) => x.genericEquals(y) }
 
-def assertEqual[A](obtained: A, expected: A): Unit / { Assertion, Formatted } =
-  assertEqual(obtained, expected) { (x, y) => x.genericEquals(y) } { x => x.genericShow }
+def assertEqual[A](obtained: A, expected: A, ?sourcePosition: SourcePosition): Unit / { Assertion, Formatted } =
+  assertEqual(obtained, expected, sourcePosition) { (x, y) => x.genericEquals(y) } { x => x.genericShow }
 
-def assertEqual[A](obtained: A, expected: A, msg: String) { equals: (A, A) => Bool }: Unit / Assertion =
-  do assert(equals(obtained, expected), msg)
+def assertEqual[A](obtained: A, expected: A, msg: String, ?sourcePosition: SourcePosition) { equals: (A, A) => Bool }: Unit / Assertion =
+  do assert(equals(obtained, expected), msg, sourcePosition)
 
-def assertEqual[A](obtained: A, expected: A) { equals: (A, A) => Bool } { show: A => String }: Unit / { Assertion, Formatted } =
-  do assert(equals(obtained, expected), Formatted::tryEmit(Escape::RESET) ++ "Expected: ".dim ++ show(expected).green ++ "\n  Obtained: ".dim ++ show(obtained).red)
+def assertEqual[A](obtained: A, expected: A, ?sourcePosition: SourcePosition) { equals: (A, A) => Bool } { show: A => String }: Unit / { Assertion, Formatted } =
+  do assert(equals(obtained, expected), Formatted::tryEmit(Escape::RESET) ++ "Expected: ".dim ++ show(expected).green ++ "\n  Obtained: ".dim ++ show(obtained).red, sourcePosition)
   // NOTE:                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   //             Here's an accidental capture! Can we prevent this somehow nicely?
 
-def assertNotThrown[E](ex: on[E]) { body: => Unit / Exception[E] }: Unit / Assertion =
-  ex.default { do assert(false, "Unexpected Exception") } {body}
+def assertNotThrown[E](ex: on[E], ?sourcePosition: SourcePosition) { body: => Unit / Exception[E] }: Unit / Assertion =
+  ex.default { do assert(false, "Unexpected Exception", sourcePosition) } {body}
 
-def assertNoThrow[E] { body: => Unit / Exception[E] }: Unit / Assertion =
-  on[E].default{ do assert(false, "Unexpected Exception") } {body}
+def assertNoThrow[E](?sourcePosition: SourcePosition) { body: => Unit / Exception[E] }: Unit / Assertion =
+  on[E].default{ do assert(false, "Unexpected Exception", sourcePosition) } {body}
 
-def assertThrown[E](ex: on[E]) { body: => Unit / Exception[E] }: Unit / Assertion =
-  do assert(ex.default { true } { body(); false }, "Expected Exception, but exited normally")
+def assertThrown[E](ex: on[E], ?sourcePosition: SourcePosition) { body: => Unit / Exception[E] }: Unit / Assertion =
+  do assert(ex.default { true } { body(); false }, "Expected Exception, but exited normally", sourcePosition)
 
-def assertThrows[E] { body: => Unit / Exception[E] }: Unit / Assertion =
-  do assert(on[E].default { true } { body(); false }, "Expected Exception, but exited normally")
+def assertThrows[E](?sourcePosition: SourcePosition) { body: => Unit / Exception[E] }: Unit / Assertion =
+  do assert(on[E].default { true } { body(); false }, "Expected Exception, but exited normally", sourcePosition)
 
-def assertFail { body: => Unit / fail }: Unit / Assertion =
-  do assert(succeeds {body}, "Expected 'fail', but exited normally")
+def assertFail(?sourcePosition: SourcePosition) { body: => Unit / fail }: Unit / Assertion =
+  do assert(succeeds {body}, "Expected 'fail', but exited normally", sourcePosition)
 
-def assertNoFail { body: => Unit / fail }: Unit / Assertion =
-  onFail { do assert(false, "Unexpected 'fail'") } {body}
+def assertNoFail(?sourcePosition: SourcePosition) { body: => Unit / fail }: Unit / Assertion =
+  onFail { do assert(false, "Unexpected 'fail'", sourcePosition) } {body}
 
 
 interface Test {
-  def success(name: String, duration: Int): Unit
-  def failure(name: String, msg: String, duration: Int): Unit
+  def success(name: String, duration: Int, ?sourcePosition: SourcePosition): Unit
+  def failure(name: String, msg: String, duration: Int, ?sourcePosition: SourcePosition): Unit
 }
 
 /// Runs the `body` as a test under the given `name`
 /// See `suite` for examples.
-def test(name: String) { body: => Unit / Assertion } = {
+def test(name: String, ?sourcePosition: SourcePosition) { body: => Unit / Assertion } = {
   val startTime = bench::relativeTimestamp()
   try {
     body()
     val duration = Duration::diff(startTime, bench::relativeTimestamp())
-    do success(name, duration)
+    do success(name, duration, sourcePosition)
   } with Assertion {
-    def assert(condition, msg) =
+    def assert(condition, msg, assertSourcePosition) =
       if (condition) resume(())
       else {
         val duration = Duration::diff(startTime, bench::relativeTimestamp())
-        do failure(name, msg, duration)
+        do failure(name, msg, duration, assertSourcePosition)
       }
   }
 }
@@ -138,17 +139,17 @@ def suite(name: String, printTimes: Bool) { body: => Unit / { Test, Formatted }
   val totalDuration = timed {
     try { body() } with Test {
       // 2a) Handle a passing test on success
-      def success(name, duration) = {
+      def success(name, duration, sourcePosition) = {
         passed = passed + 1
         println("✓".green ++ " " ++ name ++ duration.ms)
         resume(())
       }
 
       // 2b) Handle a failing test on failure, additionally printing its message
-      def failure(name, msg, duration) = {
+      def failure(name, msg, duration, sourcePosition) = {
         failed = failed + 1
         println("✕".red ++ " " ++ name ++ duration.ms)
-        println("  " ++ msg.red)
+        println("  " ++ msg.red ++ " at " ++ sourcePosition.toGccStyleString())
         resume(())
       }
     }

package/libraries/js/effekt_runtime.js

@@ -58,6 +58,7 @@ class Arena {
 }
 
 function snapshot(s) {
+  if (s === null) return null
   const snap = { store: s, root: s.root, generation: s.generation }
   s.generation = s.generation + 1
   return snap
@@ -85,9 +86,13 @@ function reroot(target) {
     node.value   = Mem
     cur          = node
   }
+
+  // 3. Reclaim the path to reuse the buffer eagerly
+  _rerootPath.length = 0
 }
 
 function restore(store, snap) {
+  if (snap === null) return // nothing saved ~> nothing to restore
   if (snap.root.value !== Mem) {
     // fast path: continuation is resumed immediately with no writes in between
     reroot(snap.root)
@@ -99,7 +104,18 @@ function restore(store, snap) {
 // Common Runtime
 // --------------
 const TOPLEVEL_K = (x, ks) => { throw { computationIsDone: true, result: x } }
-const TOPLEVEL_KS = { stack: null, prompt: Symbol("toplevel"), arena: new Arena(), rest: null }
+const TOPLEVEL_KS = { stack: null, prompt: Symbol("toplevel"), arena: null, rest: null }
+
+// The first variable in a scope creates its arena; until then `ks.arena` is null.
+function VAR(init, ks) {
+  const arena = ks.arena !== null ? ks.arena : (ks.arena = new Arena())
+  return arena.fresh(init)
+}
+
+function REGION(ks) {
+  const arena = ks.arena !== null ? ks.arena : (ks.arena = new Arena())
+  return arena.newRegion()
+}
 
 function THUNK(f) {
   f.thunk = true
@@ -109,7 +125,7 @@ function THUNK(f) {
 function CAPTURE(body) {
   return (ks, k) => {
     const res = body(x => TRAMPOLINE(() => k(x, ks)))
-    if (res instanceof Function) return res
+    if (typeof res === "function") return res
     else throw { computationIsDone: true, result: $effekt.unit }
   }
 }
@@ -120,7 +136,7 @@ const RETURN = (x, ks) => ks.rest.stack(x, ks.rest)
 function RESET(prog, ks, k) {
   const prompt = Symbol(); // gensym
   const rest = { stack: k, prompt: ks.prompt, arena: ks.arena, rest: ks.rest }
-  return prog(prompt, { stack: null, prompt, arena: new Arena(), rest }, RETURN)
+  return prog(prompt, { stack: null, prompt, arena: null, rest }, RETURN)
 }
 
 function SHIFT(p, body, ks, k) {

package/libraries/llvm/bytearray.c

@@ -77,7 +77,7 @@ struct Pos c_bytearray_construct(const uint64_t n, const uint8_t *data) {
 
 struct Pos c_bytearray_from_nullterminated_string(const char *data) {
     uint64_t n = 0;
-    while (data[++n]);
+    while (data[n]) n++;
 
     return c_bytearray_construct(n, (uint8_t*)data);
 }

package/libraries/llvm/io.c

@@ -383,18 +383,18 @@ Int c_tcp_bind(String host, Int port) {
 
 typedef struct {
     Stack stack;
-    struct Pos handler;
+    struct Neg handler;
 } tcp_listen_closure_t;
 
 void c_tcp_listen_cb(uv_stream_t* server, int status) {
     tcp_listen_closure_t* listen_closure = (tcp_listen_closure_t*)server->data;
     Stack closure_stack = listen_closure->stack;
-    struct Pos closure_handler = listen_closure->handler;
+    struct Neg closure_handler = listen_closure->handler;
 
     if (status < 0) {
         server->data = NULL;
         free(listen_closure);
-        erasePositive(closure_handler);
+        eraseNegative(closure_handler);
         resume_Int(closure_stack, status);
         return;
     }
@@ -406,7 +406,7 @@ void c_tcp_listen_cb(uv_stream_t* server, int status) {
         free(client);
         server->data = NULL;
         free(listen_closure);
-        erasePositive(closure_handler);
+        eraseNegative(closure_handler);
         resume_Int(closure_stack, result);
         return;
     }
@@ -416,16 +416,16 @@ void c_tcp_listen_cb(uv_stream_t* server, int status) {
         uv_close((uv_handle_t*)client, (uv_close_cb)free);
         server->data = NULL;
         free(listen_closure);
-        erasePositive(closure_handler);
+        eraseNegative(closure_handler);
         resume_Int(closure_stack, result);
         return;
     }
 
-    sharePositive(closure_handler);
+    shareNegative(closure_handler);
     run_Int(closure_handler, (int64_t)client);
 }
 
-void c_tcp_listen(Int listener, struct Pos handler, Stack stack) {
+void c_tcp_listen(Int listener, struct Neg handler, Stack stack) {
     uv_stream_t* server = (uv_stream_t*)listener;
 
     tcp_listen_closure_t* listen_closure = malloc(sizeof(tcp_listen_closure_t));
@@ -436,7 +436,7 @@ void c_tcp_listen(Int listener, struct Pos handler, Stack stack) {
     int result = uv_listen(server, SOMAXCONN, c_tcp_listen_cb);
     if (result < 0) {
         free(listen_closure);
-        erasePositive(handler);
+        eraseNegative(handler);
         resume_Int(stack, result);
         return;
     }
@@ -451,9 +451,9 @@ void c_tcp_shutdown(Int handle, Stack stack) {
 
     if (listen_closure) {
         Stack closure_stack = listen_closure->stack;
-        struct Pos closure_handler = listen_closure->handler;
+        struct Neg closure_handler = listen_closure->handler;
         free(listen_closure);
-        erasePositive(closure_handler);
+        eraseNegative(closure_handler);
         resume_Int(closure_stack, 0);
     }
 }
@@ -601,7 +601,7 @@ static void subproc_alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_
 }
 
 typedef struct {
-  struct Pos handler;
+  struct Neg handler;
 } subproc_stream_cb_closure_t;
 void subproc_stream_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
   subproc_stream_cb_closure_t* clos = (subproc_stream_cb_closure_t*)(stream->data);
@@ -611,12 +611,12 @@ void subproc_stream_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf)
     run_Pos(clos->handler, chunk);
   } else {
     uv_read_stop(stream);
-    erasePositive(clos->handler);
+    eraseNegative(clos->handler);
     free(clos);
     if (buf->base) free(buf->base);
   }
 }
-struct Pos subproc_options_on_stream(struct Pos opts, size_t id, uv_stdio_flags flags, struct Pos callback) {
+struct Pos subproc_options_on_stream(struct Pos opts, size_t id, uv_stdio_flags flags, struct Neg callback) {
     uv_process_options_t* options = (uv_process_options_t*)opts.obj;
 
     options->stdio[id].flags = UV_CREATE_PIPE | flags;
@@ -631,13 +631,13 @@ struct Pos subproc_options_on_stream(struct Pos opts, size_t id, uv_stdio_flags
 
     return opts;
 }
-struct Pos c_spawn_options_on_stdout(struct Pos opts, struct Pos callback) {
+struct Pos c_spawn_options_on_stdout(struct Pos opts, struct Neg callback) {
   return subproc_options_on_stream(opts, 1, UV_WRITABLE_PIPE, callback);
 }
-struct Pos c_spawn_options_on_stderr(struct Pos opts, struct Pos callback) {
+struct Pos c_spawn_options_on_stderr(struct Pos opts, struct Neg callback) {
   return subproc_options_on_stream(opts, 2, UV_WRITABLE_PIPE, callback);
 }
-struct Pos c_spawn_options_pipe_stdin(struct Pos opts, struct Pos callback) {
+struct Pos c_spawn_options_pipe_stdin(struct Pos opts, struct Neg callback) {
   return subproc_options_on_stream(opts, 0, UV_READABLE_PIPE, callback);
 }
 
@@ -754,7 +754,7 @@ void c_spawn(struct Pos cmd, struct Pos args, struct Pos options, Stack stack) {
         subproc_stream_cb_closure_t* clos = (subproc_stream_cb_closure_t*)(stream->data);
         struct Pos str = (struct Pos) { .tag = 0, .obj = stream, };
         run_Pos(clos->handler, str);
-        erasePositive(clos->handler);
+        eraseNegative(clos->handler);
         free(clos);
     }
     if(opts->stdio[1].flags & UV_CREATE_PIPE)

package/libraries/llvm/rts.ll

@@ -91,9 +91,6 @@
 %Double = type double
 %Byte = type i8
 %Char = type i64
-%Bool = type %Pos
-%Unit = type %Pos
-%String = type %Pos
 
 ; Foreign imports
 
@@ -101,7 +98,7 @@ declare ptr @malloc(i64)
 declare void @free(ptr)
 declare ptr @realloc(ptr, i64)
 declare noalias ptr @calloc(i64, i64)
-declare void @memcpy(ptr, ptr, i64)
+declare ptr @memcpy(ptr, ptr, i64)
 declare i64 @llvm.ctlz.i64 (i64 , i1)
 declare i64 @llvm.fshr.i64(i64, i64, i64)
 declare double @llvm.sqrt.f64(double)
@@ -117,8 +114,7 @@ declare double @log1p(double)
 ; Intrinsic versions of the following two only added in LLVM 19
 declare double @atan(double)
 declare double @tan(double)
-declare void @print(i64)
-declare void @exit(i64)
+declare void @exit(i32)
 declare void @llvm.assume(i1)
 
 
@@ -162,7 +158,7 @@ define private void @shareObject(%Object %object) alwaysinline {
 
     next:
     %objectReferenceCount = getelementptr %Header, ptr %object, i64 0, i32 0
-    %referenceCount = load %ReferenceCount, ptr %objectReferenceCount, !alias.scope !14, !noalias !24
+    %referenceCount = load %ReferenceCount, ptr %objectReferenceCount, !alias.scope !14, !noalias !24, !range !41
     %referenceCount.1 = add %ReferenceCount %referenceCount, 1
     store %ReferenceCount %referenceCount.1, ptr %objectReferenceCount, !alias.scope !14, !noalias !24
     br label %done
@@ -189,7 +185,7 @@ define private void @eraseObject(%Object %object) alwaysinline {
 
     next:
     %objectReferenceCount = getelementptr %Header, ptr %object, i64 0, i32 0
-    %referenceCount = load %ReferenceCount, ptr %objectReferenceCount, !alias.scope !14, !noalias !24
+    %referenceCount = load %ReferenceCount, ptr %objectReferenceCount, !alias.scope !14, !noalias !24, !range !41
     switch %ReferenceCount %referenceCount, label %decr [%ReferenceCount 0, label %free]
 
     decr:
@@ -334,10 +330,8 @@ realloc:
 
 define private %StackPointer @stackAllocate(%Stack %stack, i64 %n) alwaysinline {
     %stackPointer_pointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 1
-    %limit_pointer = getelementptr %StackValue, %Stack %stack, i64 0, i32 2
 
     %currentStackPointer = load %StackPointer, ptr %stackPointer_pointer, !alias.scope !11, !noalias !21
-    %limit = load %Limit, ptr %limit_pointer, !alias.scope !11, !noalias !21
     %nextStackPointer = getelementptr i8, %StackPointer %currentStackPointer, i64 %n
 
     store %StackPointer %nextStackPointer, ptr %stackPointer_pointer, !alias.scope !11, !noalias !21
@@ -486,7 +480,7 @@ define private {%Resumption, %Stack} @shift(%Stack %stack, %Prompt %prompt) {
 
 define private void @erasePrompt(%Prompt %prompt) alwaysinline {
     %referenceCount_pointer = getelementptr %PromptValue, %Prompt %prompt, i64 0, i32 0
-    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !13, !noalias !23
+    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !13, !noalias !23, !range !41
     switch %ReferenceCount %referenceCount, label %decrement [%ReferenceCount 0, label %free]
 
 decrement:
@@ -501,7 +495,7 @@ free:
 
 define private void @sharePrompt(%Prompt %prompt) alwaysinline {
     %referenceCount_pointer = getelementptr %PromptValue, %Prompt %prompt, i64 0, i32 0
-    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !13, !noalias !23
+    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !13, !noalias !23, !range !41
     %newReferenceCount = add %ReferenceCount %referenceCount, 1
     store %ReferenceCount %newReferenceCount, ptr %referenceCount_pointer, !alias.scope !13, !noalias !23
     ret void
@@ -544,7 +538,7 @@ define private %Stack @copyStack(%Stack %stack) alwaysinline {
     %newStackPointer = getelementptr i8, %Stack %newStack, i64 %used
     %newLimit = getelementptr i8, %Stack %newStack, i64 %size
 
-    call void @memcpy(ptr %newStack, ptr %stack, i64 %used)
+    %copied = call ptr @memcpy(ptr %newStack, ptr %stack, i64 %used)
 
     %newStackPointer_pointer = getelementptr %StackValue, %Stack %newStack, i64 0, i32 1
     %newLimit_pointer = getelementptr %StackValue, %Stack %newStack, i64 0, i32 2
@@ -569,7 +563,7 @@ define private %Resumption @uniqueStack(%Resumption %resumption) alwaysinline {
 
 entry:
     %referenceCount_pointer = getelementptr %StackValue, %Resumption %resumption, i64 0, i32 0
-    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !11, !noalias !21
+    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !11, !noalias !21, !range !41
     switch %ReferenceCount %referenceCount, label %copy [%ReferenceCount 0, label %done]
 
 done:
@@ -613,7 +607,7 @@ stop:
 
 define void @shareResumption(%Resumption %resumption) alwaysinline {
     %referenceCount_pointer = getelementptr %StackValue, %Resumption %resumption, i64 0, i32 0
-    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !11, !noalias !21
+    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !11, !noalias !21, !range !41
     %referenceCount.1 = add %ReferenceCount %referenceCount, 1
     store %ReferenceCount %referenceCount.1, ptr %referenceCount_pointer, !alias.scope !11, !noalias !21
     ret void
@@ -621,7 +615,7 @@ define void @shareResumption(%Resumption %resumption) alwaysinline {
 
 define void @eraseResumption(%Resumption %resumption) alwaysinline {
     %referenceCount_pointer = getelementptr %StackValue, %Resumption %resumption, i64 0, i32 0
-    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !11, !noalias !21
+    %referenceCount = load %ReferenceCount, ptr %referenceCount_pointer, !alias.scope !11, !noalias !21, !range !41
     switch %ReferenceCount %referenceCount, label %decr [%ReferenceCount 0, label %free]
 
     decr:
@@ -729,9 +723,11 @@ define private %Stack @withEmptyStack() {
     ret %Stack %stack
 }
 
-define ccc void @resume_Int(%Stack %stack, %Int %integer) {
-    %argument = call ccc %Pos @coerceIntPos(%Int %integer)
-    call ccc void @resume_Pos(%Stack %stack, %Pos %argument)
+define ccc void @resume_Int(%Stack %stack, %Int %argument) {
+    %stackPointer = call ccc %StackPointer @stackDeallocate(%Stack %stack, i64 24)
+    %returnAddressPointer = getelementptr %FrameHeader, %StackPointer %stackPointer, i64 0, i32 0
+    %returnAddress = load %ReturnAddress, ptr %returnAddressPointer, !alias.scope !12, !noalias !22
+    tail call tailcc void %returnAddress(%Int %argument, %Stack %stack)
     ret void
 }
 
@@ -743,9 +739,7 @@ define ccc void @resume_Pos(%Stack %stack, %Pos %argument) {
     ret void
 }
 
-define ccc void @run(%Pos %boxed) {
-
-    %function = call %Neg @coercePosNeg(%Pos %boxed)
+define ccc void @run(%Neg %function) {
     %stack = call %Stack @withEmptyStack()
 
     %arrayPointer = extractvalue %Neg %function, 0
@@ -757,15 +751,19 @@ define ccc void @run(%Pos %boxed) {
     ret void
 }
 
-define ccc void @run_Int(%Pos %boxed, %Int %integer) {
-    %argument = call ccc %Pos @coerceIntPos(%Int %integer)
-    call ccc %Pos @run_Pos(%Pos %boxed, %Pos %argument)
+define ccc void @run_Int(%Neg %function, %Int %argument) {
+    %stack = call %Stack @withEmptyStack()
+
+    %arrayPointer = extractvalue %Neg %function, 0
+    %object = extractvalue %Neg %function, 1
+    %functionPointerPointer = getelementptr ptr, ptr %arrayPointer, i64 0
+    %functionPointer = load ptr, ptr %functionPointerPointer, !alias.scope !15, !noalias !25
+
+    tail call tailcc %Pos %functionPointer(%Object %object, %Int %argument, %Stack %stack)
     ret void
 }
 
-define ccc void @run_Pos(%Pos %boxed, %Pos %argument) {
-
-    %function = call ccc %Neg @coercePosNeg(%Pos %boxed)
+define ccc void @run_Pos(%Neg %function, %Pos %argument) {
     %stack = call %Stack @withEmptyStack()
 
     %arrayPointer = extractvalue %Neg %function, 0
@@ -914,4 +912,7 @@ define ccc %CObject @coercePosObj(%Pos %input) {
 !22 = !{!1,     !3, !4, !5} ; not stackPointer
 !23 = !{!1, !2,     !4, !5} ; not prompt
 !24 = !{!1, !2, !3,     !5} ; not object
-!25 = !{!1, !2, !3, !4    } ; not vtable
+!25 = !{!1, !2, !3, !4    } ; not vtable
+
+; Ranges
+!41 = !{i64 0, i64 9223372036854775807} ; positive i64

package/libraries/llvm/types.c

@@ -38,9 +38,9 @@ typedef struct StackValue* Stack;
 extern void resume_Int(Stack, Int);
 extern void resume_Pos(Stack, struct Pos);
 
-extern void run(struct Pos);
-extern void run_Int(struct Pos, Int);
-extern void run_Pos(struct Pos, struct Pos);
+extern void run(struct Neg);
+extern void run_Int(struct Neg, Int);
+extern void run_Pos(struct Neg, struct Pos);
 
 // Reference counting primitives defined in LLVM
 extern void eraseNegative(struct Neg);