remove redundant callSoon

src/hyperx/client.nim

@@ -55,7 +55,7 @@ proc defaultSslContext(): SslContext {.raises: [HyperxConnError], definedSsl.} =
 when not defined(hyperxTest):
   proc newMySocketSsl: MyAsyncSocket {.raises: [HyperxConnError], definedSsl.} =
     result = newMySocket()
-    tryCatch wrapSocket(defaultSslContext(), result)
+    catch wrapSocket(defaultSslContext(), result)
 
 const isSslDefined = defined(ssl)
 

src/hyperx/clientserver.nim

@@ -75,7 +75,7 @@ proc defaultSslContext*(
   # protSSLv23 will disable all protocols
   # lower than the min protocol defined
   # in openssl.config, usually +TLSv1.2
-  result = tryCatch newContext(
+  result = catch newContext(
     protSSLv23,
     verifyMode = CVerifyPeer,
     certFile = certFile,
@@ -99,7 +99,7 @@ proc defaultSslContext*(
     )
   of ctClient:
     var openSslVersion = 0.culong
-    untrackExceptions:
+    uncatch:
       openSslVersion = getOpenSSLVersion()
     doAssert openSslVersion >= 0x10002000
     let ctxAlpnSet = SSL_CTX_set_alpn_protos(
@@ -114,7 +114,7 @@ else:
 
 when not defined(hyperxTest):
   proc newMySocket*: MyAsyncSocket {.raises: [HyperxConnError].} =
-    result = tryCatch newAsyncSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, buffered = true)
+    result = catch newAsyncSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, buffered = true)
     doAssert result != nil
 
 type
@@ -177,7 +177,7 @@ proc close*(client: ClientContext) {.raises: [HyperxConnError].} =
     return
   client.isConnected = false
   try:
-    tryCatch client.sock.close()
+    catch client.sock.close()
   finally:
     client.recvMsgs.close()
     client.streamOpenedMsgs.close()
@@ -721,7 +721,7 @@ proc windowUpdateTask(client: ClientContext) {.async.} =
     client.close()
 
 proc connect(client: ClientContext) {.async.} =
-  tryCatch await client.sock.connect(client.hostname, client.port)
+  catch await client.sock.connect(client.hostname, client.port)
 
 proc failSilently(f: Future[void]) {.async.} =
   ## Be careful when wrapping non {.async.} procs,

src/hyperx/limiter.nim

@@ -12,7 +12,6 @@ type LimiterAsync* = ref object
   ## Async concurrency limiter.
   used, size: int
   waiter: Future[void]
-  wakingUp: bool
   isClosed: bool
 
 func newLimiter*(size: int): LimiterAsync {.raises: [].} =
@@ -21,23 +20,14 @@ func newLimiter*(size: int): LimiterAsync {.raises: [].} =
     used: 0,
     size: size,
     waiter: nil,
-    wakingUp: false,
     isClosed: false
   )
 
 proc wakeup(lt: LimiterAsync) {.raises: [].} =
   if lt.waiter == nil:
     return
-  if lt.waiter.finished:
-    return
-  proc wakeup =
-    lt.wakingUp = false
-    if not lt.waiter.finished:
-      lt.waiter.complete()
-  if not lt.wakingUp:
-    lt.wakingUp = true
-    untrackExceptions:
-      callSoon wakeup
+  if not lt.waiter.finished:
+    uncatch lt.waiter.complete()
 
 proc inc*(lt: LimiterAsync) {.raises: [LimiterAsyncClosedError].} =
   doAssert lt.used < lt.size
@@ -67,16 +57,8 @@ proc wait*(lt: LimiterAsync): Future[void] {.raises: [LimiterAsyncClosedError].}
 proc failSoon(lt: LimiterAsync) {.raises: [].} =
   if lt.waiter == nil:
     return
-  if lt.waiter.finished:
-    return
-  proc wakeup =
-    lt.wakingUp = false
-    if not lt.waiter.finished:
-      lt.waiter.fail newLimiterAsyncClosedError()
-  if not lt.wakingUp:
-    lt.wakingUp = true
-    untrackExceptions:
-      callSoon wakeup
+  if not lt.waiter.finished:
+    uncatch lt.waiter.fail newLimiterAsyncClosedError()
 
 proc close*(lt: LimiterAsync) {.raises: [].} =
   if lt.isClosed:

src/hyperx/queue.nim

@@ -14,7 +14,6 @@ type
     s: Deque[T]
     size: int
     putWaiter, popWaiter: Future[void]
-    wakingPut, wakingPop: bool
     isClosed: bool
 
 func newQueue*[T](size: int): QueueAsync[T] {.raises: [].} =
@@ -24,8 +23,6 @@ func newQueue*[T](size: int): QueueAsync[T] {.raises: [].} =
     size: size,
     putWaiter: nil,
     popWaiter: nil,
-    wakingPut: false,
-    wakingPop: false,
     isClosed: false
   )
 
@@ -39,16 +36,8 @@ func used[T](q: QueueAsync[T]): int {.raises: [].} =
 proc wakeupPop[T](q: QueueAsync[T]) {.raises: [].} =
   if q.popWaiter == nil:
     return
-  if q.popWaiter.finished:
-    return
-  proc wakeup =
-    q.wakingPop = false
-    if not q.popWaiter.finished:
-      q.popWaiter.complete()
-  if not q.wakingPop:
-    q.wakingPop = true
-    untrackExceptions:
-      callSoon wakeup
+  if not q.popWaiter.finished:
+    uncatch q.popWaiter.complete()
 
 proc put*[T](q: QueueAsync[T], v: T) {.async.} =
   doAssert q.used <= q.size
@@ -65,16 +54,8 @@ proc put*[T](q: QueueAsync[T], v: T) {.async.} =
 proc wakeupPut[T](q: QueueAsync[T]) {.raises: [].} =
   if q.putWaiter == nil:
     return
-  if q.putWaiter.finished:
-    return
-  proc wakeup =
-    q.wakingPut = false
-    if not q.putWaiter.finished:
-      q.putWaiter.complete()
-  if not q.wakingPut:
-    q.wakingPut = true
-    untrackExceptions:
-      callSoon wakeup
+  if not q.putWaiter.finished:
+    uncatch q.putWaiter.complete()
 
 proc pop*[T](q: QueueAsync[T]): Future[T] {.async.} =
   doAssert q.used >= 0
@@ -94,11 +75,8 @@ func isClosed*[T](q: QueueAsync[T]): bool {.raises: [].} =
 proc failSoon(f: Future[void]) {.raises: [].} =
   if f == nil:
     return
-  proc wakeup =
-    if not f.finished:
-      f.fail newQueueClosedError()
-  untrackExceptions:
-    callSoon wakeup
+  if not f.finished:
+    uncatch f.fail newQueueClosedError()
 
 proc close*[T](q: QueueAsync[T]) {.raises: [].}  =
   if q.isClosed:

src/hyperx/server.nim

@@ -63,7 +63,7 @@ when not defined(hyperxTest):
     keyFile = ""
   ): MyAsyncSocket {.raises: [HyperxConnError], definedSsl.} =
     result = newMySocket()
-    tryCatch wrapSocket(defaultSslContext(certFile, keyFile), result)
+    catch wrapSocket(defaultSslContext(certFile, keyFile), result)
 
 type
   ServerContext* = ref object
@@ -99,10 +99,10 @@ proc close*(server: ServerContext) {.raises: [HyperxConnError].} =
   if not server.isConnected:
     return
   server.isConnected = false
-  tryCatch server.sock.close()
+  catch server.sock.close()
 
 proc listen(server: ServerContext) {.raises: [HyperxConnError].} =
-  tryCatch:
+  catch:
     server.sock.setSockOpt(OptReuseAddr, true)
     server.sock.setSockOpt(OptReusePort, true)
     server.sock.setSockOpt(OptNoDelay, true, level = IPPROTO_TCP.cint)
@@ -113,7 +113,7 @@ proc listen(server: ServerContext) {.raises: [HyperxConnError].} =
 
 # XXX limit number of active clients
 proc recvClient*(server: ServerContext): Future[ClientContext] {.async.} =
-  tryCatch:
+  catch:
     # note OptNoDelay is inherited from server.sock
     let sock = await server.sock.accept()
     when defined(ssl):

src/hyperx/signal.nim

@@ -33,11 +33,8 @@ proc waitFor*(sig: SignalAsync): Future[void] {.raises: [SignalClosedError].} =
   sig.waiters.addFirst result
 
 proc wakeupSoon(f: Future[void]) {.raises: [].} =
-  proc wakeup =
-    if not f.finished:
-      f.complete()
-  untrackExceptions:
-    callSoon wakeup
+  if not f.finished:
+    uncatch f.complete()
 
 proc trigger*(sig: SignalAsync) {.raises: [SignalClosedError].} =
   if sig.isClosed:
@@ -49,11 +46,8 @@ func isClosed*(sig: SignalAsync): bool {.raises: [].} =
   sig.isClosed
 
 proc failSoon(f: Future[void]) {.raises: [].} =
-  proc wakeup =
-    if not f.finished:
-      f.fail newSignalClosedError()
-  untrackExceptions:
-    callSoon wakeup
+  if not f.finished:
+    uncatch f.fail newSignalClosedError()
 
 proc close*(sig: SignalAsync) {.raises: [].}  =
   if sig.isClosed:

src/hyperx/utils.nim

@@ -70,7 +70,7 @@ template raisesAssertion*(exp: untyped): untyped =
         asserted = true
       doAssert asserted
 
-template untrackExceptions*(body: untyped): untyped =
+template uncatch*(body: untyped): untyped =
   ## workaround for API errors in Nim's stdlib
   try:
     body
@@ -80,11 +80,11 @@ template untrackExceptions*(body: untyped): untyped =
     debugErr err
     raise newException(Defect, err.msg, err)
 
-template tryCatch*(body: untyped): untyped =
+template catch*(body: untyped): untyped =
   try:
     body
   except Defect as err:
-    raise err
+    raise err  # raise original error
   except Exception as err:
     debugErr2 err
     raise newConnError(err.msg, err)
@@ -254,10 +254,10 @@ when isMainModule:
       raised = true
     doAssert raised
   block:
-    raisesAssertion(tryCatch(doAssert false))
+    raisesAssertion(catch(doAssert false))
   block:
     try:
-      tryCatch:
+      catch:
         raise newException(ValueError, "foo")
       doAssert false
     except HyperxConnError as err:

src/hyperx/value.nim

@@ -26,13 +26,8 @@ func newValueAsync*[T](): ValueAsync[T] {.raises: [].} =
 proc wakeupSoon(f: Future[void]) {.raises: [].} =
   if f == nil:
     return
-  if f.finished:
-    return
-  proc wakeup =
-    if not f.finished:
-      f.complete()
-  untrackExceptions:
-    callSoon wakeup
+  if not f.finished:
+    uncatch f.complete()
 
 proc put*[T](vala: ValueAsync[T], val: T) {.async.} =
   check not vala.isClosed, newValueAsyncClosedError()
@@ -59,13 +54,8 @@ proc get*[T](vala: ValueAsync[T]): Future[T] {.async.} =
 proc failSoon(f: Future[void]) {.raises: [].} =
   if f == nil:
     return
-  if f.finished:
-    return
-  proc wakeup =
-    if not f.finished:
-      f.fail newValueAsyncClosedError()
-  untrackExceptions:
-    callSoon wakeup
+  if not f.finished:
+    uncatch f.fail newValueAsyncClosedError()
 
 proc close*[T](vala: ValueAsync[T]) {.raises: [].} =
   if vala.isClosed: