макросы

Этот модуль содержит интерфейс к абстрактного синтаксического дерева (AST) компилятора. Макросы работают с этим деревом.

См. также:

AST в Nim

Этот раздел описывает, как AST моделируется с помощью системы типов Nim. AST состоит из узлов (NimNode) с переменным количеством дочерних узлов. Каждый узел имеет поле, названное kind, которое описывает содержимое узла:

type
  NimNodeKind = enum     ## kind of a node; only explanatory
    nnkNone,             ## invalid node kind
    nnkEmpty,            ## empty node
    nnkIdent,            ## node contains an identifier
    nnkIntLit,           ## node contains an int literal (example: 10)
    nnkStrLit,           ## node contains a string literal (example: "abc")
    nnkNilLit,           ## node contains a nil literal (example: nil)
    nnkCaseStmt,         ## node represents a case statement
    ...                  ## many more
  
  NimNode = ref NimNodeObj
  NimNodeObj = object
    case kind: NimNodeKind           ## the node's kind
    of nnkNone, nnkEmpty, nnkNilLit:
      discard                        ## node contains no additional fields
    of nnkCharLit..nnkUInt64Lit:
      intVal: BiggestInt             ## the int literal
    of nnkFloatLit..nnkFloat64Lit:
      floatVal: BiggestFloat         ## the float literal
    of nnkStrLit..nnkTripleStrLit, nnkCommentStmt, nnkIdent, nnkSym:
      strVal: string                 ## the string literal
    else:
      sons: seq[NimNode]             ## the node's sons (or children)

Для типа NimNode, оператор [] был перегружен: n[i] — это n-й дочерний узел.

Для указания AST для различных конструкций Nim используется обозначение nodekind(son1, son2, ...) или nodekind(value) или nodekind(field=value).

Некоторые дочерние узлы могут отсутствовать. Отсутствующий дочерний узел имеет тип nnkEmpty; дочерний узел никогда не может быть nil.

Листовые узлы/Атомы

Лист AST часто соответствует терминальному символу в конкретном синтаксисе. Обратите внимание, что по умолчанию float в Nim отображается как float64, так что по умолчанию AST для числа с плавающей запятой — это nnkFloat64Lit, как показано ниже.

Выражение Nim	Соответствующий AST
`42`	`nnkIntLit(intVal = 42)`
`42'i8`	`nnkInt8Lit(intVal = 42)`
`42'i16`	`nnkInt16Lit(intVal = 42)`
`42'i32`	`nnkInt32Lit(intVal = 42)`
`42'i64`	`nnkInt64Lit(intVal = 42)`
`42'u8`	`nnkUInt8Lit(intVal = 42)`
`42'u16`	`nnkUInt16Lit(intVal = 42)`
`42'u32`	`nnkUInt32Lit(intVal = 42)`
`42'u64`	`nnkUInt64Lit(intVal = 42)`
`42.0`	`nnkFloat64Lit(floatVal = 42.0)`
`42.0'f32`	`nnkFloat32Lit(floatVal = 42.0)`
`42.0'f64`	`nnkFloat64Lit(floatVal = 42.0)`
`"abc"`	`nnkStrLit(strVal = "abc")`
`r"abc"`	`nnkRStrLit(strVal = "abc")`
`"""abc"""`	`nnkTripleStrLit(strVal = "abc")`
`' '`	`nnkCharLit(intVal = 32)`
`nil`	`nnkNilLit()`
`myIdentifier`	`nnkIdent(strVal = "myIdentifier")`
`myIdentifier`	после прохода поиска: `nnkSym(strVal = "myIdentifier", ...)`

Идентификаторы — это узлы nnkIdent. После прохода поиска имён эти узлы преобразуются в узлы nnkSym.

Вызовы/выражения

Вызов команды

Конкретный синтаксис:

echo "abc", "xyz"

AST:

nnkCommand(
  nnkIdent("echo"),
  nnkStrLit("abc"),
  nnkStrLit("xyz")
)

Вызов с `()`

Конкретный синтаксис:

echo("abc", "xyz")

AST:

nnkCall(
  nnkIdent("echo"),
  nnkStrLit("abc"),
  nnkStrLit("xyz")
)

Вызов инфиксного оператора

Конкретный синтаксис:

"abc" & "xyz"

AST:

nnkInfix(
  nnkIdent("&"),
  nnkStrLit("abc"),
  nnkStrLit("xyz")
)

Обратите внимание, что при использовании нескольких инфиксных операторов команда анализируется с учётом приоритета операторов.

Конкретный синтаксис:

5 + 3 * 4

AST:

nnkInfix(
  nnkIdent("+"),
  nnkIntLit(5),
  nnkInfix(
    nnkIdent("*"),
    nnkIntLit(3),
    nnkIntLit(4)
  )
)

Если вы решите использовать инфиксные операторы в префиксной форме, AST будет вести себя как вызов родительской функции с nnkAccQuoted, как показано ниже:

Конкретный синтаксис:

`+`(3, 4)

AST:

nnkCall(
  nnkAccQuoted(
    nnkIdent("+")
  ),
  nnkIntLit(3),
  nnkIntLit(4)
)

Вызов префиксного оператора

Конкретный синтаксис:

? "xyz"

AST:

nnkPrefix(
  nnkIdent("?"),
  nnkStrLit("abc")
)

Вызов постфиксного оператора

Примечание: В Nim нет постфиксных операторов. Однако узел nnkPostfix используется для маркера экспорта звёздочкой *.

Конкретный синтаксис:

identifier*

AST:

nnkPostfix(
  nnkIdent("*"),
  nnkIdent("identifier")
)

Вызов с именованными аргументами

Конкретный синтаксис:

writeLine(file=stdout, "hallo")

AST:

nnkCall(
  nnkIdent("writeLine"),
  nnkExprEqExpr(
    nnkIdent("file"),
    nnkIdent("stdout")
  ),
  nnkStrLit("hallo")
)

Вызов с литералом необработанной строки

Это используется, например, в примерах bindSym здесь и с re"some regexp" в модуле регулярных выражений.

Конкретный синтаксис:

echo"abc"

AST:

nnkCallStrLit(
  nnkIdent("echo"),
  nnkRStrLit("hello")
)

Оператор разыменования `[]`

Конкретный синтаксис:

x[]

AST:

nnkDerefExpr(nnkIdent("x"))

Оператор addr

Конкретный синтаксис:

addr(x)

AST:

nnkAddr(nnkIdent("x"))

Оператор приведения типа

Конкретный синтаксис:

cast[T](x)

AST:

nnkCast(nnkIdent("T"), nnkIdent("x"))

Оператор доступа к объекту `.`

Конкретный синтаксис:

x.y

AST:

nnkDotExpr(nnkIdent("x"), nnkIdent("y"))

Если вы используете гибкий синтаксис вызова Nim (как в x.len()), результат будет таким же, но обернут в nnkCall.

Оператор доступа к массиву `[]`

Конкретный синтаксис:

x[y]

AST:

nnkBracketExpr(nnkIdent("x"), nnkIdent("y"))

Скобки

Скобки для влияния на приоритет операторов или построения кортежей создаются с помощью узла nnkPar.

Конкретный синтаксис:

(1, 2, (3))

AST:

nnkPar(nnkIntLit(1), nnkIntLit(2), nnkPar(nnkIntLit(3)))

Фигурные скобки

Фигурные скобки используются как конструктор множества.

Конкретный синтаксис:

{1, 2, 3}

AST:

nnkCurly(nnkIntLit(1), nnkIntLit(2), nnkIntLit(3))

При использовании как конструктора таблицы синтаксис отличается.

Конкретный синтаксис:

{a: 3, b: 5}

AST:

nnkTableConstr(
  nnkExprColonExpr(nnkIdent("a"), nnkIntLit(3)),
  nnkExprColonExpr(nnkIdent("b"), nnkIntLit(5))
)

Квадратные скобки

Квадратные скобки используются как конструктор массива.

Конкретный синтаксис:

[1, 2, 3]

AST:

nnkBracket(nnkIntLit(1), nnkIntLit(2), nnkIntLit(3))

Диапазоны

Диапазоны встречаются в конструкторах множеств, ветвях оператора case или срезах массивов. Внутренне используется тип узла nnkRange, но при построении AST вместо этого следует использовать построение с .. как инфиксным оператором.

Конкретный синтаксис:

1..3

AST:

nnkInfix(
  nnkIdent(".."),
  nnkIntLit(1),
  nnkIntLit(3)
)

Пример кода:

macro genRepeatEcho(): stmt =
  result = newNimNode(nnkStmtList)
  
  var forStmt = newNimNode(nnkForStmt) # generate a for statement
  forStmt.add(ident("i")) # use the variable `i` for iteration
  
  var rangeDef = newNimNode(nnkInfix).add(
    ident("..")).add(
    newIntLitNode(3),newIntLitNode(5)) # iterate over the range 3..5
  
  forStmt.add(rangeDef)
  forStmt.add(newCall(ident("echo"), newIntLitNode(3))) # meat of the loop
  result.add(forStmt)

genRepeatEcho() # gives:
                # 3
                # 3
                # 3

Выражение if

Представление выражения if тонкое, но легко просматривается.

Конкретный синтаксис:

if cond1: expr1 elif cond2: expr2 else: expr3

AST:

nnkIfExpr(
  nnkElifExpr(cond1, expr1),
  nnkElifExpr(cond2, expr2),
  nnkElseExpr(expr3)
)

Комментарии документации

Комментарии с двойным диез (##) в коде фактически имеют собственный формат, используя strVal для получения и установки текста комментария. Комментарии с одиночным диез (#) игнорируются.

Конкретный синтаксис:

## This is a comment
## This is part of the first comment
stmt1
## Yet another

AST:

nnkCommentStmt() # only appears once for the first two lines!
stmt1
nnkCommentStmt() # another nnkCommentStmt because there is another comment
                 # (separate from the first)

Директивы

Одной из интересных особенностей Nim являются директивы, позволяющие тонко настраивать различные аспекты языка. Они бывают разных типов, например, украшают процедуры и объекты, но отдельная директива emit демонстрирует основы с AST.

Конкретный синтаксис:

{.emit: "#include <stdio.h>".}

AST:

nnkPragma(
  nnkExprColonExpr(
    nnkIdent("emit"),
    nnkStrLit("#include <stdio.h>") # the "argument"
  )
)

Появляется столько nnkIdent , сколько директив находится между {..}. Обратите внимание, что объявление новых директив по сути то же самое:

Конкретный синтаксис:

{.pragma: cdeclRename, cdecl.}

AST:

nnkPragma(
  nnkExprColonExpr(
    nnkIdent("pragma"), # this is always first when declaring a new pragma
    nnkIdent("cdeclRename") # the name of the pragma
  ),
  nnkIdent("cdecl")
)

Операторы

Оператор if

Представление оператора if тонкое, но легко просматривается. Если нет ветви else, дочерний узел nnkElse отсутствует.

Конкретный синтаксис:

if cond1:
  stmt1
elif cond2:
  stmt2
elif cond3:
  stmt3
else:
  stmt4

AST:

nnkIfStmt(
  nnkElifBranch(cond1, stmt1),
  nnkElifBranch(cond2, stmt2),
  nnkElifBranch(cond3, stmt3),
  nnkElse(stmt4)
)

Оператор when

Как оператор if, но корень имеет тип nnkWhenStmt.

Присваивание

Конкретный синтаксис:

x = 42

AST:

nnkAsgn(nnkIdent("x"), nnkIntLit(42))

Это не синтаксис присваивания, когда он комбинируется с var, let, или const.

Список операторов

Конкретный синтаксис:

stmt1
stmt2
stmt3

AST:

nnkStmtList(stmt1, stmt2, stmt3)

Оператор case

Конкретный синтаксис:

case expr1
of expr2, expr3..expr4:
  stmt1
of expr5:
  stmt2
elif cond1:
  stmt3
else:
  stmt4

AST:

nnkCaseStmt(
  expr1,
  nnkOfBranch(expr2, nnkRange(expr3, expr4), stmt1),
  nnkOfBranch(expr5, stmt2),
  nnkElifBranch(cond1, stmt3),
  nnkElse(stmt4)
)

Части nnkElifBranch и nnkElse могут отсутствовать.

Оператор while

Конкретный синтаксис:

while expr1:
  stmt1

AST:

nnkWhileStmt(expr1, stmt1)

Оператор for

Конкретный синтаксис:

for ident1, ident2 in expr1:
  stmt1

AST:

nnkForStmt(ident1, ident2, expr1, stmt1)

Оператор try

Конкретный синтаксис:

try:
  stmt1
except e1, e2:
  stmt2
except e3:
  stmt3
except:
  stmt4
finally:
  stmt5

AST:

nnkTryStmt(
  stmt1,
  nnkExceptBranch(e1, e2, stmt2),
  nnkExceptBranch(e3, stmt3),
  nnkExceptBranch(stmt4),
  nnkFinally(stmt5)
)

Оператор return

Конкретный синтаксис:

return expr1

AST:

nnkReturnStmt(expr1)

Оператор yield

Как return, но с типом узла nnkYieldStmt.

nnkYieldStmt(expr1)

Оператор discard

Как return, но с типом узла nnkDiscardStmt.

nnkDiscardStmt(expr1)

Оператор continue

Конкретный синтаксис:

continue

AST:

nnkContinueStmt()

Оператор break

Конкретный синтаксис:

break otherLocation

AST:

nnkBreakStmt(nnkIdent("otherLocation"))

Если break используется без места перехода, nnkEmpty заменяет nnkIdent.

Оператор блока

Конкретный синтаксис:

block name:

AST:

nnkBlockStmt(nnkIdent("name"), nnkStmtList(...))

Блок block не нуждается в имени, в этом случае используется nnkEmpty.

Оператор asm

Конкретный синтаксис:

asm """
  some asm
"""

AST:

nnkAsmStmt(
  nnkEmpty(), # for pragmas
  nnkTripleStrLit("some asm"),
)

Раздел импорта

Заявление Nim's import фактически принимает различные варианты в зависимости от присутствующих ключевых слов. Начнем с самого простого варианта.

Конкретная синтаксическая запись:

import math

AST:

nnkImportStmt(nnkIdent("math"))

С except, мы получаем nnkImportExceptStmt.

Конкретная синтаксическая запись:

import math except pow

AST:

nnkImportExceptStmt(nnkIdent("math"),nnkIdent("pow"))

Обратите внимание, что import math as m не использует другой узел; вместо этого мы используем nnkImportStmt с as в качестве инфиксного оператора.

Конкретная синтаксическая запись:

import strutils as su

AST:

nnkImportStmt(
  nnkInfix(
    nnkIdent("as"),
    nnkIdent("strutils"),
    nnkIdent("su")
  )
)

Из заявления

Если мы используем from ... import, результат также отличается.

Конкретная синтаксическая запись:

from math import pow

AST:

nnkFromStmt(nnkIdent("math"), nnkIdent("pow"))

Использование from math as m import pow идентично модификатору as со import заявлением, но заключено в nnkFromStmt.

Заявление о выводе

Когда вы делаете импортированный модуль доступным для модулей, которые импортируют ваш модуль, синтаксис export довольно простой.

Конкретная синтаксическая запись:

export unsigned

AST:

nnkExportStmt(nnkIdent("unsigned"))

Подобно заявлению import, AST отличается для export ... except.

Конкретная синтаксическая запись:

export math except pow # we're going to implement our own exponentiation

AST:

nnkExportExceptStmt(nnkIdent("math"),nnkIdent("pow"))

Заявление об включении

Как и простое import заявление, но с nnkIncludeStmt.

Конкретная синтаксическая запись:

include blocks

AST:

nnkIncludeStmt(nnkIdent("blocks"))

Раздел Var

Конкретная синтаксическая запись:

var a = 3

AST:

nnkVarSection(
  nnkIdentDefs(
    nnkIdent("a"),
    nnkEmpty(), # or nnkIdent(...) if the variable declares the type
    nnkIntLit(3),
  )
)

Обратите внимание, что второй или третий (или оба) параметра выше должны существовать, так как компилятор должен каким-то образом узнать тип (который он может вывести из заданного присваивания).

Это не тот же AST для всех случаев использования var. Подробности см. в разделе Объявление процедуры.

Раздел Let

Это эквивалентно var, но с nnkLetSection вместо nnkVarSection.

Конкретная синтаксическая запись:

let a = 3

AST:

nnkLetSection(
  nnkIdentDefs(
    nnkIdent("a"),
    nnkEmpty(), # or nnkIdent(...) for the type
    nnkIntLit(3),
  )
)

Раздел Const

Конкретная синтаксическая запись:

const a = 3

AST:

nnkConstSection(
  nnkConstDef( # not nnkConstDefs!
    nnkIdent("a"),
    nnkEmpty(), # or nnkIdent(...) if the variable declares the type
    nnkIntLit(3), # required in a const declaration!
  )
)

Раздел Type

Начиная с простого случая, раздел type выглядит так же, как var и const.

Конкретная синтаксическая запись:

type A = int

AST:

nnkTypeSection(
  nnkTypeDef(
    nnkIdent("A"),
    nnkEmpty(),
    nnkIdent("int")
  )
)

Объявление типов distinct аналогично, при этом последнее nnkIdent заключено в nnkDistinctTy.

Конкретная синтаксическая запись:

type MyInt = distinct int

AST:

# ...
nnkTypeDef(
  nnkIdent("MyInt"),
  nnkEmpty(),
  nnkDistinctTy(
    nnkIdent("int")
  )
)

Если раздел type использует параметры обобщения, они обрабатываются здесь:

Конкретная синтаксическая запись:

type A[T] = expr1

AST:

nnkTypeSection(
  nnkTypeDef(
    nnkIdent("A"),
    nnkGenericParams(
      nnkIdentDefs(
        nnkIdent("T"),
        nnkEmpty(), # if the type is declared with options, like
                    # ``[T: SomeInteger]``, they are given here
        nnkEmpty(),
      )
    )
    expr1,
  )
)

Обратите внимание, что не все nnkTypeDef используют nnkIdent в качестве параметра. Одно из наиболее распространенных применений объявлений типов — работа с объектами.

Конкретная синтаксическая запись:

type IO = object of RootObj

AST:

# ...
nnkTypeDef(
  nnkIdent("IO"),
  nnkEmpty(),
  nnkObjectTy(
    nnkEmpty(), # no pragmas here
    nnkOfInherit(
      nnkIdent("RootObj") # inherits from RootObj
    )
    nnkEmpty()
  )
)

Синтаксис объектов Nim богат. Давайте рассмотрим сложный пример целиком, чтобы увидеть некоторые из сложностей.

Конкретная синтаксическая запись:

type Obj[T] = object {.inheritable.}
  name: string
  case isFat: bool
  of true:
    m: array[100_000, T]
  of false:
    m: array[10, T]

AST:

# ...
nnkObjectTy(
  nnkPragma(
    nnkIdent("inheritable")
  ),
  nnkEmpty(),
  nnkRecList( # list of object parameters
    nnkIdentDefs(
      nnkIdent("name"),
      nnkIdent("string"),
      nnkEmpty()
    ),
    nnkRecCase( # case statement within object (not nnkCaseStmt)
      nnkIdentDefs(
        nnkIdent("isFat"),
        nnkIdent("bool"),
        nnkEmpty()
      ),
      nnkOfBranch(
        nnkIdent("true"),
        nnkRecList( # again, a list of object parameters
          nnkIdentDefs(
            nnkIdent("m"),
            nnkBracketExpr(
              nnkIdent("array"),
              nnkIntLit(100000),
              nnkIdent("T")
            ),
            nnkEmpty()
        )
      ),
      nnkOfBranch(
        nnkIdent("false"),
        nnkRecList(
          nnkIdentDefs(
            nnkIdent("m"),
            nnkBracketExpr(
              nnkIdent("array"),
              nnkIntLit(10),
              nnkIdent("T")
            ),
            nnkEmpty()
          )
        )
      )
    )
  )
)

Использование enum аналогично использованию object.

Конкретная синтаксическая запись:

type X = enum
  First

AST:

# ...
nnkEnumTy(
  nnkEmpty(),
  nnkIdent("First") # you need at least one nnkIdent or the compiler complains
)

Использование concept (экспериментальная) аналогично объектам.

Конкретная синтаксическая запись:

type Con = concept x,y,z
  (x & y & z) is string

AST:

# ...
nnkTypeClassTy( # note this isn't nnkConceptTy!
  nnkArglist(
    # ... idents for x, y, z
  )
  # ...
)

Статические типы, такие как static[int], используют nnkIdent в nnkStaticTy.

Конкретная синтаксическая запись:

type A[T: static[int]] = object

AST:

# ... within nnkGenericParams
nnkIdentDefs(
  nnkIdent("T"),
  nnkStaticTy(
    nnkIdent("int")
  ),
  nnkEmpty()
)
# ...

В общем случае объявление типов отражает этот синтаксис (например, nnkStaticTy для static, и т. д.). Далее следуют примеры (исключения помечены как *):

Тип Nim	Соответствующий AST
`static`	`nnkStaticTy`
`tuple`	`nnkTupleTy`
`var`	`nnkVarTy`
`ptr`	`nnkPtrTy`
`ref`	`nnkRefTy`
`distinct`	`nnkDistinctTy`
`enum`	`nnkEnumTy`
`concept`	`nnkTypeClassTy`*
`array`	`nnkBracketExpr(nnkIdent("array"),...`*
`proc`	`nnkProcTy`
`iterator`	`nnkIteratorTy`
`object`	`nnkObjectTy`

Обращайте особое внимание при объявлении типов как proc. Поведение аналогично Procedure declaration, ниже, но nnkGenericParams не обрабатывается. Параметры обобщения обрабатываются в типе, а не в самом proc.

Конкретная синтаксическая запись:

type MyProc[T] = proc(x: T)

AST:

# ...
nnkTypeDef(
  nnkIdent("MyProc"),
  nnkGenericParams( # here, not with the proc
    # ...
  )
  nnkProcTy( # behaves like a procedure declaration from here on
    nnkFormalParams(
      # ...
    )
  )
)

Тот же синтаксис применяется к iterator (с nnkIteratorTy), но не применяется к converter или template.

Заявление Mixin

Конкретная синтаксическая запись:

mixin x

AST:

nnkMixinStmt(nnkIdent("x"))

Заявление Bind

Конкретная синтаксическая запись:

bind x

AST:

nnkBindStmt(nnkIdent("x"))

Объявление процедуры

Давайте рассмотрим процедуру со многими интересными аспектами, чтобы понять, как разбиваются вызовы процедур.

Конкретная синтаксическая запись:

proc hello*[T: SomeInteger](x: int = 3, y: float32): int {.inline.} = discard

AST:

nnkProcDef(
  nnkPostfix(nnkIdent("*"), nnkIdent("hello")), # the exported proc name
  nnkEmpty(), # patterns for term rewriting in templates and macros (not procs)
  nnkGenericParams( # generic type parameters, like with type declaration
    nnkIdentDefs(
      nnkIdent("T"),
      nnkIdent("SomeInteger"),
      nnkEmpty()
    )
  ),
  nnkFormalParams(
    nnkIdent("int"), # the first FormalParam is the return type. nnkEmpty() if there is none
    nnkIdentDefs(
      nnkIdent("x"),
      nnkIdent("int"), # type type (required for procs, not for templates)
      nnkIntLit(3) # a default value
    ),
    nnkIdentDefs(
      nnkIdent("y"),
      nnkIdent("float32"),
      nnkEmpty()
    )
  ),
  nnkPragma(nnkIdent("inline")),
  nnkEmpty(), # reserved slot for future use
  nnkStmtList(nnkDiscardStmt(nnkEmpty())) # the meat of the proc
)

Есть еще один момент. Nim имеет гибкую идентификацию типов для своих процедур. Несмотря на то, что proc(a: int, b: int) и proc(a, b: int) эквивалентны в коде, AST немного отличается для последнего.

Конкретная синтаксическая запись:

proc(a, b: int)

AST:

# ...AST as above...
nnkFormalParams(
  nnkEmpty(), # no return here
  nnkIdentDefs(
    nnkIdent("a"), # the first parameter
    nnkIdent("b"), # directly to the second parameter
    nnkIdent("int"), # their shared type identifier
    nnkEmpty(), # default value would go here
  )
),
# ...

Когда процедура использует специальную переменную типа возврата var, результат отличается от результата раздела var.

Конкретная синтаксическая запись:

proc hello(): var int

AST:

# ...
nnkFormalParams(
  nnkVarTy(
    nnkIdent("int")
  )
)

Объявление итератора

Синтаксис итераторов похож на процедуры, но nnkIteratorDef заменяет nnkProcDef.

Конкретная синтаксическая запись:

iterator nonsense[T](x: seq[T]): float {.closure.} = ...

AST:

nnkIteratorDef(
  nnkIdent("nonsense"),
  nnkEmpty(),
  ...
)

Объявление преобразователя

Преобразователь похож на процедуру.

Конкретная синтаксическая запись:

converter toBool(x: float): bool

AST:

nnkConverterDef(
  nnkIdent("toBool"),
  # ...
)

Объявление шаблона

Шаблоны (а также макросы, как мы увидим) имеют немного расширенный AST по сравнению с процедурами и итераторами. Причина в этом [макросы переписывания терминов](manual.html#term-rewriting-macros). Вы видите nnkEmpty() в качестве второго аргумента к nnkProcDef и nnkIteratorDef выше? Именно туда попадают макросы переписывания терминов.

Конкретная синтаксическая запись:

template optOpt{expr1}(a: int): int

AST:

nnkTemplateDef(
  nnkIdent("optOpt"),
  nnkStmtList( # instead of nnkEmpty()
    expr1
  ),
  # follows like a proc or iterator
)

Если шаблон не имеет типов для своих параметров, идентификаторы типов внутри nnkFormalParams просто становятся nnkEmpty.

Объявление макроса

Макросы ведут себя как шаблоны, но nnkTemplateDef заменяется на nnkMacroDef.

Особые виды узлов

Существует несколько видов узлов, используемых для семантической проверки или генерации кода. Они доступны из этого модуля, но не должны использоваться. Другие виды узлов специально разработаны для упрощения манипулирования AST. Они описаны здесь.

Будет написано позже.

Импорты

since

Типы

NimNodeKind = enum nnkNone, nnkEmpty, nnkIdent, nnkSym, nnkType, nnkCharLit, nnkIntLit, nnkInt8Lit, nnkInt16Lit, nnkInt32Lit, nnkInt64Lit, nnkUIntLit, nnkUInt8Lit, nnkUInt16Lit, nnkUInt32Lit, nnkUInt64Lit, nnkFloatLit, nnkFloat32Lit, nnkFloat64Lit, nnkFloat128Lit, nnkStrLit, nnkRStrLit, nnkTripleStrLit, nnkNilLit, nnkComesFrom, nnkDotCall, nnkCommand, nnkCall, nnkCallStrLit, nnkInfix, nnkPrefix, nnkPostfix, nnkHiddenCallConv, nnkExprEqExpr, nnkExprColonExpr, nnkIdentDefs, nnkVarTuple, nnkPar, nnkObjConstr, nnkCurly, nnkCurlyExpr, nnkBracket, nnkBracketExpr, nnkPragmaExpr, nnkRange, nnkDotExpr, nnkCheckedFieldExpr, nnkDerefExpr, nnkIfExpr, nnkElifExpr, nnkElseExpr, nnkLambda, nnkDo, nnkAccQuoted, nnkTableConstr, nnkBind, nnkClosedSymChoice, nnkOpenSymChoice, nnkHiddenStdConv, nnkHiddenSubConv, nnkConv, nnkCast, nnkStaticExpr, nnkAddr, nnkHiddenAddr, nnkHiddenDeref, nnkObjDownConv, nnkObjUpConv, nnkChckRangeF, nnkChckRange64, nnkChckRange, nnkStringToCString, nnkCStringToString, nnkAsgn, nnkFastAsgn, nnkGenericParams, nnkFormalParams, nnkOfInherit, nnkImportAs, nnkProcDef, nnkMethodDef, nnkConverterDef, nnkMacroDef, nnkTemplateDef, nnkIteratorDef, nnkOfBranch, nnkElifBranch, nnkExceptBranch, nnkElse, nnkAsmStmt, nnkPragma, nnkPragmaBlock, nnkIfStmt, nnkWhenStmt, nnkForStmt, nnkParForStmt, nnkWhileStmt, nnkCaseStmt, nnkTypeSection, nnkVarSection, nnkLetSection, nnkConstSection, nnkConstDef, nnkTypeDef, nnkYieldStmt, nnkDefer, nnkTryStmt, nnkFinally, nnkRaiseStmt, nnkReturnStmt, nnkBreakStmt, nnkContinueStmt, nnkBlockStmt, nnkStaticStmt, nnkDiscardStmt, nnkStmtList, nnkImportStmt, nnkImportExceptStmt, nnkExportStmt, nnkExportExceptStmt, nnkFromStmt, nnkIncludeStmt, nnkBindStmt, nnkMixinStmt, nnkUsingStmt, nnkCommentStmt, nnkStmtListExpr, nnkBlockExpr, nnkStmtListType, nnkBlockType, nnkWith, nnkWithout, nnkTypeOfExpr, nnkObjectTy, nnkTupleTy, nnkTupleClassTy, nnkTypeClassTy, nnkStaticTy, nnkRecList, nnkRecCase, nnkRecWhen, nnkRefTy, nnkPtrTy, nnkVarTy, nnkConstTy, nnkMutableTy, nnkDistinctTy, nnkProcTy, nnkIteratorTy, nnkSharedTy, nnkEnumTy, nnkEnumFieldDef, nnkArglist, nnkPattern, nnkHiddenTryStmt, nnkClosure, nnkGotoState, nnkState, nnkBreakState, nnkFuncDef, nnkTupleConstr: Исходный код Редактировать
NimNodeKinds = set[NimNodeKind]: Исходный код Редактировать
NimTypeKind = enum ntyNone, ntyBool, ntyChar, ntyEmpty, ntyAlias, ntyNil, ntyExpr, ntyStmt, ntyTypeDesc, ntyGenericInvocation, ntyGenericBody, ntyGenericInst, ntyGenericParam, ntyDistinct, ntyEnum, ntyOrdinal, ntyArray, ntyObject, ntyTuple, ntySet, ntyRange, ntyPtr, ntyRef, ntyVar, ntySequence, ntyProc, ntyPointer, ntyOpenArray, ntyString, ntyCString, ntyForward, ntyInt, ntyInt8, ntyInt16, ntyInt32, ntyInt64, ntyFloat, ntyFloat32, ntyFloat64, ntyFloat128, ntyUInt, ntyUInt8, ntyUInt16, ntyUInt32, ntyUInt64, ntyUnused0, ntyUnused1, ntyUnused2, ntyVarargs, ntyUncheckedArray, ntyError, ntyBuiltinTypeClass, ntyUserTypeClass, ntyUserTypeClassInst, ntyCompositeTypeClass, ntyInferred, ntyAnd, ntyOr, ntyNot, ntyAnything, ntyStatic, ntyFromExpr, ntyOptDeprecated, ntyVoid: Исходный код Редактировать
TNimTypeKinds {...}{.deprecated.} = set[NimTypeKind]: Исходный код Редактировать
NimSymKind = enum nskUnknown, nskConditional, nskDynLib, nskParam, nskGenericParam, nskTemp, nskModule, nskType, nskVar, nskLet, nskConst, nskResult, nskProc, nskFunc, nskMethod, nskIterator, nskConverter, nskMacro, nskTemplate, nskField, nskEnumField, nskForVar, nskLabel, nskStub: Исходный код Редактировать
TNimSymKinds {...}{.deprecated.} = set[NimSymKind]: Исходный код Редактировать
NimIdent {...}{.deprecated.} = object of RootObj: Представляет идентификатор Nim в AST. Примечание: Это редко используется, для создания идентификатора из строки используйте ident"abc". Исходный код Редактировать
NimSym {...}{.deprecated.} = ref NimSymObj: Представляет символ Nim в компиляторе; символ — это идентификатор, по которому производится поиск. Исходный код Редактировать
BindSymRule = enum brClosed, ## only the symbols in current scope are bound brOpen, ## open wrt overloaded symbols, but may be a single ## symbol if not ambiguous (the rules match that of ## binding in generics) brForceOpen ## same as brOpen, but it will always be open even ## if not ambiguous (this cannot be achieved with ## any other means in the language currently): определяет, как ведет себя bindSym Исходный код Редактировать
LineInfo = object filename*: string line*, column*: int: Исходный код Редактировать

Константы

nnkLiterals = {nnkCharLit..nnkNilLit}: Исходный код Редактировать
nnkCallKinds = {nnkCall, nnkInfix, nnkPrefix, nnkPostfix, nnkCommand, nnkCallStrLit}: Исходный код Редактировать
RoutineNodes = {nnkProcDef, nnkFuncDef, nnkMethodDef, nnkDo, nnkLambda, nnkIteratorDef, nnkTemplateDef, nnkConverterDef, nnkMacroDef}: Исходный код Редактировать
AtomicNodes = {nnkNone..nnkNilLit}: Исходный код Редактировать
CallNodes = {nnkCall, nnkInfix, nnkPrefix, nnkPostfix, nnkCommand, nnkCallStrLit, nnkHiddenCallConv}: Исходный код Редактировать

Процедуры

proc toNimIdent(s: string): NimIdent {...}{.magic: "StrToIdent", noSideEffect, deprecated: "Deprecated since version 0.18.0: Use \'ident\' or \'newIdentNode\' instead.".}

Устаревшее: Устарело начиная с версии 0.18.0: Используйте 'ident' или 'newIdentNode' вместо этого.

Создаёт идентификатор из строки s. Исходный код Редактировать

proc `==`(a, b: NimIdent): bool {...}{.magic: "EqIdent", noSideEffect, deprecated: "Deprecated since version 0.18.1; Use \'==\' on \'NimNode\' instead.".}

Устаревшее: Устарело начиная с версии 0.18.1; Используйте '==' на 'NimNode' вместо этого.

Сравнивает два идентификатора Nim. Исходный код Редактировать

proc `==`(a, b: NimNode): bool {...}{.magic: "EqNimrodNode", noSideEffect.}

Сравнивает два узла Nim. Возвращает true, если узлы структурно эквивалентны. Это означает, что два независимо созданных узла могут быть равны. Исходный код Редактировать

proc `==`(a, b: NimSym): bool {...}{.magic: "EqNimrodNode", noSideEffect, deprecated: "Deprecated since version 0.18.1; Use \'==(NimNode, NimNode)\' instead.".}

Устаревшее: Устарело начиная с версии 0.18.1; Используйте '==(NimNode, NimNode)' вместо этого.

Сравнивает два символа Nim. Исходный код Редактировать

proc sameType(a, b: NimNode): bool {...}{.magic: "SameNodeType", noSideEffect, raises: [], tags: [].}

Сравнивает типы двух узлов Nim. Возвращает true, если типы одинаковы, например, при сравнении алиаса с исходным типом. Исходный код Редактировать

proc len(n: NimNode): int {...}{.magic: "NLen", noSideEffect.}

Возвращает количество дочерних элементов n. Исходный код Редактировать

proc `[]`(n: NimNode; i: int): NimNode {...}{.magic: "NChild", noSideEffect.}

Получить n's i-й дочерний элемент. Исходный код Редактировать

proc `[]`(n: NimNode; i: BackwardsIndex): NimNode {...}{.raises: [], tags: [].}

Получить n's i-й дочерний элемент. Исходный код Редактировать

proc `[]`[T, U](n: NimNode; x: HSlice[T, U]): seq[NimNode]

Операция среза для NimNode. Возвращает последовательность дочерних элементов n в пределах диапазона [n[x.a], n[x.b]]. Исходный код Редактировать

proc `[]=`(n: NimNode; i: int; child: NimNode) {...}{.magic: "NSetChild", noSideEffect.}

Установить n's i-й дочерний элемент в child. Исходный код Редактировать

proc `[]=`(n: NimNode; i: BackwardsIndex; child: NimNode) {...}{.raises: [], tags: [].}

Установить n's i-й дочерний элемент в child. Исходный код Редактировать

proc add(father, child: NimNode): NimNode {...}{.magic: "NAdd", discardable, noSideEffect, locks: 0.}

Добавляет child к узлу father. Возвращает родительский узел для вложенных вызовов. Исходный код Редактировать

proc add(father: NimNode; children: varargs[NimNode]): NimNode {...}{. magic: "NAddMultiple", discardable, noSideEffect, locks: 0.}

Добавляет каждый дочерний элемент children к узлу father. Возвращает узел father для вложенных вызовов. Исходный код Редактировать

proc del(father: NimNode; idx = 0; n = 1) {...}{.magic: "NDel", noSideEffect.}

Удаляет n дочерних элементов father, начиная с индекса idx. Исходный код Редактировать

proc kind(n: NimNode): NimNodeKind {...}{.magic: "NKind", noSideEffect.}

Возвращает kind узла n. Исходный код Редактировать

proc intVal(n: NimNode): BiggestInt {...}{.magic: "NIntVal", noSideEffect.}

Возвращает целое значение из любого целочисленного литерала или символа поля перечисления. Исходный код Редактировать

proc floatVal(n: NimNode): BiggestFloat {...}{.magic: "NFloatVal", noSideEffect.}

Возвращает число с плавающей точкой из любого литерала с плавающей точкой. Исходный код Редактировать

proc ident(n: NimNode): NimIdent {...}{.magic: "NIdent", noSideEffect, deprecated: "Deprecated since version 0.18.1; All functionality is defined on \'NimNode\'.".}

Устаревшее: Устарело начиная с версии 0.18.1; Вся функциональность определена в 'NimNode'.

макросы

AST в Nim

Листовые узлы/Атомы

Вызовы/выражения

Вызов команды

Вызов с ()

Вызов инфиксного оператора

Вызов префиксного оператора

Вызов постфиксного оператора

Вызов с именованными аргументами

Вызов с литералом необработанной строки

Оператор разыменования []

Оператор addr

Оператор приведения типа

Оператор доступа к объекту .

Оператор доступа к массиву []

Скобки

Фигурные скобки

Квадратные скобки

Диапазоны

Выражение if

Комментарии документации

Директивы

Операторы

Оператор if

Оператор when

Присваивание

Список операторов

Оператор case

Оператор while

Оператор for

Оператор try

Оператор return

Оператор yield

Оператор discard

Оператор continue

Оператор break

Оператор блока

Оператор asm

Раздел импорта

Из заявления

Заявление о выводе

Заявление об включении

Раздел Var

Раздел Let

Раздел Const

Раздел Type

Заявление Mixin

Заявление Bind

Объявление процедуры

Объявление итератора

Объявление преобразователя

Объявление шаблона

Объявление макроса

Особые виды узлов

Импорты

Типы

Константы

Процедуры

Итераторы

Макросы

Шаблоны

Вызов с `()`

Оператор разыменования `[]`

Оператор доступа к объекту `.`

Оператор доступа к массиву `[]`