@effekt-lang/effekt 0.78.0 → 0.79.0

package/libraries/common/map.effekt

@@ -80,19 +80,13 @@ def get[K, V](m: Map[K, V], k: K): Option[V] = internal::get(m.tree, m.compare,
 ///
 /// O(log N)
 def getOrElse[K, V](m: Map[K, V], k: K) { default: => V }: V =
-  internal::get(m.tree, m.compare, k) match {
-    case None() => default()
-    case Some(v) => v
-  }
+  internal::getOrElse(m.tree, m.compare, k) {default}
 
 /// Check if map `m` contains a key `k`.
 ///
 /// O(log N)
 def contains[K, V](m: Map[K, V], k: K): Bool =
-  internal::get(m.tree, m.compare, k) match {
-    case None() => false
-    case Some(_) => true
-  }
+  internal::contains(m.tree, m.compare, k)
 
 /// Get minimum in the map `m`.
 ///
@@ -354,15 +348,10 @@ def collect[K, V](?compare: (K, K) => Ordering at {}) { stream: () => Unit / emi
 namespace returning {
   /// Collects `(key, value)` pairs from a push stream producer `stream` into a new `map`,
   /// using the provided `compare` function, returning the result of the producer as well as the collected map.
-  def collect[K, V, R](?compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Map[K, V]) =
-    var map = map::empty[K, V](compare)
-    val r = try {
-      stream()
-    } with emit[(K, V)] { case (k, v) =>
-      map = map.put(k, v)
-      resume(())
-    }
-    (r, map)
+  def collect[K, V, R](?compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Map[K, V]) = {
+    val (r, tree) = internal::collect[K, V, R](compare) {stream}
+    (r, Map(tree, compare))
+  }
 }
 
 // Internal tree representation
@@ -417,6 +406,33 @@ namespace internal {
       case Bin(size, _, _, _, _) => size
     }
 
+  /// Look up `k` in the tree `m`, handing the value it is bound to to `found`,
+  /// or running `missing` if there is none.
+  ///
+  /// O(log N)
+  def getWith[K, V, R](m: Tree[K, V], compare: (K, K) => Ordering at {}, k: K) { found: V => R } { missing: => R }: R =
+    m match {
+      case Tip() => missing()
+      case Bin(_, k2, v, l, r) =>
+        compare(k, k2) match {
+          case Less() => getWith(l, compare, k) {found} {missing}
+          case Greater() => getWith(r, compare, k) {found} {missing}
+          case Equal() => found(v)
+        }
+    }
+
+  /// Whether the tree `m` binds the key `k`.
+  ///
+  /// O(log N)
+  def contains[K, V](m: Tree[K, V], compare: (K, K) => Ordering at {}, k: K): Bool =
+    getWith(m, compare, k) { _v => true } { false }
+
+  /// The value bound to `k` in the tree `m`, or `default` if there is none.
+  ///
+  /// O(log N)
+  def getOrElse[K, V](m: Tree[K, V], compare: (K, K) => Ordering at {}, k: K) { default: => V }: V =
+    getWith(m, compare, k) { v => v } {default}
+
   /// Insert a new key `k` and value `v` into the tree `m`.
   /// If the key `k` is already present in `m`, its associated value is replaced with `v`.
   ///
@@ -451,15 +467,7 @@ namespace internal {
   ///
   /// O(log N)
   def get[K, V](m: Tree[K, V], compare: (K, K) => Ordering at {}, k: K): Option[V] =
-    m match {
-      case Tip() => None()
-      case Bin(size, k2, v, l, r) =>
-        compare(k, k2) match {
-          case Less() => get(l, compare, k)
-          case Greater() => get(r, compare, k)
-          case Equal() => Some(v)
-        }
-    }
+    getWith(m, compare, k) { v => Some(v) } { None() }
 
   /// Get minimum in the tree `m`.
   ///
@@ -600,98 +608,184 @@ namespace internal {
     go(m)
   }
 
+  /// A balanced subtree waiting to be joined, and the key separating it from the pairs collected after it.
+  ///
+  /// A list of these is the *right* spine of the tree being built.
+  /// Their sizes strictly increase towards the back, so the list is the digits of a binary counter.
+  record Waiting[K, V](size: Int, key: K, value: V, tree: Tree[K, V])
+
+  /// Collect `(key, value)` pairs from a push stream producer `stream` into a tree,
+  /// returning the result of the producer as well.
+  /// Consider using `map::fromList` if you know the full list.
+  ///
+  /// O(N) if the stream is sorted by key (in _either_ direction),
+  /// O(N log N) otherwise
+  def collect[K, V, R](compare: (K, K) => Ordering at {}) { stream: () => R / emit[(K, V)] }: (R, Tree[K, V]) = {
+    // Note that `fromList` is always better since it knows the whole list of pairs in advance,
+    // whereas we have to be streaming here. Otherwise the functions are very similar...
+
+    // The lowest digit of the binary counter is a lone pair, kept as the leaf it will one day become. :)
+    var lowest: Tree[K, V] = Tip()
+    var spine: List[Waiting[K, V]] = Nil()
+    var tree = Tip()
+    // which way the current run is going; is `Equal` once a monotone run is over
+    var direction: Ordering = Less()
+
+    // How the currently collected pair compares with the one collected last.
+    def compareLast(k: K): Ordering =
+      lowest match {
+        case Bin(_, previous, _, _, _) => compare(previous, k)
+        case Tip() => spine match {
+          case Nil() => Less()
+          case Cons(Waiting(_, previous, _, _), _) => compare(previous, k)
+        }
+      }
+
+    // Give the pair collected last a new value, overwriting the existing one.
+    def rebind(v: V): Unit =
+      lowest match {
+        case Bin(_, k, _, _, _) =>
+          lowest = singleton(k, v)
+        case Tip() => spine match {
+          case Nil() => ()
+          case Cons(Waiting(size, k, _, tree), more) =>
+            spine = Cons(Waiting(size, k, v, tree), more)
+        }
+      }
+
+    // Increment the binary counter: carry while the next subtree has the same size.
+    def extend(k: K, v: V): Unit = {
+      def carry(size: Int, subtree: Tree[K, V], rest: List[Waiting[K, V]]): List[Waiting[K, V]] =
+        rest match {
+          case Nil() => [Waiting(size, k, v, subtree)]
+          case Cons(Waiting(s, k2, v2, t), more) =>
+            if (s == size) {
+              val merged = if (direction is Greater()) bin(k2, v2, subtree, t) else bin(k2, v2, t, subtree)
+              carry(2 * size + 1, merged, more)
+            } else {
+              Cons(Waiting(size, k, v, subtree), rest)
+            }
+        }
+
+      lowest match {
+        case Tip() => lowest = singleton(k, v)
+        case Bin(_, _, _, _, _) =>
+          val leaf = lowest
+          lowest = Tip()
+          spine = carry(1, leaf, spine)
+      }
+    }
+
+    def joinSpineWith(spine: List[Waiting[K, V]], whole: Tree[K, V]): Tree[K, V] =
+      spine match {
+        case Nil() => whole
+        case Cons(Waiting(_, k, v, subtree), more) =>
+          val joined = if (direction is Greater()) link(k, v, whole, subtree) else link(k, v, subtree, whole)
+          more.joinSpineWith(joined)
+      }
+
+    val result = try {
+      stream()
+    } with emit[(K, V)] { case (k, v) =>
+      // as long as the keys all keep going the same way, we can build a tree in O(N) time
+      direction match {
+        // the run is over, so we have to insert each new pair without a shortcut
+        case Equal() => tree = tree.put(compare, k, v)
+        case _ =>
+          (compareLast(k), direction) match {
+            case (Equal(), _) => rebind(v)
+            case (Less(), Less()) => extend(k, v)
+            case (Greater(), Greater()) => extend(k, v)
+            case (ordering, _) =>
+              // the new key goes against the run:
+              if (spine is Nil()) {
+                // - if it's the first pair, we just set the direction
+                direction = ordering
+                extend(k, v)
+              } else {
+                // - if it's not the first pair, we have to join up the run and use the slow path
+                tree = spine.joinSpineWith(lowest).put(compare, k, v)
+                direction = Equal()
+              }
+          }
+      }
+
+      resume(())
+    }
+
+    (result, if (direction is Equal()) tree else spine.joinSpineWith(lowest))
+  }
+
   /// Create a tree from a list of (key, value) pairs.
   /// If the list contains more than one value for the same key,
   /// only the last value is used in the tree.
   ///
-  /// O(N) if the list is sorted by key,
+  /// O(N) if the list is sorted by key (in _either_ direction),
   /// O(N log N) otherwise
-  def fromList[K, V](pairs: List[(K, V)], compare: (K, K) => Ordering at {}): Tree[K, V] = {
+  def fromList[K, V](pairs: List[(K, V)], compare: (K, K) => Ordering at {}): Tree[K, V] =
     pairs match {
       case Nil() => Tip()
       case Cons((k, v), Nil()) => singleton(k, v)
-      case Cons((k, v), rest) =>
-        // TODO: this function should really, **really** get inlined!
-        def notOrdered(k: K, pairs: List[(K, V)]) = {
-          pairs match {
-            case Nil() => false
-            case Cons((k2, _), _) =>  // k >= k2
-              compare(k, k2) match {
-                case Less() => false
-                case Greater() => true
-                case Equal() => true
+      case Cons(_, _) =>
+        // the first pair not yet taken, and whether the run repeated a key
+        var rest = pairs
+        var repeated = false
+        // which way the current run is going; is `Equal` once a monotone run is over
+        var direction: Ordering = Equal()
+
+        // How many distinct keys the non-decreasing run at the front of `ps` holds.
+        def runLength(ps: List[(K, V)], count: Int): Int =
+          ps match {
+            case Nil() => count
+            case Cons((k, _), tail) => tail match { // note: tail is effectivelly an @-pattern!
+              case Nil() => count + 1
+              case Cons((next, _), _) => (compare(k, next), direction) match {
+                case (Less()   , Less()   ) => runLength(tail, count + 1)
+                case (Greater(), Greater()) => runLength(tail, count + 1)
+                case (Equal(), _) => repeated = true; runLength(tail, count)
+
+                // the first comparison that is not `Equal` settles which way we go
+                case (ordering, Equal()) => direction = ordering; runLength(tail, count + 1)
+                case _ => count + 1
               }
+            }
           }
-        }
 
-        // Naive insertion, used for the worst-case scenario when the list is not sorted by key
-        def insertMany(m: Tree[K, V], pairs: List[(K, V)]) = {
-          var treeSoFar = m
-          pairs.foreach { case (k, v) =>
-            treeSoFar = treeSoFar.put(compare, k, v)
+        // Advance `rest` past any repeats of `k`, giving back the last binding of it.
+        def lastBinding(k: K, v: V): V =
+          if (rest is Cons((next, value), tail) and compare(k, next) is Equal()) {
+            rest = tail
+            lastBinding(k, value)
+          } else {
+            v
           }
-          treeSoFar
-        }
 
-        // Returns a triple `(tree, xs, ys)`
-        //
-        // Invariant: At least one of `xs`, `ys` is empty.
-        // Moreover, if `ys` is nonempty, its keys are **not** ordered!
-        // Otherwise, all of the seen keys have been ordered so far.
-        //
-        // TODO: Possibly use a better type to encode the invariant?
-        def create(level: Int, pairs: List[(K, V)]): (Tree[K, V], List[(K, V)], List[(K, V)]) = {
-          pairs match {
-            case Nil() => (Tip(), [], [])
-            case Cons((k, v), rest) =>
-              if (level == 1) {
-                val one = singleton(k, v)
-                if (notOrdered(k, rest)) {
-                  (one, [], rest)
-                } else {
-                  (one, rest, [])
-                }
-              } else {
-                val res = create(level.bitwiseShr(1), pairs)
-                res match {
-                  case (_, Nil(), _) => res
-                  case (l, Cons((k2, v2), Nil()), zs) => (l.putMax(k2, v2), [], zs)
-                  case (l, Cons((k2, v2), rest2), _) =>
-                    // @-pattern
-                    val xs = Cons((k2, v2), rest2)
-
-                    if (notOrdered(k2, rest2)) { (l, [], xs) }
-                    else {
-                      val (r, zs, ws) = create(level.bitwiseShr(1), rest2);
-                      (link(k2, v2, l, r), zs, ws)
-                    }
-                }
-              }
+        // Shape `count` distinct keys from `rest` into a balanced tree, leaving `rest` on the first pair not taken.
+        // The order is established already, so knowing the size lays the tree out from the root down, one node per key.
+        def fromSorted(count: Int): Tree[K, V] =
+          if (count <= 0) Tip() else {
+            val half = (count - 1) / 2
+            val front = half.fromSorted
+            rest match {
+              case Nil() => <{ "fromList: fewer pairs than counted" }>
+              case Cons((k, v), tail) =>
+                rest = tail
+                val value = if (repeated) lastBinding(k, v) else v
+                val back = (count - 1 - half).fromSorted
+                if (direction is Greater()) bin(k, value, back, front) else bin(k, value, front, back)
+            }
           }
-        }
 
-        def go(level: Int, m: Tree[K, V], pairs: List[(K, V)]): Tree[K, V] = {
-          pairs match {
+        // Whatever is left, once the run has stopped, goes through `put`.
+        def insertMany(m: Tree[K, V], ps: List[(K, V)]): Tree[K, V] =
+          ps match {
             case Nil() => m
-            case Cons((k, v), Nil()) => m.putMax(k, v)
-            case Cons((k, v), rest) =>
-              if (notOrdered(k, rest)) { insertMany(m, pairs) }
-              else {
-                val l = m; // m is the left subtree here
-                val cr = create(level, rest)
-                cr match {
-                  case (r, xs, Nil()) => go(level.bitwiseShl(1), link(k, v, l, r), xs)
-                  case (r, Nil(), ys) => insertMany(link(k, v, l, r), ys)
-                  case _ => <{ "create: go: cannot happen, invariant broken!" }>
-                }
-              }
+            case Cons((k, v), tail) => m.put(compare, k, v).insertMany(tail)
           }
-        }
 
-        if (notOrdered(k, rest)) { insertMany(singleton(k, v), rest) }
-        else { go(1, singleton(k, v), rest) }
+        val sorted = runLength(pairs, 0).fromSorted
+        sorted.insertMany(rest)
     }
-  }
 
   /// Remove a key `k` from a tree `m`.
   /// If `k` is not in `m`, `m` is returned.
@@ -1053,4 +1147,4 @@ namespace internal {
 
     "[" ++ res ++ "]"
   }
-}
+}

package/libraries/common/process.effekt

@@ -4,7 +4,8 @@ import array
 extern def exit(errorCode: Int) at io: Nothing =
   js   "(function() { process.exit(${errorCode}) })()"
   llvm """
-    call void @exit(i64 ${errorCode})
+    %exitCode = trunc i64 ${errorCode} to i32
+    call void @exit(i32 %exitCode)
     ret %Pos zeroinitializer
   """
   chez "(exit ${errorCode})"
@@ -107,6 +108,6 @@ extern def spawn(cmd: String, args: Array[String], options: SpawnOptions) at asy
     return p;
     })"""
   llvm """
-    call void @c_spawn(%Pos ${cmd}, %Pos ${args}, %Pos ${options}, %Stack %stack)
+    notail call void @c_spawn(%Pos ${cmd}, %Pos ${args}, %Pos ${options}, %Stack %stack)
     ret void
   """

package/libraries/common/random.effekt

@@ -114,11 +114,24 @@ def randomInt32s(): Unit / {emit[Int], random} =
 
 /// `max` is _inclusive_!
 def randomInt(min: Int, max: Int): Int / random = {
+  // How many bytes it takes to represent `range` distinct values.
+  // Each bound is a power of two, so it's exact even as a JS 'number'.
+  def bytesFor(range: Int): Int =
+    if (range <= 1) 0
+    else if (range <= 256) 1
+    else if (range <= 65536) 2
+    else if (range <= 16777216) 3
+    else if (range <= 4294967296) 4
+    else if (range <= 1099511627776) 5
+    else if (range <= 281474976710656) 6
+    else if (range <= 72057594037927936) 7
+    else 8
+
   if (min > max) {
     randomInt(max, min)
   } else {
     val range = max - min + 1
-    val bytesNeeded = (log(range.toDouble) / log(256.0)).ceil
+    val bytesNeeded = bytesFor(range)
 
     var result = 0
     repeat(bytesNeeded) {

package/libraries/common/set.effekt

@@ -79,22 +79,19 @@ def toMap[K, V](keys: Set[K]) { valueOf: K => V }: Map[K, V] = {
 
 /// Create a set from a given list and a pure, first-class comparison function.
 ///
-/// O(N log N)
 /// O(N) if the list is sorted
-def fromList[A](list: List[A], ?compare: (A, A) => Ordering at {}): Set[A] = {
-  val tree: internal::Tree[A, Unit] = internal::fromList(list.map { k => (k, ()) }, compare)
-  Set(tree, compare)
-}
+/// O(N log N)
+def fromList[A](list: List[A], ?compare: (A, A) => Ordering at {}): Set[A] =
+  set::collect(compare) { list.each }
 
 /// Create a set from a given list with a generic comparison function.
 /// Works only on the JavaScript backends!
 ///
-/// O(N log N)
 /// O(N) if the list is sorted
+/// O(N log N)
 def fromListGeneric[A](list: List[A]): Set[A] = {
   val compare: (A, A) => Ordering at {} = box { (left, right) => genericCompare(left, right) }
-  val tree: internal::Tree[A, Unit] = internal::fromList(list.map { k => (k, ()) }, compare)
-  Set(tree, compare)
+  set::collect(compare) { list.each }
 }
 
 /// Traverse all elements in order, running the function `action` on each element.
@@ -150,10 +147,7 @@ def any[A](s: Set[A]) { predicate: A => Bool }: Bool = {
 ///
 /// O(log N)
 def contains[A](s: Set[A], a: A): Bool =
-  internal::get(s.tree, s.compare, a) match {
-    case None() => false
-    case Some(v) => true
-  }
+  internal::contains(s.tree, s.compare, a)
 
 
 /// Check if set `s1` is a subset of set `s2`.
@@ -260,13 +254,9 @@ namespace returning {
   /// Collects elements emitted by a push stream producer `stream` into a new set
   /// using provided `compare` function, returning the result of the producer as well as the collected set.
   def collect[A, R](?compare: (A, A) => Ordering at {}) { stream: () => R / emit[A] }: (R, Set[A]) = {
-    var set = set::empty(compare)
-    val r = try {
-      stream()
-    } with emit[A] { (v) =>
-      set = set.insert(v)
-      resume(())
+    val (r, tree) = internal::collect[A, Unit, R](compare) {
+      stream::returning::for[A, R] {stream} { (v: A) => do emit((v, ())) }
     }
-    (r, set)
+    (r, Set(tree, compare))
   }
 }

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/rts.ll

@@ -101,7 +101,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 +117,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 +161,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 +188,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 +333,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 +483,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 +498,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 +541,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 +566,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 +610,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 +618,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:
@@ -914,4 +911,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