Feature request: macros as variable declaration pragmas

[mratsim]

Forum thread link.

Example:

Being to do this with a user-defined macro

{.pragma: align64, codegenDecl: "$# $# __attribute__((aligned(64)))".}
var foo{.align64.} = [1, 2, 3, 4]

macro align64*(x: untyped): untyped =
  expectKind(x, nnkIdent)
  result = x
  when defined(js):
    return
  # codegenDecl code goes here


# This works
proc foo() {.align64.} =
  discard


# Get this to work
let bar {.align64.} = [1, 2, 3, 4]

[yglukhov]

And for types as well! =)

Question is to which AST macros should be applied though?

let bar {.foo.} = 123

Might be transformed to

foo(let bar = 123)

or

let foo(bar) = 123

or smth else? The first variant looks more useful and allows crazier things. However, what if the let section has more decls?

let
  bar {.foo.} = 123
  buz = 456

Should the let section be split now to the following?

foo(let bar = 123)
let buz = 456

[fredrikhr]

Would also like this for Type declarations like:

import macros
macro myMagicTypeMacro(ast: untyped): untyped =
  result = ast

type MyMagicType {.myMagicTypeMacro.} = object of RootObj
  foo: int

[mratsim]

Related: #1930, #1930

[Skrylar]

In the case of Flatbuffers (and Capnproto, any serializer, etc) this would let you place format-specific tags on an object and avoid needing to take over the entire type section.

import macros

macro sporg(unused: untyped): untyped =
  discard

type
  thingdo = object
    foo {.sporg: true.}: int # something like this should work, as it does in C# (and Go, kind of)

macro cocainum(x: typedesc): untyped =
  let t = gettypeimpl(gettype(x)[1])
  echo lisprepr t

cocainum(thingdo)

[andreaferretti]

@Skrylar I tried to re-read your comment a few times but I could not parse it :-(

[Bulat-Ziganshin]

@andreaferretti he meant that now we can apply macro to type in this way:

sporg true:
  type thingdo = object foo: int

and this feature will allow to add per-type pragmas right to the type definitions

[Skrylar]

We have these now in the form of custom pragmas, which I have (locally) tested and you can use them for ORMs/automatic serialization code. The API to use custom pragmas is a slight bit painful, but I'm not sure this ticket needs to be open anymore?

[metagn]

This is now implemented, but without arguments like {.sporg: true.}, see https://nim-lang.org/docs/decls.html

[timotheecour]

the new design is being discussed here: nim-lang/RFCs#220, TLDR the syntax will likely change from (lhs,typ,rhs) params to a single AST param