fix #14339, #13511, #14420: fixes limited VM support for addr (#16002)

* fix #14339: fixes limited VM support for addr

* strengthen test

* reference bug #16003

* also fixes #13511

* also fixes #14420

compiler/vm.nim

@@ -746,10 +746,13 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       regs[ra].regAddr = addr(regs[rb])
     of opcAddrNode:
       decodeB(rkNodeAddr)
-      if regs[rb].kind == rkNode:
+      case regs[rb].kind
+      of rkNode:
         regs[ra].nodeAddr = addr(regs[rb].node)
+      of rkNodeAddr: # bug #14339
+        regs[ra].nodeAddr = regs[rb].nodeAddr
       else:
-        stackTrace(c, tos, pc, "limited VM support for 'addr'")
+        stackTrace(c, tos, pc, "limited VM support for 'addr', got kind: " & $regs[rb].kind)
     of opcLdDeref:
       # a = b[]
       let ra = instr.regA

tests/macros/tmacros_various.nim

@@ -245,3 +245,28 @@ xbenchmark:
     discard inputtest
   fastSHA("hey")
 
+
+block: # bug #13511
+  type
+    Builder = ref object
+      components: seq[Component]
+    Component = object
+
+  proc add(builder: var Builder, component: Component) {.compileTime.} =
+    builder.components.add(component)
+
+  macro debugAst(arg: typed): untyped =
+    ## just for debugging purpose.
+    discard arg.treeRepr
+    return arg
+
+  static:
+    var component = Component()
+    var builder = Builder()
+
+    template foo(): untyped =
+      ## WAS: this doc comment causes compilation failure.
+      builder
+
+    debugAst:
+      add(foo(), component)

tests/misc/taddr.nim

@@ -123,3 +123,83 @@ block:
   block: # pending bug #15959
     when false:
       proc byLent2[T](a: T): lent type(a[0]) = a[0]
+
+proc test14420() = # bug #14420
+  # s/proc/template/ would hit bug #16005
+  block:
+    type Foo = object
+      x: float
+
+    proc fn(a: var Foo): var float =
+      ## WAS: discard <- turn this into a comment (or a `discard`) and error disappears
+      # result = a.x # this works
+      a.x #  WAS: Error: limited VM support for 'addr'
+
+    proc fn2(a: var Foo): var float =
+      result = a.x # this works
+      a.x #  WAS: Error: limited VM support for 'addr'
+
+    var a = Foo()
+    discard fn(a)
+    discard fn2(a)
+
+  block:
+    proc byLent2[T](a: T): lent T =
+      runnableExamples: discard
+      a
+    proc byLent3[T](a: T): lent T =
+      runnableExamples: discard
+      result = a
+    var a = 10
+    let x3 = byLent3(a) # works
+    let x2 = byLent2(a) # WAS: Error: internal error: genAddr: nkStmtListExpr
+
+  block:
+    type MyOption[T] = object
+      case has: bool
+      of true:
+        value: T
+      of false:
+        discard
+    func some[T](val: T): MyOption[T] =
+      result = MyOption[T](has: true, value: val)
+    func get[T](opt: MyOption[T]): lent T =
+      doAssert opt.has
+      # result = opt.value # this was ok
+      opt.value # this had the bug
+    let x = some(10)
+    doAssert x.get() == 10
+
+template test14339() = # bug #14339
+  block:
+    type
+      Node = ref object
+        val: int
+    proc bar(c: Node): var int =
+      var n = c # was: Error: limited VM support for 'addr'
+      c.val
+    var a = Node()
+    discard a.bar()
+  block:
+    type
+      Node = ref object
+        val: int
+    proc bar(c: Node): var int =
+      var n = c
+      doAssert n.val == n[].val
+      n.val
+    var a = Node(val: 3)
+    a.bar() = 5
+    when nimvm:
+      doAssert a.val == 5
+    else:
+      when not defined(js): # pending bug #16003
+        doAssert a.val == 5
+
+template main =
+  # xxx wrap all other tests here like that so they're also tested in VM
+  test14420()
+  test14339()
+
+static: main()
+main()

tests/stdlib/tcritbits.nim

@@ -1,61 +1,69 @@
-import sequtils, critbits
+import std/[sequtils,critbits]
 
+template main =
+  var r: CritBitTree[void]
+  r.incl "abc"
+  r.incl "xyz"
+  r.incl "def"
+  r.incl "definition"
+  r.incl "prefix"
+  r.incl "foo"
 
-var r: CritBitTree[void]
+  doAssert r.contains"def"
-r.incl "abc"
-r.incl "xyz"
-r.incl "def"
-r.incl "definition"
-r.incl "prefix"
-r.incl "foo"
 
-doAssert r.contains"def"
+  r.excl "def"
+  assert r.missingOrExcl("foo") == false
+  assert "foo" notin toSeq(r.items)
 
-r.excl "def"
+  assert r.missingOrExcl("foo") == true
-assert r.missingOrExcl("foo") == false
-assert "foo" notin toSeq(r.items)
 
-assert r.missingOrExcl("foo") == true
+  assert toSeq(r.items) == @["abc", "definition", "prefix", "xyz"]
 
-assert toSeq(r.items) == @["abc", "definition", "prefix", "xyz"]
+  assert toSeq(r.itemsWithPrefix("de")) == @["definition"]
+  var c = CritBitTree[int]()
 
-assert toSeq(r.itemsWithPrefix("de")) == @["definition"]
+  c.inc("a")
-var c = CritBitTree[int]()
+  assert c["a"] == 1
 
-c.inc("a")
+  c.inc("a", 4)
-assert c["a"] == 1
+  assert c["a"] == 5
 
-c.inc("a", 4)
+  c.inc("a", -5)
-assert c["a"] == 5
+  assert c["a"] == 0
 
-c.inc("a", -5)
+  c.inc("b", 2)
-assert c["a"] == 0
+  assert c["b"] == 2
 
-c.inc("b", 2)
+  c.inc("c", 3)
-assert c["b"] == 2
+  assert c["c"] == 3
 
-c.inc("c", 3)
+  c.inc("a", 1)
-assert c["c"] == 3
+  assert c["a"] == 1
 
-c.inc("a", 1)
+  var cf = CritBitTree[float]()
-assert c["a"] == 1
 
-var cf = CritBitTree[float]()
+  cf.incl("a", 1.0)
+  assert cf["a"] == 1.0
 
-cf.incl("a", 1.0)
+  cf.incl("b", 2.0)
-assert cf["a"] == 1.0
+  assert cf["b"] == 2.0
 
-cf.incl("b", 2.0)
+  cf.incl("c", 3.0)
-assert cf["b"] == 2.0
+  assert cf["c"] == 3.0
 
-cf.incl("c", 3.0)
+  assert cf.len == 3
-assert cf["c"] == 3.0
+  cf.excl("c")
+  assert cf.len == 2
 
-assert cf.len == 3
+  var cb: CritBitTree[string]
-cf.excl("c")
+  cb.incl("help", "help")
-assert cf.len == 2
+  for k in cb.keysWithPrefix("helpp"):
+    doAssert false, "there is no prefix helpp"
 
-var cb: CritBitTree[string]
+  block: # bug #14339
-cb.incl("help", "help")
+    var strings: CritBitTree[int]
-for k in cb.keysWithPrefix("helpp"):
+    discard strings.containsOrIncl("foo", 3)
-  doAssert false, "there is no prefix helpp"
+    doAssert strings["foo"] == 3
+
+main()
+static: main()