ARC related bugfixes and refactorings (#12781)

1 files changed, 0 insertions, 87 deletions

diff --git a/lib/core/seqs.nim b/lib/core/seqs.nim
index 914ca438c..b7f9fb153 100644
--- a/lib/core/seqs.nim
+++ b/lib/core/seqs.nim
@@ -30,60 +30,6 @@ template payloadSize(cap): int = cap * sizeof(T) + sizeof(int) + sizeof(Allocato
 
 # XXX make code memory safe for overflows in '*'
 
-when false:
-  # this is currently not part of Nim's type bound operators and so it's
-  # built into the tracing proc generation just like before.
-  proc `=trace`[T](s: NimSeqV2[T]) =
-    for i in 0 ..< s.len: `=trace`(s.data[i])
-
-#[
-Keep in mind that C optimizers are bad at detecting the connection
-between ``s.p != nil`` and ``s.len != 0`` and that these are intermingled
-with user-level code that accesses ``s.len`` only, never ``s.p`` directly.
-This means the check for whether ``s.p`` needs to be freed should
-be ``s.len == 0`` even though that feels slightly more awkward.
-]#
-
-when not defined(nimV2):
-  proc `=destroy`[T](s: var seq[T]) =
-    var x = cast[ptr NimSeqV2[T]](addr s)
-    var p = x.p
-    if p != nil:
-      mixin `=destroy`
-      when not supportsCopyMem(T):
-        for i in 0..<x.len: `=destroy`(p.data[i])
-      if p.allocator != nil:
-        p.allocator.dealloc(p.allocator, p, payloadSize(p.cap))
-      x.p = nil
-      x.len = 0
-
-  proc `=`[T](x: var seq[T]; y: seq[T]) =
-    mixin `=destroy`
-    var a = cast[ptr NimSeqV2[T]](addr x)
-    var b = cast[ptr NimSeqV2[T]](unsafeAddr y)
-
-    if a.p == b.p: return
-    `=destroy`(x)
-    a.len = b.len
-    if b.p != nil:
-      a.p = cast[type(a.p)](alloc(payloadSize(a.len)))
-      when supportsCopyMem(T):
-        if a.len > 0:
-          copyMem(unsafeAddr a.p.data[0], unsafeAddr b.p.data[0], a.len * sizeof(T))
-      else:
-        for i in 0..<a.len:
-          a.p.data[i] = b.p.data[i]
-
-  proc `=sink`[T](x: var seq[T]; y: seq[T]) =
-    mixin `=destroy`
-    var a = cast[ptr NimSeqV2[T]](addr x)
-    var b = cast[ptr NimSeqV2[T]](unsafeAddr y)
-    if a.p != nil and a.p != b.p:
-      `=destroy`(x)
-    a.len = b.len
-    a.p = b.p
-
-
 type
   PayloadBase = object
     cap: int
@@ -181,36 +127,3 @@ proc setLen[T](s: var seq[T], newlen: Natural) =
       if xu.p == nil or xu.p.cap < newlen:
         xu.p = cast[typeof(xu.p)](prepareSeqAdd(oldLen, xu.p, newlen - oldLen, sizeof(T)))
       xu.len = newlen
-
-when false:
-  proc resize[T](s: var NimSeqV2[T]) =
-    let old = s.cap
-    if old == 0: s.cap = 8
-    else: s.cap = (s.cap * 3) shr 1
-    s.data = cast[type(s.data)](realloc(s.data, old * sizeof(T), s.cap * sizeof(T)))
-
-  proc reserveSlot[T](x: var NimSeqV2[T]): ptr T =
-    if x.len >= x.cap: resize(x)
-    result = addr(x.data[x.len])
-    inc x.len
-
-  template add*[T](x: var NimSeqV2[T]; y: T) =
-    reserveSlot(x)[] = y
-
-  template `[]`*[T](x: NimSeqV2[T]; i: Natural): T =
-    assert i < x.len
-    x.data[i]
-
-  template `[]=`*[T](x: NimSeqV2[T]; i: Natural; y: T) =
-    assert i < x.len
-    x.data[i] = y
-
-  proc `@`*[T](elems: sink openArray[T]): NimSeqV2[T] =
-    result.cap = elems.len
-    result.len = elems.len
-    result.data = cast[type(result.data)](alloc(result.cap * sizeof(T)))
-    when supportsCopyMem(T):
-      copyMem(result.data, unsafeAddr(elems[0]), result.cap * sizeof(T))
-    else:
-      for i in 0..<result.len:
-        result.data[i] = elems[i]