Index

Modules: assume, assume/spec.

API symbols

add:

• assume: proc add(a: var AnLetSection | var AnVarSection; n: AnIdentDefs)

AnIdentDefs:

• assume: type AnIdentDefs

AnLetSection:

• assume: type AnLetSection

AnVarSection:

• assume: type AnVarSection

applyLineInfo:

• spec: proc applyLineInfo(n, info: NimNode): NimNode

asIdentDefs:

• assume: iterator asIdentDefs(n: AnVarSection or AnLetSection): AnIdentDefs
• assume: iterator asIdentDefs(n: AnIdentDefs): AnIdentDefs
• assume: iterator asIdentDefs(n: NimNode): AnIdentDefs

AssError:

• spec: type AssError

AssNode:

• spec: type AssNode

colon:

• spec: template colon(a: string | NimNode; b: string | int): NimNode
• spec: template colon(a, b: NimNode): NimNode
• spec: template colon(a: string; b: NimNode): NimNode

desym:

• spec: proc desym(n: NimNode): NimNode

dot:

• spec: template dot(a, b: NimNode): NimNode
• spec: template dot(a: NimNode; b: string): NimNode

enumValueAsString:

• spec: macro enumValueAsString(e: enum): string

enumValuesAsArray:

• spec: macro enumValuesAsArray(e: typed): untyped

enumValuesAsSet:

• spec: macro enumValuesAsSet(e: typed): untyped

enumValuesAsSetOfOrds:

• spec: macro enumValuesAsSetOfOrds(e: typed): untyped

eq:

• spec: template eq(a, b: NimNode): NimNode
• spec: template eq(a: string; b: NimNode): NimNode

errorAst:

• spec: proc errorAst(n: NimNode; s = "creepy ast"): NimNode
• spec: proc errorAst(s: string; info: NimNode = nil): NimNode

filter:

• spec: proc filter(f: NodeFilter; n: NimNode): NimNode

fromAnIdentDefstoNimNode:

• assume: converter fromAnIdentDefstoNimNode(n`gensym36: AnIdentDefs): NimNode

fromAnLetSectiontoNimNode:

• assume: converter fromAnLetSectiontoNimNode(n`gensym42: AnLetSection): NimNode

fromAnVarSectiontoNimNode:

• assume: converter fromAnVarSectiontoNimNode(n`gensym48: AnVarSection): NimNode

getTypeImplSkip:

• spec: proc getTypeImplSkip(n: NimNode; skip = Skippable): NimNode

getTypeInstSkip:

• spec: proc getTypeInstSkip(n: NimNode; skip = SkippableInst): NimNode

getTypeSkip:

• spec: proc getTypeSkip(n: NimNode; skip = Skippable): NimNode

inject:

• spec: proc inject(n: NimNode): NimNode

isGenericOf:

• spec: proc isGenericOf(n: NimNode; s: string): bool

isNil:

• assume: proc isNil(a: AssNode): bool

isType:

• spec: proc isType(n: NimNode): bool
• spec: proc isType(n: NimNode; s: string): bool

kind:

• assume: proc kind(a: AssNode): NimNodeKind

len:

• assume: proc len(a`gensym22: AnIdentDefs): int
• assume: proc len(a`gensym24: AnLetSection): int
• assume: proc len(a`gensym23: AnVarSection): int
• assume: proc len(a: AssNode): int

newTreeFrom:

• spec: macro newTreeFrom(kind: NimNodeKind; n: NimNode; body: untyped): NimNode

newTypedesc:

• spec: proc newTypedesc(n: NimNode): NimNode

NodeFilter:

• spec: type NodeFilter

NodeLike:

• spec: type NodeLike

repr:

• assume: proc repr(a: AssNode): string

sameType:

• spec: proc sameType(a, b: NimNode): bool

Skippable:

• spec: const Skippable

SkippableInst:

• spec: const SkippableInst

sq:

• spec: template sq(a: NimNode): NimNode
• spec: template sq(a, b: NimNode): NimNode
• spec: template sq(a: NimNode; b: SomeInteger)

toAnIdentDefs:

• assume: converter toAnIdentDefs(n: NimNode): AnIdentDefs

toAnLetSection:

• assume: converter toAnLetSection(n: NimNode): AnLetSection

toAnVarSection:

• assume: converter toAnVarSection(n: NimNode): AnVarSection

treeRepr:

• assume: proc treeRepr(a: AssNode): string

tupleTypeArity:

• spec: proc tupleTypeArity(n: NimNode): int