make tests green again

compiler/destroyer.nim

@@ -188,6 +188,35 @@ proc isHarmlessVar*(s: PSym; c: Con): bool =
       discard "we do not perform an abstract interpretation yet"
   result = usages <= 1
 
+proc isLastRead(s: PSym; c: var Con; pc, comesFrom: int): int =
+  var pc = pc
+  while pc < c.g.len:
+    case c.g[pc].kind
+    of def:
+      if c.g[pc].sym == s:
+        # the path lead to a redefinition of 's' --> abandon it.
+        return pc
+      inc pc
+    of use:
+      if c.g[pc].sym == s:
+        c.otherRead = c.g[pc].n
+        return -1
+      inc pc
+    of goto:
+      pc = pc + c.g[pc].dest
+    of fork:
+      # every branch must lead to the last read of the location:
+      let variantA = isLastRead(s, c, pc+1, pc)
+      if variantA < 0: return -1
+      let variantB = isLastRead(s, c, pc + c.g[pc].dest, pc)
+      if variantB < 0: return -1
+      pc = variantA+1
+    of InstrKind.join:
+      let dest = pc + c.g[pc].dest
+      if dest == comesFrom: return pc
+      inc pc
+  return pc
+
 proc isLastRead(n: PNode; c: var Con): bool =
   # first we need to search for the instruction that belongs to 'n':
   doAssert n.kind == nkSym
@@ -195,15 +224,17 @@ proc isLastRead(n: PNode; c: var Con): bool =
   var instr = -1
   for i in 0..<c.g.len:
     if c.g[i].n == n:
-      if instr < 0: instr = i
+      if instr < 0:
-      else:
+        instr = i
-        # eh, we found two positions that belong to 'n'?
+        break
-        # better return 'false' then:
+
-        return false
   if instr < 0: return false
   # we go through all paths beginning from 'instr+1' and need to
   # ensure that we don't find another 'use X' instruction.
   if instr+1 >= c.g.len: return true
+  when false:
+    result = isLastRead(n.sym, c, 0, -1) >= 0
+  else:
     let s = n.sym
     var pcs: seq[int] = @[instr+1]
     var takenGotos: IntSet