perf(deque,queue,priority_queue): annotate consuming parameters with #owned

deque/deque.mbt

@@ -410,6 +410,7 @@ pub fn[A] Deque::append(self : Deque[A], other : Deque[A]) -> Unit {
 ///   )
 /// }
 /// ```
+#owned(value)
 pub fn[A] Deque::insert(self : Deque[A], index : Int, value : A) -> Unit {
   guard index >= 0 && index <= self.length() else {
     abort(
@@ -631,6 +632,7 @@ pub fn[A] Deque::back(self : Deque[A]) -> A? {
 ///   @test.assert_eq(dv.front(), Some(0))
 /// }
 /// ```
+#owned(value)
 pub fn[A] Deque::push_front(self : Deque[A], value : A) -> Unit {
   if self.len == self.buf.length() {
     self.realloc()
@@ -654,6 +656,7 @@ pub fn[A] Deque::push_front(self : Deque[A], value : A) -> Unit {
 ///   @test.assert_eq(dv.back(), Some(6))
 /// }
 /// ```
+#owned(value)
 pub fn[A] Deque::push_back(self : Deque[A], value : A) -> Unit {
   if self.len == self.buf.length() {
     self.realloc()
@@ -836,6 +839,7 @@ pub fn[A] Deque::at(self : Deque[A], index : Int) -> A {
 /// }
 /// ```
 #alias("_[_]=_")
+#owned(value)
 pub fn[A] Deque::set(self : Deque[A], index : Int, value : A) -> Unit {
   if index < 0 || index >= self.len {
     index_out_of_bounds(self.len, index)

priority_queue/priority_queue.mbt

@@ -154,6 +154,7 @@ pub fn[K : Compare] PriorityQueue::from_iter(
 }
 
 ///|
+#owned(x, y)
 fn[A : Compare] meld(x : Node[A], y : Node[A]) -> Node[A] {
   if x.content > y.content {
     y.sibling = x.child
@@ -167,6 +168,7 @@ fn[A : Compare] meld(x : Node[A], y : Node[A]) -> Node[A] {
 }
 
 ///|
+#owned(x)
 fn[A : Compare] merges(x : Node[A]?) -> Node[A]? {
   let (x, acc) = match x {
     None => return None
@@ -251,6 +253,7 @@ pub fn[A : Compare] PriorityQueue::pop(self : PriorityQueue[A]) -> A? {
 ///   @test.assert_eq(queue.length(), 1)
 /// }
 /// ```
+#owned(value)
 pub fn[A : Compare] PriorityQueue::push(
   self : PriorityQueue[A],
   value : A,

queue/queue.mbt

@@ -103,6 +103,7 @@ pub fn[A] Queue::is_empty(self : Queue[A]) -> Bool {
 ///   queue.push(1)
 /// }
 /// ```
+#owned(x)
 pub fn[A] Queue::push(self : Queue[A], x : A) -> Unit {
   self.inner.push_back(x)
 }