Accessing compileTime variable at runtime returns zeroed data.

[ftsf]

After doing anything runtime specific, eg. looping, compileTime variables return zeroed data.

The manual states

"compileTime variables are available at runtime too. This simplifies certain idioms where variables are filled at compile-time (for example, lookup tables) but accessed at runtime:"

But this does not appear to work except before doing any runtime operations.

Example taken from manual

import macros

var nameToProc {.compileTime.}: seq[(string, proc (): string {.nimcall.})]

macro registerProc(p: untyped): untyped =
  result = newTree(nnkStmtList, p)
  
  let procName = p[0]
  let procNameAsStr = $p[0]
  result.add quote do:
    nameToProc.add((`procNameAsStr`, `procName`))

proc foo: string {.registerProc.} = "foo"
proc bar: string {.registerProc.} = "bar"
proc baz: string {.registerProc.} = "baz"

# this works as expected
echo nameToProc.len
doAssert nameToProc[2][1]() == "baz"

for i in 0..<1:
  echo nameToProc.len # problem begins here, this returns 0

# this also doesn't work
echo nameToProc.len
doAssert nameToProc[2][1]() == "baz"

Current Output

3
0
0
/usercode/in.nim(26)     in
/playground/nim/lib/system/fatal.nim(39) sysFatal
Error: unhandled exception: index out of bounds, the container is empty [IndexError]

Expected Output

3
3
3

$ nim -v
Nim Compiler Version 1.0.6

[mratsim]

It has been mentionned in multiple places but surprisingly there is no issue to track this

#12516 (comment)

Workaround use an extra step, for example

var nameToProc {.compileTime.}: seq[(string, proc (): string {.nimcall.})]

# ... compile time processing

# Cross the Compile-time -> Runtime boundary
let nameToProcRT = static(nameToProc)

Example:

• CT: https://github.com/status-im/nim-beacon-chain/blob/7b38269b/nbench/bench_lab.nim#L48-L51
• RT: https://github.com/status-im/nim-beacon-chain/blob/7b38269b/nbench/nbench.nim#L33

[Araq]

The "extra step" is at least as bad IMHO but it has the advantage that it reflects reality of Nim-pre1.0. As I said, I "fixed" this for version 1.0 but didn't get the implementation right. Now the question is what is the better spec...

[ftsf]

This workaround is not very useful when split over multiple modules.
I'm not sure if the original behaviour is intended to be able to work like this or not.

In Nim 1.2.4
let nameToProcRT = static(nameToProc) raises a linker error

ld.exe: C:\Users\user\nimcache\consumer_d\@mconsumer.nim.c.o:@mconsumer.nim.c:(.rdata$.refptr.nameToProc__UApYjPtPj8a5A9bEj9c72Wdw[.refptr.nameToProc__UApYjPtPj8a5A9bEj9c72Wdw]+0x0): undefined reference to `nameToProc__UApYjPtPj8a5A9bEj9c72Wdw''

using instead:
let nameToProcRT = nameToProc

provider.nim

import macros

var nameToProc {.compileTime.}: seq[(string, proc (): string {.nimcall.})]

macro registerProc*(p: untyped): untyped =
  result = newTree(nnkStmtList, p)

  let procName = p[0]
  let procNameAsStr = $p[0]
  result.add quote do:
    nameToProc.add((`procNameAsStr`, `procName`))
    echo "registered proc ", `procNameAsStr`

let nameToProcRT = nameToProc

proc callProc*(name: string) =
  for p in nameToProcRT:
    if p[0] == name:
      echo p[1]()
      return
  echo "not found ", name

consumer.nim

import provider

proc foo: string {.registerProc.} = "foo"
proc bar: string {.registerProc.} = "bar"
proc baz: string {.registerProc.} = "baz"

callProc("foo")
callProc("bar")
callProc("baz")

expected output when running consumer

registered proc foo
registered proc bar
registered proc baz
foo
bar
baz

actual output

registered proc foo
registered proc bar
registered proc baz
not found foo
not found bar
not found baz

Is there any way to get this working over multiple modules so any module may register procs at compile time and at runtime call any that have been registered?

[ringabout]

Another workaround(adding global pragmas):

var nameToProc {.compileTime, global.}: seq[(string, proc (): string {.nimcall.})]

[timotheecour]

see also nim-lang/RFCs#283 which is relevant; if both this issue is fixed and nim-lang/RFCs#283 is implemented, then:

var a {.compileTime,global.}: string # will be available at RT and CT, and value will cross-over bw CT and RT
var a {.global.}: string # will be available at RT and CT, and value will **not** cross-over bw CT and RT