faster CIs (#13803)

* ttables: smaller table, 5x speedup

* thavlak: less iterations, less loops; 30% speedup

* tasyncclosestall: shorter timeout; 35% speedup

* gcleak4: less iterations, 2x speedup

* ttimes: remove deprecated stuff

* tdangerisrelease: remove cpp backend, 3x speedup

* tfrexp1: smaller range, 2x speedup

* trtree: fix warnings, less iterations, 6x speedup

* tasyncawait_cyclebreaker: smaller swarm size; 2x speedup

* trealloc: smaller number of iterations; 10x speedup

* towned_binary_tree: less iterations, 4x speedup

* tclosure: remove unused code, less iterations; 2x speedup

* twaitany: less durations; 1.4x speedup

* tasync_misc: less iterations, 2x speedup

* t8535: smaller sleep, 1.5x speedup

* tmanyjoin: smaller sleep, 2x speedup

* t12221: shorter sleeps, removed two slower tests; 1.6x speedup

* tfuturestream: smaller sleep; 1.5x speedup

* growobjcrash: less iterations; 2x speedup

* ttryrecv: smaller sleep; 1.5x speedup

* treusetvar: less threads; 2x speedup

* delete tthreadanalysis2, basically a duplicate of tthreadanalysis

* t7758: less iterations, 1.5x speedup

* tasyncawait: smaller swarm, less messages; 1.5x speedup

* tjsandnativeasync: smaller sleep, 1.5x speedup

* tpendingcheck: smaller sleep, 1.5x speedup

* remove rodfiles test category

* move tseq from its own category to 'collections' category

* remove unneeded tests and helpers from 'assert' category

* stdlib: merge tbitops2 into tbitops

* remove 'trepr2' from 'stdlib' cat

* merge 'tstreams' into one file

* remove 'tinefficient_const_table' from 'ccbugs' cat

* merge 'tcollections_to_string' into 'tcollections'

* tblocking_channel: smaller sleep, small speedup

* tconvexhull: less iterartions; 1.2x speedup

* merge 'tdeepcopy2' into 'tdeepcopy'

* merge 'tdisjoint_slice2' into 'tdisjoint_slice1'

* tmissing_deepcopy: smaller sequence

* tsendtwice: smaller arrays; 5x speedup

* remove 'tindexerrorformatbounds'

* disable multimethod tests

* remove 'gc:none' and 'refc' without 'd:useRealtimeGC' from gc tests

* koch.nim: bootstrap just with '-d:release', no need for 'csource'

* add github workflow for documentation

* testament: no need for 8 sub-second decimals

1 files changed, 2 insertions, 216 deletions

diff --git a/tests/closure/tclosure.nim b/tests/closure/tclosure.nim
index cfef4193a..7e2ec7a77 100644
--- a/tests/closure/tclosure.nim
+++ b/tests/closure/tclosure.nim
@@ -41,10 +41,6 @@ block tclosure:
   proc map(n: var openarray[int], fn: proc (x: int): int {.closure}) =
     for i in 0..n.len-1: n[i] = fn(n[i])
 
-  proc foldr(n: openarray[int], fn: proc (x, y: int): int {.closure}): int =
-    for i in 0..n.len-1:
-      result = fn(result, n[i])
-
   proc each(n: openarray[int], fn: proc(x: int) {.closure.}) =
     for i in 0..n.len-1:
       fn(n[i])
@@ -67,18 +63,6 @@ block tclosure:
 
   #OUT 2 4 6 8 10
 
-  type
-    ITest = tuple[
-      setter: proc(v: int),
-      getter: proc(): int]
-
-  proc getInterf(): ITest =
-    var shared: int
-
-    return (setter: proc (x: int) = shared = x,
-            getter: proc (): int = return shared)
-
-
   # bug #5015
 
   type Mutator = proc(matched: string): string {.noSideEffect, gcsafe, locks: 0.}
@@ -180,7 +164,7 @@ block tclosure0:
 block tclosure3:
   proc main =
     const n = 30
-    for iterations in 0..50_000:
+    for iterations in 0..10_000:
       var s: seq[proc(): string {.closure.}] = @[]
       for i in 0 .. n-1:
         (proc () =
@@ -203,210 +187,12 @@ block tclosure4:
     let json_elems = json_params["files"].elems
     # These fail compilation.
     var files = map(json_elems, proc (x: JsonNode): string = x.str)
-    #var files = json_elems.map do (x: JsonNode) -> string: x.str
 
   let text = """{"files": ["a", "b", "c"]}"""
   run((text.parseJson).fields)
 
 
 
-import hashes, math
-block tclosurebug2:
-  type
-    TSlotEnum = enum seEmpty, seFilled, seDeleted
-    TKeyValuePair[A, B] = tuple[slot: TSlotEnum, key: A, val: B]
-    TKeyValuePairSeq[A, B] = seq[TKeyValuePair[A, B]]
-
-    TOrderedKeyValuePair[A, B] = tuple[
-      slot: TSlotEnum, next: int, key: A, val: B]
-    TOrderedKeyValuePairSeq[A, B] = seq[TOrderedKeyValuePair[A, B]]
-    OrderedTable[A, B] = object ## table that remembers insertion order
-      data: TOrderedKeyValuePairSeq[A, B]
-      counter, first, last: int
-
-  const
-    growthFactor = 2
-
-  proc mustRehash(length, counter: int): bool {.inline.} =
-    assert(length > counter)
-    result = (length * 2 < counter * 3) or (length - counter < 4)
-
-  proc nextTry(h, maxHash: Hash): Hash {.inline.} =
-    result = ((5 * h) + 1) and maxHash
-
-  template rawGetImpl() {.dirty.} =
-    var h: Hash = hash(key) and high(t.data) # start with real hash value
-    while t.data[h].slot != seEmpty:
-      if t.data[h].key == key and t.data[h].slot == seFilled:
-        return h
-      h = nextTry(h, high(t.data))
-    result = -1
-
-  template rawInsertImpl() {.dirty.} =
-    var h: Hash = hash(key) and high(data)
-    while data[h].slot == seFilled:
-      h = nextTry(h, high(data))
-    data[h].key = key
-    data[h].val = val
-    data[h].slot = seFilled
-
-  template addImpl() {.dirty.} =
-    if mustRehash(len(t.data), t.counter): enlarge(t)
-    rawInsert(t, t.data, key, val)
-    inc(t.counter)
-
-  template putImpl() {.dirty.} =
-    var index = rawGet(t, key)
-    if index >= 0:
-      t.data[index].val = val
-    else:
-      addImpl()
-
-  proc len[A, B](t: OrderedTable[A, B]): int {.inline.} =
-    ## returns the number of keys in `t`.
-    result = t.counter
-
-  template forAllOrderedPairs(yieldStmt: untyped) {.dirty.} =
-    var h = t.first
-    while h >= 0:
-      var nxt = t.data[h].next
-      if t.data[h].slot == seFilled: yieldStmt
-      h = nxt
-
-  iterator pairs[A, B](t: OrderedTable[A, B]): tuple[key: A, val: B] =
-    ## iterates over any (key, value) pair in the table `t` in insertion
-    ## order.
-    forAllOrderedPairs:
-      yield (t.data[h].key, t.data[h].val)
-
-  iterator mpairs[A, B](t: var OrderedTable[A, B]): tuple[key: A, val: var B] =
-    ## iterates over any (key, value) pair in the table `t` in insertion
-    ## order. The values can be modified.
-    forAllOrderedPairs:
-      yield (t.data[h].key, t.data[h].val)
-
-  iterator keys[A, B](t: OrderedTable[A, B]): A =
-    ## iterates over any key in the table `t` in insertion order.
-    forAllOrderedPairs:
-      yield t.data[h].key
-
-  iterator values[A, B](t: OrderedTable[A, B]): B =
-    ## iterates over any value in the table `t` in insertion order.
-    forAllOrderedPairs:
-      yield t.data[h].val
-
-  iterator mvalues[A, B](t: var OrderedTable[A, B]): var B =
-    ## iterates over any value in the table `t` in insertion order. The values
-    ## can be modified.
-    forAllOrderedPairs:
-      yield t.data[h].val
-
-  proc rawGet[A, B](t: OrderedTable[A, B], key: A): int =
-    rawGetImpl()
-
-  proc `[]`[A, B](t: OrderedTable[A, B], key: A): B =
-    ## retrieves the value at ``t[key]``. If `key` is not in `t`,
-    ## default empty value for the type `B` is returned
-    ## and no exception is raised. One can check with ``hasKey`` whether the key
-    ## exists.
-    var index = rawGet(t, key)
-    if index >= 0: result = t.data[index].val
-
-  proc mget[A, B](t: var OrderedTable[A, B], key: A): var B =
-    ## retrieves the value at ``t[key]``. The value can be modified.
-    ## If `key` is not in `t`, the ``EInvalidKey`` exception is raised.
-    var index = rawGet(t, key)
-    if index >= 0: result = t.data[index].val
-    else: raise newException(KeyError, "key not found: " & $key)
-
-  proc hasKey[A, B](t: OrderedTable[A, B], key: A): bool =
-    ## returns true iff `key` is in the table `t`.
-    result = rawGet(t, key) >= 0
-
-  proc rawInsert[A, B](t: var OrderedTable[A, B],
-                      data: var TOrderedKeyValuePairSeq[A, B],
-                      key: A, val: B) =
-    rawInsertImpl()
-    data[h].next = -1
-    if t.first < 0: t.first = h
-    if t.last >= 0: data[t.last].next = h
-    t.last = h
-
-  proc enlarge[A, B](t: var OrderedTable[A, B]) =
-    var n: TOrderedKeyValuePairSeq[A, B]
-    newSeq(n, len(t.data) * growthFactor)
-    var h = t.first
-    t.first = -1
-    t.last = -1
-    while h >= 0:
-      var nxt = t.data[h].next
-      if t.data[h].slot == seFilled:
-        rawInsert(t, n, t.data[h].key, t.data[h].val)
-      h = nxt
-    swap(t.data, n)
-
-  proc `[]=`[A, B](t: var OrderedTable[A, B], key: A, val: B) =
-    ## puts a (key, value)-pair into `t`.
-    putImpl()
-
-  proc add[A, B](t: var OrderedTable[A, B], key: A, val: B) =
-    ## puts a new (key, value)-pair into `t` even if ``t[key]`` already exists.
-    addImpl()
-
-  proc iniOrderedTable[A, B](initialSize=64): OrderedTable[A, B] =
-    ## creates a new ordered hash table that is empty. `initialSize` needs to be
-    ## a power of two.
-    assert isPowerOfTwo(initialSize)
-    result.counter = 0
-    result.first = -1
-    result.last = -1
-    newSeq(result.data, initialSize)
-
-  proc toOrderedTable[A, B](pairs: openarray[tuple[key: A,
-                            val: B]]): OrderedTable[A, B] =
-    ## creates a new ordered hash table that contains the given `pairs`.
-    result = iniOrderedTable[A, B](nextPowerOfTwo(pairs.len+10))
-    for key, val in items(pairs): result[key] = val
-
-  proc sort[A, B](t: var OrderedTable[A,B],
-                  cmp: proc (x, y: tuple[key: A, val: B]): int {.closure.}) =
-    ## sorts the ordered table so that the entry with the highest counter comes
-    ## first. This is destructive (with the advantage of being efficient)!
-    ## You must not modify `t` afterwards!
-    ## You can use the iterators `pairs`,  `keys`, and `values` to iterate over
-    ## `t` in the sorted order.
-
-    # we use shellsort here; fast enough and simple
-    var h = 1
-    while true:
-      h = 3 * h + 1
-      if h >= high(t.data): break
-    while true:
-      h = h div 3
-      for i in countup(h, high(t.data)):
-        var j = i
-        #echo(t.data.len, " ", j, " - ", h)
-        #echo(repr(t.data[j-h]))
-        proc rawCmp(x, y: TOrderedKeyValuePair[A, B]): int =
-          if x.slot in {seEmpty, seDeleted} and y.slot in {seEmpty, seDeleted}:
-            return 0
-          elif x.slot in {seEmpty, seDeleted}:
-            return -1
-          elif y.slot in {seEmpty, seDeleted}:
-            return 1
-          else:
-            let item1 = (x.key, x.val)
-            let item2 = (y.key, y.val)
-            return cmp(item1, item2)
-
-        while rawCmp(t.data[j-h], t.data[j]) <= 0:
-          swap(t.data[j], t.data[j-h])
-          j = j-h
-          if j < h: break
-      if h == 1: break
-
-
-
 import sugar
 block inference3304:
   type
@@ -513,7 +299,7 @@ block tflatmap:
     let g: A -> Rand[B] = (a: A) => ((rng: RNG) => (f(a), rng))
     flatMap(s, g)
 
-  let f = nextInt.map(i => i - i mod 2)
+  discard nextInt.map(i => i - i mod 2)