import std/private/since

whendefined(nimPreviewSlimSystem):

import std/[assertions, formatfloat]

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, nnkOutTy,

nnkDistinctTy,

nnkProcTy,

nnkIteratorTy, # iterator type

nnkSinkAsgn,

nnkEnumTy,

nnkEnumFieldDef,

nnkArgList, nnkPattern

nnkHiddenTryStmt,

nnkClosure,

nnkGotoState,

nnkState,

nnkBreakState,

nnkFuncDef,

nnkTupleConstr,

nnkError, ## erroneous AST node

nnkModuleRef, nnkReplayAction, nnkNilRodNode ## internal IC nodes

nnkOpenSym

NimNodeKinds*=set[NimNodeKind]

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]

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]

nnkMutableTy* {.deprecated.} = nnkOutTy

nnkSharedTy* {.deprecated.} = nnkSinkAsgn

NimIdent* {.deprecated.} =objectofRootObj

NimSym* {.deprecated.} =refNimSymObj

nnkLiterals*= {nnkCharLit..nnkNilLit}

nnkCallKinds*= {nnkCall, nnkInfix, nnkPrefix, nnkPostfix, nnkCommand,

nnkCallStrLit, nnkHiddenCallConv}

nnkPragmaCallKinds = {nnkExprColonExpr, nnkCall, nnkCallStrLit}

{.pushwarnings: off.}

proctoNimIdent*(s: string): NimIdent {.magic: "StrToIdent", noSideEffect, deprecated:

"Deprecated since version 0.18.0: Use 'ident' or 'newIdentNode' instead.".}

proc`==`*(a, b: NimIdent): bool {.magic: "EqIdent", noSideEffect, deprecated:

"Deprecated since version 0.18.1; Use '==' on 'NimNode' instead.".}

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

proc`==`*(a, b: NimSym): bool {.magic: "EqNimrodNode", noSideEffect, deprecated:

"Deprecated since version 0.18.1; Use '==(NimNode, NimNode)' instead.".}

{.pop.}

procsameType*(a, b: NimNode): bool {.magic: "SameNodeType", noSideEffect.} =

proclen*(n: NimNode): int {.magic: "NLen", noSideEffect.}

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

proc`[]`*(n: NimNode, i: BackwardsIndex): NimNode= n[n.len - i.int]

template`^^`(n: NimNode, i: untyped): untyped=

(when i isBackwardsIndex: n.len -int(i) else: int(i))

proc`[]`*[T, U: Ordinal](n: NimNode, x: HSlice[T, U]): seq[NimNode] =

let xa = n ^^ x.a

let L = (n ^^ x.b) - xa +1

result=newSeq[NimNode](L)

for i in0..<L:

result[i] = n[i + xa]

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

noSideEffect.}

proc`[]=`*(n: NimNode, i: BackwardsIndex, child: NimNode) =

n[n.len - i.int] = child

template`or`*(x, y: NimNode): NimNode=

let arg = x

if arg !=niland arg.kind != nnkEmpty:

arg

else:

y

procadd*(father, child: NimNode): NimNode {.magic: "NAdd", discardable,

noSideEffect.}

procadd*(father: NimNode, children: varargs[NimNode]): NimNode {.

magic: "NAddMultiple", discardable, noSideEffect.}

procdel*(father: NimNode, idx =0, n =1) {.magic: "NDel", noSideEffect.}

prockind*(n: NimNode): NimNodeKind {.magic: "NKind", noSideEffect.}

procintVal*(n: NimNode): BiggestInt {.magic: "NIntVal", noSideEffect.}

procfloatVal*(n: NimNode): BiggestFloat {.magic: "NFloatVal", noSideEffect.}

procsymKind*(symbol: NimNode): NimSymKind {.magic: "NSymKind", noSideEffect.}

procgetImpl*(symbol: NimNode): NimNode {.magic: "GetImpl", noSideEffect.}

procstrVal*(n: NimNode): string {.magic: "NStrVal", noSideEffect.}

{.pushwarnings: off.} # silence `deprecated`

procident*(n: NimNode): NimIdent {.magic: "NIdent", noSideEffect, deprecated:

"Deprecated since version 0.18.1; All functionality is defined on 'NimNode'.".}

procsymbol*(n: NimNode): NimSym {.magic: "NSymbol", noSideEffect, deprecated:

"Deprecated since version 0.18.1; All functionality is defined on 'NimNode'.".}

procgetImpl*(s: NimSym): NimNode {.magic: "GetImpl", noSideEffect, deprecated: "use `getImpl: NimNode -> NimNode` instead".}

proc`$`*(i: NimIdent): string {.magic: "NStrVal", noSideEffect, deprecated:

"Deprecated since version 0.18.1; Use 'strVal' instead.".}

proc`$`*(s: NimSym): string {.magic: "NStrVal", noSideEffect, deprecated:

"Deprecated since version 0.18.1; Use 'strVal' instead.".}

{.pop.}

when (NimMajor, NimMinor, NimPatch) >= (1, 3, 5) ordefined(nimSymImplTransform):

procgetImplTransformed*(symbol: NimNode): NimNode {.magic: "GetImplTransf", noSideEffect.}

procowner*(sym: NimNode): NimNode {.magic: "SymOwner", noSideEffect, deprecated.}

procisInstantiationOf*(instanceProcSym, genProcSym: NimNode): bool {.magic: "SymIsInstantiationOf", noSideEffect.}

procgetType*(n: NimNode): NimNode {.magic: "NGetType", noSideEffect.}

procgetType*(n: typedesc): NimNode {.magic: "NGetType", noSideEffect.}

proctypeKind*(n: NimNode): NimTypeKind {.magic: "NGetType", noSideEffect.}

procgetTypeInst*(n: NimNode): NimNode {.magic: "NGetType", noSideEffect.} =

runnableExamples:

Vec[N: static[int], T] =object

arr: array[N, T]

Vec4[T] =Vec[4, T]

Vec4f=Vec4[float32]

var a: Vec4f

var b: Vec4[float32]

var c: Vec[4, float32]

macrodumpTypeInst(x: typed): untyped=

newLit(x.getTypeInst.repr)

doAssert(dumpTypeInst(a) =="Vec4f")

doAssert(dumpTypeInst(b) =="Vec4[float32]")

doAssert(dumpTypeInst(c) =="Vec[4, float32]")

procgetTypeInst*(n: typedesc): NimNode {.magic: "NGetType", noSideEffect.}

procgetTypeImpl*(n: NimNode): NimNode {.magic: "NGetType", noSideEffect.} =

runnableExamples:

Vec[N: static[int], T] =object

arr: array[N, T]

Vec4[T] =Vec[4, T]

Vec4f=Vec4[float32]

var a: Vec4f

var b: Vec4[float32]

var c: Vec[4, float32]

macrodumpTypeImpl(x: typed): untyped=

newLit(x.getTypeImpl.repr)

let t ="""

doAssert(dumpTypeImpl(a) == t)

doAssert(dumpTypeImpl(b) == t)

doAssert(dumpTypeImpl(c) == t)

procsignatureHash*(n: NimNode): string {.magic: "NSigHash", noSideEffect.}

procsymBodyHash*(s: NimNode): string {.noSideEffect.} =

procgetTypeImpl*(n: typedesc): NimNode {.magic: "NGetType", noSideEffect.}

proc`intVal=`*(n: NimNode, val: BiggestInt) {.magic: "NSetIntVal", noSideEffect.}

proc`floatVal=`*(n: NimNode, val: BiggestFloat) {.magic: "NSetFloatVal", noSideEffect.}

{.pushwarnings: off.}

proc`symbol=`*(n: NimNode, val: NimSym) {.magic: "NSetSymbol", noSideEffect, deprecated:

"Deprecated since version 0.18.1; Generate a new 'NimNode' with 'genSym' instead.".}

proc`ident=`*(n: NimNode, val: NimIdent) {.magic: "NSetIdent", noSideEffect, deprecated:

"Deprecated since version 0.18.1; Generate a new 'NimNode' with 'ident(string)' instead.".}

{.pop.}

proc`strVal=`*(n: NimNode, val: string) {.magic: "NSetStrVal", noSideEffect.}

procnewNimNode*(kind: NimNodeKind,

lineInfoFrom: NimNode=nil): NimNode

{.magic: "NNewNimNode", noSideEffect.}

proccopyNimNode*(n: NimNode): NimNode {.magic: "NCopyNimNode", noSideEffect.} =

runnableExamples:

macrofoo(x: typed) =

var s =copyNimNode(x)

doAssert s.len ==0

doAssert s.kind == nnkStmtList

foo:

let x =12

echo x

proccopyNimTree*(n: NimNode): NimNode {.magic: "NCopyNimTree", noSideEffect.} =

runnableExamples:

macrofoo(x: typed) =

var s =copyNimTree(x)

doAssert s.len ==2

doAssert s.kind == nnkStmtList

foo:

let x =12

echo x

whendefined(nimHasNoReturnError):

{.pragma: errorNoReturn, noreturn.}

else:

{.pragma: errorNoReturn.}

procerror*(msg: string, n: NimNode=nil) {.magic: "NError", benign, errorNoReturn.}

procwarning*(msg: string, n: NimNode=nil) {.magic: "NWarning", benign.}

prochint*(msg: string, n: NimNode=nil) {.magic: "NHint", benign.}

procnewStrLitNode*(s: string): NimNode {.noSideEffect.} =

result=newNimNode(nnkStrLit)

result.strVal = s

procnewCommentStmtNode*(s: string): NimNode {.noSideEffect.} =

result=newNimNode(nnkCommentStmt)

result.strVal = s

procnewIntLitNode*(i: BiggestInt): NimNode=

result=newNimNode(nnkIntLit)

result.intVal = i

procnewFloatLitNode*(f: BiggestFloat): NimNode=

result=newNimNode(nnkFloatLit)

result.floatVal = f

{.pushwarnings: off.}

procnewIdentNode*(i: NimIdent): NimNode {.deprecated: "use ident(string)".} =

result=newNimNode(nnkIdent)

result.ident = i

{.pop.}

procnewIdentNode*(i: string): NimNode {.magic: "StrToIdent", noSideEffect.}

procident*(name: string): NimNode {.magic: "StrToIdent", noSideEffect.}

brClosed, ## only the symbols in current scope are bound

brOpen, ## open for overloaded symbols, but may be a single

brForceOpen ## same as brOpen, but it will always be open even

procbindSym*(ident: string|NimNode, rule: BindSymRule= brClosed): NimNode {.

magic: "NBindSym", noSideEffect.}

procgenSym*(kind: NimSymKind= nskLet; ident =""): NimNode {.

magic: "NGenSym", noSideEffect.}

proccallsite*(): NimNode {.magic: "NCallSite", benign, deprecated:

"Deprecated since v0.18.1; use `varargs[untyped]` in the macro prototype instead".}

proctoStrLit*(n: NimNode): NimNode=

returnnewStrLitNode(repr(n))

filename*: string

line*,column*: int

proc`$`*(arg: LineInfo): string=

result= arg.filename &"("&$arg.line &", "&$arg.column &")"

procgetLine(arg: NimNode): int {.magic: "NLineInfo", noSideEffect.}

procgetColumn(arg: NimNode): int {.magic: "NLineInfo", noSideEffect.}

procgetFile(arg: NimNode): string {.magic: "NLineInfo", noSideEffect.}

proccopyLineInfo*(arg: NimNode, info: NimNode) {.magic: "NLineInfo", noSideEffect.}

procsetLine(arg: NimNode, line: uint16) {.magic: "NLineInfo", noSideEffect.}

procsetColumn(arg: NimNode, column: int16) {.magic: "NLineInfo", noSideEffect.}

procsetFile(arg: NimNode, file: string) {.magic: "NLineInfo", noSideEffect.}

procsetLineInfo*(arg: NimNode, file: string, line: int, column: int) =

arg.setFile(file)

arg.setLine(line.uint16)

arg.setColumn(column.int16)

procsetLineInfo*(arg: NimNode, lineInfo: LineInfo) =

setLineInfo(arg, lineInfo.filename, lineInfo.line, lineInfo.column)

proclineInfoObj*(n: NimNode): LineInfo=

result=LineInfo(filename: n.getFile, line: n.getLine, column: n.getColumn)

proclineInfo*(arg: NimNode): string=

$arg.lineInfoObj

procinternalParseExpr(s, filename: string): NimNode {.

magic: "ParseExprToAst", noSideEffect.}

procinternalParseStmt(s, filename: string): NimNode {.

magic: "ParseStmtToAst", noSideEffect.}

procinternalErrorFlag*(): string {.magic: "NError", noSideEffect.}

procparseExpr*(s: string; filename: string=""): NimNode {.noSideEffect.} =

result=internalParseExpr(s, filename)

let x =internalErrorFlag()

if x.len >0: raisenewException(ValueError, x)

procparseStmt*(s: string; filename: string=""): NimNode {.noSideEffect.} =

result=internalParseStmt(s, filename)

let x =internalErrorFlag()

if x.len >0: raisenewException(ValueError, x)

procgetAst*(macroOrTemplate: untyped): NimNode {.magic: "ExpandToAst", noSideEffect.}

procquote*(bl: typed, op ="``"): NimNode {.magic: "QuoteAst", noSideEffect.} =

runnableExamples:

macrocheck(ex: untyped) =

var info = ex.lineinfo

var expString = ex.toStrLit

result=quotedo:

ifnot `ex`:

echo `info` &": Check failed: "& `expString`

runnableExamples:

var destroyCalled =false

macrobar() =

let s =newTree(nnkAccQuoted, ident"=destroy")

result=quotedo:

proc`s`(a: varFoo) = destroyCalled =true

block:

let a =Foo()

bar()

doAssert destroyCalled

runnableExamples:

var destroyCalled =false

macrobar(ident) =

var x =1.5

result=quote("@") do:

let `@ident` =0# custom op interpolated symbols need quoted (``)

proc`=destroy`(a: varFoo) =

doAssert@x ==1.5

doAssertcompiles(@x ==1.5)

let b1 =@[1,2]

let b2 =@@[1,2]

doAssert$b1 =="[1, 2]"

doAssert$b2 =="@[1, 2]"

destroyCalled =true

block:

let a =Foo()

bar(someident)

doAssert destroyCalled

proc`&%`(x: int): int=1

proc`&%`(x, y: int): int=2

macrobar2() =

var x =3

result=quote("&%") do:

var y =&%x # quoting operator

doAssert&%&%y ==1# unary operator => need to escape

doAssert y &% y ==2# binary operator => no need to escape

doAssert y ==3

bar2()

procexpectKind*(n: NimNode, k: NimNodeKind) =

if n.kind != k: error("Expected a node of kind "&$k &", got "&$n.kind, n)

procexpectMinLen*(n: NimNode, min: int) =

if n.len < min: error("Expected a node with at least "&$min &" children, got "&$n.len, n)

procexpectLen*(n: NimNode, len: int) =

if n.len != len: error("Expected a node with "&$len &" children, got "&$n.len, n)

procexpectLen*(n: NimNode, min, max: int) =

if n.len < min or n.len > max:

error("Expected a node with "&$min &".."&$max &" children, got "&$n.len, n)

procnewTree*(kind: NimNodeKind,

children: varargs[NimNode]): NimNode=

result=newNimNode(kind)

result.add(children)

procnewCall*(theProc: NimNode, args: varargs[NimNode]): NimNode=

result=newNimNode(nnkCall)

result.add(theProc)

result.add(args)

{.pushwarnings: off.}

procnewCall*(theProc: NimIdent, args: varargs[NimNode]): NimNode {.deprecated:

"Deprecated since v0.18.1; use 'newCall(string, ...)' or 'newCall(NimNode, ...)' instead".} =

result=newNimNode(nnkCall)

result.add(newIdentNode(theProc))

result.add(args)

{.pop.}

procnewCall*(theProc: string,

args: varargs[NimNode]): NimNode=

result=newNimNode(nnkCall)

result.add(newIdentNode(theProc))

result.add(args)

procnewLit*(c: char): NimNode=

result=newNimNode(nnkCharLit)

result.intVal =ord(c)

procnewLit*(i: int): NimNode=

result=newNimNode(nnkIntLit)

result.intVal = i

procnewLit*(i: int8): NimNode=

result=newNimNode(nnkInt8Lit)

result.intVal = i

procnewLit*(i: int16): NimNode=

result=newNimNode(nnkInt16Lit)

result.intVal = i

procnewLit*(i: int32): NimNode=

result=newNimNode(nnkInt32Lit)

result.intVal = i

procnewLit*(i: int64): NimNode=

result=newNimNode(nnkInt64Lit)

result.intVal = i

procnewLit*(i: uint): NimNode=

result=newNimNode(nnkUIntLit)

result.intVal =BiggestInt(i)

procnewLit*(i: uint8): NimNode=

result=newNimNode(nnkUInt8Lit)

result.intVal =BiggestInt(i)

procnewLit*(i: uint16): NimNode=

result=newNimNode(nnkUInt16Lit)

result.intVal =BiggestInt(i)

procnewLit*(i: uint32): NimNode=

result=newNimNode(nnkUInt32Lit)

result.intVal =BiggestInt(i)

procnewLit*(i: uint64): NimNode=

result=newNimNode(nnkUInt64Lit)

result.intVal =BiggestInt(i)

procnewLit*(b: bool): NimNode=

result=if b: bindSym"true"else: bindSym"false"

procnewLit*(s: string): NimNode=

result=newNimNode(nnkStrLit)

result.strVal = s

whenfalse:

procnewLit*(f: float): NimNode=

result=newNimNode(nnkFloatLit)

result.floatVal = f

procnewLit*(f: float32): NimNode=

result=newNimNode(nnkFloat32Lit)

result.floatVal = f

procnewLit*(f: float64): NimNode=

result=newNimNode(nnkFloat64Lit)

result.floatVal = f

whendeclared(float128):

procnewLit*(f: float128): NimNode=

result=newNimNode(nnkFloat128Lit)

result.floatVal = f

procnewLit*(arg: enum): NimNode=

result=newCall(

arg.typeof.getTypeInst[1],

newLit(int(arg))

)

procnewLit*[N,T](arg: array[N,T]): NimNode

procnewLit*[T](arg: seq[T]): NimNode

procnewLit*[T](s: set[T]): NimNode

procnewLit*[T: tuple](arg: T): NimNode

procnewLit*(arg: object): NimNode=

result= nnkObjConstr.newTree(arg.typeof.getTypeInst[1])

for a, b in arg.fieldPairs:

result.add nnkExprColonExpr.newTree( newIdentNode(a), newLit(b) )

procnewLit*(arg: refobject): NimNode=

result= nnkObjConstr.newTree(arg.typeof.getTypeInst[1])

for a, b infieldPairs(arg[]):

result.add nnkExprColonExpr.newTree(newIdentNode(a), newLit(b))

procnewLit*[N,T](arg: array[N,T]): NimNode=

result= nnkBracket.newTree

for x in arg:

result.addnewLit(x)

procnewLit*[T](arg: seq[T]): NimNode=

let bracket = nnkBracket.newTree

for x in arg:

bracket.addnewLit(x)

result= nnkPrefix.newTree(

bindSym"@",

bracket

)

if arg.len ==0:

var typ =getTypeInst(typeof(arg))[1]

result=newCall(typ,result)

procnewLit*[T](s: set[T]): NimNode=

result= nnkCurly.newTree

for x in s:

result.addnewLit(x)

ifresult.len ==0:

var typ =getTypeInst(typeof(s))[1]

result=newCall(typ,result)

procisNamedTuple(T: typedesc): bool {.magic: "TypeTrait".}

procnewLit*[T: tuple](arg: T): NimNode=

result= nnkTupleConstr.newTree

whendefined(nimHasWorkaround14720) orisNamedTuple(T):

for a, b in arg.fieldPairs:

result.add nnkExprColonExpr.newTree(newIdentNode(a), newLit(b))

else:

for b in arg.fields:

result.addnewLit(b)

procnestList*(op: NimNode; pack: NimNode): NimNode=

if pack.len <1:

error("`nestList` expects a node with at least 1 child")

result= pack[^1]

for i incountdown(pack.len -2, 0):

result=newCall(op, pack[i], result)

procnestList*(op: NimNode; pack: NimNode; init: NimNode): NimNode=

result= init

for i incountdown(pack.len -1, 0):

result=newCall(op, pack[i], result)

proceqIdent*(a: string; b: string): bool {.magic: "EqIdent", noSideEffect.}

proceqIdent*(a: NimNode; b: string): bool {.magic: "EqIdent", noSideEffect.}

proceqIdent*(a: string; b: NimNode): bool {.magic: "EqIdent", noSideEffect.}

proceqIdent*(a: NimNode; b: NimNode): bool {.magic: "EqIdent", noSideEffect.}

const collapseSymChoice =notdefined(nimLegacyMacrosCollapseSymChoice)

proctreeTraverse(n: NimNode; res: varstring; level =0; isLisp =false, indented =false) {.benign.} =

if level >0:

if indented:

res.add("\n")

for i in0.. level-1:

if isLisp:

res.add("") # dumpLisp indentation

else:

res.add("") # dumpTree indentation

else:

res.add("")

if isLisp:

res.add("(")

res.add(($n.kind).substr(3))

case n.kind

of nnkEmpty, nnkNilLit:

of nnkCharLit .. nnkInt64Lit:

res.add(""&$n.intVal)

of nnkUIntLit .. nnkUInt64Lit:

res.add(""&$cast[uint64](n.intVal))

of nnkFloatLit .. nnkFloat64Lit:

res.add(""&$n.floatVal)

of nnkStrLit .. nnkTripleStrLit, nnkCommentStmt, nnkIdent, nnkSym:

res.add(""&$n.strVal.newLit.repr)

of nnkNone:

elif n.kind in {nnkOpenSymChoice, nnkClosedSymChoice} and collapseSymChoice:

res.add(""&$n.len)

if n.len >0:

var allSameSymName =true

for i in0..<n.len:

if n[i].kind != nnkSym ornoteqIdent(n[i], n[0]):

allSameSymName =false

if allSameSymName:

res.add(""&$n[0].strVal.newLit.repr)

else:

for j in0..< n.len:

n[j].treeTraverse(res, level+1, isLisp, indented)

else:

for j in0..< n.len:

n[j].treeTraverse(res, level+1, isLisp, indented)

if isLisp:

res.add(")")

proctreeRepr*(n: NimNode): string {.benign.} =

n.treeTraverse(result, isLisp =false, indented =true)

proclispRepr*(n: NimNode; indented =false): string {.benign.} =

n.treeTraverse(result, isLisp =true, indented = indented)

procastGenRepr*(n: NimNode): string {.benign.} =