Adding .gensym. to a template does not make it local

[winksaville]

template t() =
  template declX(str: string) {.gensym.} =
    var x {.inject.} : string = str

t()
declX("a string")
echo "x=", x

When compiling:

$ nim c -r --hints:off t
CC: t
[Linking]
/home/wink/prgs/nim/template/t
x=a string

[reactormonk]

From the manual:

Whether a symbol that is declared in a template is exposed to the instantiation scope is controlled by the inject and gensym pragmas: gensym'ed symbols are not exposed but inject'ed are.

so it does exactly what you tell it to.

template t() =
  template declX(str: string) {.gensym.} =
    var x: string = str

t()
declX("a string")
echo "x=", x

Results in

test.nim(7, 11) Error: undeclared identifier: 'x'

as expected.

[Perelandric]

@reactormonk

I was wondering about this bug. I didn't think it was one at first, but I saw that Araq called it a bug in this forum comment.

Looking at it again, shouldn't the gensym pragma make the declX template local to the t template? Seems like it should produce: undeclared identifier: declX. That's what it does with a proc anyway.

template t() =
  proc declX(str: string) {.gensym.} =
    var x: string = str

t()
declX("a string")
echo "x=", x

test.nim(6, 0) Error: undeclared identifier: 'declX'

[winksaville]

In case you didn't realize, the reason you're getting:

test.nim(7, 11) Error: undeclared identifier: 'x'

Is because in your example you didn't have {.inject.} on the x:

var x {.inject.} : string = str

My full example is repeated here with the compile & run output:

$ cat t.nim; nim c -r --hints:off t.nim
template t() =
  template declX(str: string) {.gensym.} =
    var x {.inject.} : string = str

t()
declX("a string")
echo "x=", x
[Linking]
/home/wink/prgs/nim/template/t 
x=a string

As @goob said I would expect this to generate a compile error saying "declX" is undeclared. Instead it works.

[dom96]

The {.inject.} pragma has nothing to do with this bug. The following should also result in a compile-time error:

template t() =
  template foo() {.gensym.} =
    echo 42

t()
foo()

[timotheecour]

was about to file a new bug (which I ran into while working on #11722) but I found this, looks like the same or similar:
this compiles, but shouldn't

import std/macros

macro mgen(): untyped =
  let name1 = genSym(nskTemplate, "mypriv1")
  let name2 = genSym(nskProc, "mypriv2")
  let name3 = genSym(nskLet, "mypriv3")
  result = newStmtList()
  result.add quote do:
    template `name1`() = echo "in template"
    proc `name2`() = echo "in proc"
    proc bobah() = echo "in bobah"
    let `name3` = 123
  echo repr(result)
  return result

mgen()

bobah() # ok, works
mypriv1()  # BUG: this shouldn't compile, it's genSym'd

when false:
  mypriv2() # inconsistent with mypriv1: this one doesn't compile
  echo mypriv3 # ditto
  mypriv1421054() # the gensym'd name doesn't compile either
  mypriv2421053() # ditto for mypriv2

note

this could affect all code with genSym(nskTemplate, ...

workaround

here's the workaround I found that seems to work: use a name with an underscore, making it impossible to clash:

let name = genSym(nskTemplate, "_fun")

[timotheecour]

the bug in top post is now fixed (as of 6aa971d 1.3.5 at least) but the bug in #2465 (comment) is still here

maybe a simple hacky fix would be to force gensym idents to start with _, although that still may not work eg if mgen is called twice, would those clash? unclear.

[metagn]

Now:

template t() =
  template foo() {.gensym.} =
    echo 42

t()
foo()

Gives:

(6, 1) Error: undeclared identifier: 'foo'