From a748d22350ad6687f107c226733c211c54939aca Mon Sep 17 00:00:00 2001
From: Mark Spanbroek <mark@spanbroek.net>
Date: Tue, 11 Jan 2022 12:31:25 +0100
Subject: [PATCH] =?UTF-8?q?Fix:=20ensure=20that=20overridden=20=3D=3F=20op?=
 =?UTF-8?q?erator=20does=20not=20remain=20in=20scope?=

---
 questionable/withoutresult.nim | 35 +++++++++++++++++++++++++---------
 testmodules/result/test.nim    | 22 +++++++++++++++++++++
 2 files changed, 48 insertions(+), 9 deletions(-)

diff --git a/questionable/withoutresult.nim b/questionable/withoutresult.nim
index 087a3e5..1188db2 100644
--- a/questionable/withoutresult.nim
+++ b/questionable/withoutresult.nim
@@ -1,22 +1,39 @@
+import std/macros
 import ./binding
 import ./without
 
-template without*(expression, errorname, body) =
+macro replaceInfix(expression, operator, replacement): untyped =
+  ## Replaces an infix operator in an expression. The AST of the expression is
+  ## traversed to find and replace all instances of the operator.
+
+  proc replace(expression, operator, replacement: NimNode): NimNode =
+    if expression.kind == nnkInfix and eqIdent(expression[0], operator):
+      expression[0] = replacement
+      expression[2] = replace(expression[2], operator, replacement)
+    else:
+      for i in 0..<expression.len:
+        expression[i] = replace(expression[i], operator, replacement)
+    expression
+
+  replace(expression, operator, replacement)
+
+template without*(condition, errorname, body) =
   ## Used to place guards that ensure that a Result contains a value.
   ## Exposes error when Result does not contain a value.
 
   var error: ref CatchableError
 
   # override =? operator such that it stores the error if there is one
-  template `=?`(name, result): bool =
-    when result is Result:
-      if result.isFailure:
-        error = result.error
-    when result is Option:
-      if result.isNone:
+  template `override=?`(name, expression): bool {.gensym, used.} =
+    let optional = expression
+    when optional is Result:
+      if optional.isFailure:
+        error = optional.error
+    when optional is Option:
+      if optional.isNone:
         error = newException(ValueError, "Option is set to `none`")
-    binding.`=?`(name, result)
+    name =? optional
 
-  without expression:
+  without replaceInfix(condition, `=?`, `override=?`):
     template errorname: ref CatchableError = error
     body
diff --git a/testmodules/result/test.nim b/testmodules/result/test.nim
index 371c4a1..869b27d 100644
--- a/testmodules/result/test.nim
+++ b/testmodules/result/test.nim
@@ -243,6 +243,28 @@ suite "result":
     test1()
     test2()
 
+  test "without statement with error can be used more than once":
+    proc test =
+      without a =? 42.success, error:
+        discard error
+        fail
+      without b =? 42.success, error:
+        discard error
+        fail
+
+    test()
+
+  test "without statement with error works with deeply nested =? operators":
+    proc test =
+      let fail1 = int.failure "error 1"
+      let fail2 = int.failure "error 2"
+      without (block: a =? (if b =? fail1: b.success else: fail2)), error:
+        check error.msg == "error 2"
+        return
+      fail
+
+    test()
+
   test "catch can be used to convert exceptions to results":
     check parseInt("42").catch == 42.success
     check parseInt("foo").catch.error of ValueError