@effekt-lang/effekt 0.79.0 → 0.80.0

package/libraries/common/io/network.effekt

@@ -182,7 +182,7 @@ namespace internal {
   extern def listen(listener: Int, handler: Connection => Unit at {io, async, global}) at async: Int =
     jsNode "$effekt.capture(k => tcp$listen(${listener}, ${handler}, k))"
     llvm """
-      notail call void @c_tcp_listen(%Int ${listener}, %Pos ${handler}, %Stack %stack)
+      notail call void @c_tcp_listen(%Int ${listener}, %Neg ${handler}, %Stack %stack)
       ret void
     """
 

package/libraries/common/io.effekt

@@ -12,7 +12,7 @@ extern def spawn[T](task: () => T at {io, async, global}) at async: Unit =
   js "$effekt.capture(k => { setTimeout(() => k($effekt.unit), 0); return $effekt.run(${task}) })"
   llvm """
     notail call void @c_yield(%Stack %stack)
-    notail call void @run(%Pos ${task})
+    notail call void @run(%Neg ${task})
     ret void
   """
 

package/libraries/common/process.effekt

@@ -48,7 +48,7 @@ extern def onStdout(opts: SpawnOptions, callback: String => Unit at {io, global}
     };
     return old; })()"""
   llvm """
-    %opts = call %Pos @c_spawn_options_on_stdout(%Pos ${opts}, %Pos ${callback})
+    %opts = call %Pos @c_spawn_options_on_stdout(%Pos ${opts}, %Neg ${callback})
     ret %Pos %opts
   """
 extern def onStderr(opts: SpawnOptions, callback: String => Unit at {io, global}) at {}: SpawnOptions =
@@ -64,7 +64,7 @@ extern def onStderr(opts: SpawnOptions, callback: String => Unit at {io, global}
     };
     return old; })()"""
   llvm """
-    %opts = call %Pos @c_spawn_options_on_stderr(%Pos ${opts}, %Pos ${callback})
+    %opts = call %Pos @c_spawn_options_on_stderr(%Pos ${opts}, %Neg ${callback})
     ret %Pos %opts
   """
 extern type WritableStream =
@@ -84,7 +84,7 @@ extern def withStdin(opts: SpawnOptions, callback: WritableStream => Unit at {io
     return old;
   })()"""
   llvm """
-    %opts = call %Pos @c_spawn_options_pipe_stdin(%Pos ${opts}, %Pos ${callback})
+    %opts = call %Pos @c_spawn_options_pipe_stdin(%Pos ${opts}, %Neg ${callback})
     ret %Pos %opts
   """
 extern def write(to: WritableStream, s: String) at io: Unit =

package/libraries/common/sourcepos.effekt

@@ -0,0 +1,75 @@
+module sourcepos
+import io/error
+import io/filesystem
+import stringbuffer
+import tty
+
+def toGccStyleString(sp: SourcePosition): String = {
+  s"${sp.file}:${sp.startLine.show()}:${sp.startColumn.show()}"
+}
+def toClangStyleString = toGccStyleString
+def toMsvcStyleString(sp: SourcePosition): String = {
+  s"${sp.file}(${sp.startLine.show()},${sp.startColumn.show()})"
+}
+def toPythonStyleString(sp: SourcePosition): String = {
+  s"File \"${sp.file}\", line ${sp.startLine.show()}"
+}
+
+def getSourceLine(file: String, line: Int): String / {Exception[IOError], stop} = {
+  with stringBuffer
+  with readFileUTF8(file)
+  var currentLine = 1
+  while (currentLine < line) {
+    val c = do next()
+    if (c == '\n' || c == '\r') {
+      currentLine += 1
+    }
+  }
+  var c = do next()
+  while (c != '\n' && c != '\r') {
+    do write(c.toString)
+    c = do next()
+  }
+}
+def getSourceText(sp: SourcePosition): String / {Exception[IOError], stop} = {
+  with stringBuffer
+  with readFileUTF8(sp.file)
+  var currentLine = 1
+  var currentColumn = 1
+  while (currentLine < sp.startLine || currentColumn < sp.startColumn) {
+    val c = do next()
+    if (c == '\n' || c == '\r') {
+      currentLine += 1
+      currentColumn = 0
+    }
+  }
+  var c = do next()
+  while (currentLine <= sp.endLine && currentColumn <= sp.endColumn) {
+    do write(c.toString)
+    if (c == '\n' || c == '\r') {
+      currentLine += 1
+      currentColumn = 0
+    }
+    c = do next()
+  }
+}
+
+def getMarkedSource(sp: SourcePosition): String / Formatted = {
+  try {
+    if (sp.startLine == sp.endLine) {
+      val line = getSourceLine(sp.file, sp.startLine)
+      val mline = line.substring(0, sp.startColumn) ++ line.substring(sp.startColumn, sp.endColumn + 1).red ++ line.substring(sp.endColumn + 1)
+      return mline ++ "\n" ++ " ".repeat(sp.startColumn - 1) ++ "^".repeat(sp.endColumn - sp.startColumn)
+    } else {
+      val prefix = getSourceLine(sp.file, sp.startLine).substring(0, sp.startColumn)
+      val suffix = getSourceLine(sp.file, sp.endLine).substring(sp.endColumn + 1)
+      val text = getSourceText(sp)
+      return prefix ++ text.red ++ suffix
+    }
+  } with stop {
+    "(invalid source position)" 
+  } with Exception[IOError] { 
+    def raise(e, m) =
+      "(can't open source file: " ++ m ++ ")"
+  }
+}

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/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
 
@@ -726,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
 }
 
@@ -740,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
@@ -754,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

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);