[WIP] exportable pragmas

[timotheecour]

see tests

small example:

# foo.nim:
template myfoo0* = {.exportc: "myfoo0_in_c".}
# main.nim
import foo
proc bar() {.myfoo0, discardable.} = 12

caveats (help welcome)

right now this has some limitations:

• can't use a classical user defined pragma pragma inside a template pragma EDIT: actually it's possible for local pragma pragma, see tests; for non-loacl pragma pragmas, would require also exportable pragmas (v2) #13030
• can't use non exported template pragma inside exported template pragma EDIT: works, see tests
• [EDIT] ideally the pragmas would be evaluated at definition time and bind to symbols, not identifiers; see example myfooHijacked illustrating how a locally defined template pragma affects an imported pragma because it hijacks the identifier
  EDIT: this now works, no hijacking happens, see tests

note

see also #13030 for an alternative implementation

[Araq]

For some reason I missed this PR, I like it much better than #13030. Definitely how we should do things IMO, the pragma pragma always was weird.

[timotheecour]

• added more tests illustrating hijacking caveat
• this PR is actually complementary to exportable pragmas (v2) #13030 if we want to also support exported pragma pragma's, otherwise these template pragmas can use local pragma pragmas but can't be exported themselves.

The root cause of all this is we're binding identifiers, not symbols; if you can think of a way to bind symbols, that would improve things.
Hopefully doesn't block this PR

[timotheecour]

PTAL, I've resolved the main issues:

• template pragmas now try to resolve identifiers as symbols (unless template is {.dirty.})
• this removes hijacking (ditto, unless {.dirty.})
• also we now doesn't need to export foo if we have template bar = {.foo.}
• also we can now use pragma pragma's inside template pragmas

[timotheecour]

note

one question is how to handle this:

• tests/pragmas/tsym_as_pragma.nim (Argument named "closure" to proc inside template interfere with closure pragma #3171)
• tests/template/tparams_gensymed.nim (contains proc instSym(xOrig: int): int {.gensym, cdecl.} = inside a template so gensym clashes

[Araq]

I doubt this answers your question directly but effectively builtin pragmas are in their own namespace and only unknown pragmas are mapped to templates or pragma pragmas. I doubt too much can be done about this design without breaking too much code out there. This implies that bulitin pragmas inside templates should get the same special handing as e.g. the if keyword gets since effectively the builtin pragmas are keywords, albeit only enabled in a {. .} environment.

[timotheecour]

I believe this PR, once finished, will allow since to work with templates; right now you can't write:

template lenTuple*(t: tuple): int {.since: (1, 1).} =
  ## Return number of elements of `t`
  lenTuple(type(t))

because it gives: Error: cannot attach a custom pragma to 'lenTuple'

but once pragma's use PSym that bind locally, this should work

[Araq]

The CIs are all red but the feature is decent, please continue to work on it.

[stale]

This pull request has been automatically marked as stale because it has not had recent activity. If you think it is still a valid PR, please rebase it on the latest devel; otherwise it will be closed. Thank you for your contributions.

[stale]

This pull request has been automatically marked as stale because it has not had recent activity. If you think it is still a valid PR, please rebase it on the latest devel; otherwise it will be closed. Thank you for your contributions.