Mirror of forum.nim-lang.org

894 :: AST differs when pragma parameter is `stmt` vs `expr`

• jboy (orginal) [2015-02-19T10:56:55+01:00] view original

  Here's something that took me by surprise.

  If you have a macro that you're using as a pragma, and the parameter type of the macro is declared as stmt rather than expr, you get a different abstract syntax tree.

  Specifically, in the expr case, the ProcDef will include the proc name as an Ident, followed by a postfix Ident of an asterisk (*) if the proc is to be exported from the module. This is what is documented in the macros module documentation for the nnkPostfix postfix operator.

  But in the stmt case, the ProcDef will include the proc name as a Sym, without any export asterisk included.

  Here are the salient differences in the treeRepr:

  
  testexport.nim(4, 8) Hint: pragmaArgExpr [User]
  testexport.nim(5, 8) Hint: ProcDef
    Postfix
      Ident !"*"
      Ident !"foo2"
    Empty
    Empty
    FormalParams
  Run

  vs:

  
  testexport.nim(8, 8) Hint: pragmaArgStmt [User]
  testexport.nim(9, 8) Hint: ProcDef
    Sym "foo3"
    Empty
    Empty
    FormalParams
  Run

  If instead of using treeRepr from inside a pragma macro, I use a dumpTree block, the Ident and postfix asterisk come back:

  
  StmtList
    StrLit dumpTree
    ProcDef
      Postfix
        Ident !"*"
        Ident !"foo1"
      Empty
      Empty
      FormalParams
  Run

  If you want to play along at home, here is the test code I used:

  
  import macros
  
  macro pragmaArgExpr(e: expr): stmt =
      hint("pragmaArgExpr")
      hint(treeRepr(e))
  
  macro pragmaArgStmt(s: stmt): stmt =
      hint("pragmaArgStmt")
      hint(treeRepr(s))
  
  dumpTree:
      "dumpTree"
      proc foo1*(i: int): int = return 1
  
  proc foo2*(i: int): int {.pragmaArgExpr.} = return 1
  
  proc foo3*(i: int): int {.pragmaArgStmt.} = return 1
  Run

  Is this difference intended? I couldn't find any mention of it in the Nim manual or macros module doc.

  If it is an intentional difference, what's the purpose?

  Thanks for any insight anyone can offer.

---

• Araq (orginal) [2015-02-19T11:16:40+01:00] view original

  The difference is intentional, Nim's expr is becoming the only metatype that means "lazy semantic checking" so you get the AST before semantic checking which involves type checking and symbol lookups, and with stmt you get the AST after semantic checking. The plan is to get rid of the immediate vs not immediate distinction this way, so a macro/template which has only expr parameters is immediate and every other template/macro is not.

---

• jboy (orginal) [2015-02-19T11:22:10+01:00] view original

  Ah, very interesting. Thanks for the explanation.

  (I've also wished for more semantic checking in macros & templates.)

---

• jboy (orginal) [2015-02-20T03:37:43+01:00] view original

  Hi again, I've been pondering this information and I have some further questions:

  1. If I want to define a statement macro foo that receives a block of code before semantic checking, what type should I use for foo's "body" parameter? stmt? expr? Something else?
  2. Will the AST provided to foo's "body" parameter be a StmtList at its top level, or something else?
  3. Will the definition of dumpTree change to specify this same parameter type as foo will use?

  Thanks.

---

• Araq (orginal) [2015-02-20T10:05:19+01:00] view original

  expr

  yes

  no and I don't see what you are after here.

---

• jboy (orginal) [2015-02-20T11:35:34+01:00] view original

  Hi @Araq, thanks for the info.

  To respond to your point #3, I'm simply wondering whether dumpTree will print a version of the AST before or after semantic checking, that's all.

  Currently, dumpTree is declared with parameter of stmt, which (according to your explanation) would mean that it would print the AST after semantic checking (when identifiers have become symbols, etc.). That's why I was asking whether the definition of dumpTree would change (to instead take a parameter of expr, for example).

---

• Araq (orginal) [2015-02-20T12:33:24+01:00] view original

  Ah ok, well dumpTree will change its signature to expr as soon as the .immediate disappears, yes.

---