ast

Search:
Group by:
Source   Edit  

Types

IdGenerator = ref object
  module*: int32
  symId*: int32
  typeId*: int32
  sealed*: bool
  disambTable*: CountTable[PIdent]
Source   Edit  

Vars

ggDebug {....deprecated.}: bool
convenience switch for trying out things Source   Edit  

Consts

AttachedOpToStr: array[TTypeAttachedOp, string] = ["=wasMoved", "=destroy",
    "=copy", "=dup", "=sink", "=trace", "=deepcopy"]
Source   Edit   
FirstParamAt = 1
Source   Edit   
GrowthFactor = 2
Source   Edit   
nodesToIgnoreSet = {nkNone..nkIdent, nkType..nkNilLit, nkTypeSection, nkProcDef,
                    nkConverterDef, nkMethodDef, nkIteratorDef, nkMacroDef,
                    nkTemplateDef, nkLambda, nkDo, nkFuncDef, nkConstSection,
                    nkConstDef, nkIncludeStmt, nkImportStmt, nkExportStmt,
                    nkPragma, nkCommentStmt, nkBreakState, nkTypeOfExpr,
                    nkMixinStmt, nkBindStmt}
Source   Edit   
PackageModuleId = -3'i32
Source   Edit   
StartSize = 8
Source   Edit  

Procs

proc `$`(s: PSym): string {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc add(father, son: PNode) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc add(father, son: PType) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc addAllowNil(father, son: PNode) {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc addAllowNil(father, son: PType) {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc addParam(procType: PType; param: PSym) {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc addSonNilAllowed(father, son: PNode) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc align(t: PType): int16 {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc align=(t: PType; val: int16) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc alignment(s: PSym): int {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc alignment=(s: PSym; val: int) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc annex(s: PSym): PLib {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc annex=(s: PSym; val: PLib) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc appendToModule(m: PSym; n: PNode) {....raises: [], tags: [], forbids: [].}
The compiler will use this internally to add nodes that will be appended to the module after the sem pass Source   Edit   
proc assignType(dest, src: PType) {....raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc ast(s: PSym): PNode {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc ast=(s: PSym; val: PNode) {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc astdef(s: PSym): PNode {....raises: [ValueError, IOError, KeyError, OSError,
                                       Exception], tags: [WriteIOEffect,
    ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc backendEnsureMutable(s: PSym) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc backendEnsureMutable(t: PType) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc base(t: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc baseClass(n: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc bitsize(s: PSym): int {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc bitsize=(s: PSym; val: int) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc callConv(t: PType): TCallingConvention {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc callConv=(t: PType; val: TCallingConvention) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc canRaise(fn: PNode): bool {....raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc canRaiseConservative(fn: PNode): bool {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc comment(n: PNode): string {....raises: [KeyError], tags: [], forbids: [].}
Source   Edit   
proc comment=(n: PNode; a: string) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc constraint(s: PSym): PNode {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc constraint=(s: PSym; val: PNode) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc containsNode(n: PNode; kinds: TNodeKinds): bool {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc copyIdTable[T](dest: var TIdTable[T]; src: TIdTable[T])
Source   Edit   
proc copyNode(src: PNode): PNode {....raises: [KeyError], tags: [], forbids: [].}
Source   Edit   
proc copyObjectSet(dest: var TObjectSet; src: TObjectSet) {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc copyStrTable(dest: var TStrTable; src: TStrTable) {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc copySym(s: PSym; idgen: IdGenerator): PSym {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc copyTree(src: PNode): PNode {....raises: [KeyError], tags: [], forbids: [].}
Source   Edit   
proc copyTreeWithoutNode(src, skippedNode: PNode): PNode {....raises: [KeyError],
    tags: [], forbids: [].}
Source   Edit   
proc copyType(t: PType; idgen: IdGenerator; owner: PSym): PType {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc createModuleAlias(s: PSym; idgen: IdGenerator; newIdent: PIdent;
                       info: TLineInfo; options: TOptions): PSym {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc delSon(father: PNode; idx: int) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc discardSons(father: PNode) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc elementType(n: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc ensureMutable(s: PSym) {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc ensureMutable(t: PType) {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc exactReplica(t: PType): PType {....raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc excl(s: PSym; flag: TSymFlag) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc excl(t: PType; flag: TTypeFlag) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc excl(t: PType; flags: set[TTypeFlag]) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc extractPragma(s: PSym): PNode {....raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
gets the pragma node of routine/type/var/let/const symbol s Source   Edit   
proc findUnresolvedStatic(n: PNode): PNode {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc firstGenericParam(n: PType): PType {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc firstParamType(n: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc flags(s: PSym): TSymFlags {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc flags(t: PType): TTypeFlags {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc flags=(s: PSym; val: TSymFlags) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc flags=(t: PType; val: TTypeFlags) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc gcUnsafetyReason(s: PSym): PSym {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc gcUnsafetyReason=(s: PSym; val: PSym) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc genericConstraint(t: PType): PType {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc genericHead(n: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc genericInvocationParamsLen(t: PType): int {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc genericParamHasConstraints(t: PType): bool {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc genericParamsLen(t: PType): int {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc getDeclPragma(n: PNode): PNode {....raises: [], tags: [], forbids: [].}
return the nkPragma node for declaration n, or nil if no pragma was found. Currently only supports routineDefs + {nkTypeDef}. Source   Edit   
proc getFloat(a: PNode): BiggestFloat {....raises: [ERecoverableError], tags: [],
                                        forbids: [].}
Source   Edit   
proc getInt(a: PNode): Int128 {....raises: [ERecoverableError], tags: [],
                                forbids: [].}
Source   Edit   
proc getInt64(a: PNode): int64 {....deprecated: "use getInt",
                                 raises: [ERecoverableError], tags: [],
                                 forbids: [].}
Deprecated: use getInt
Source   Edit   
proc getPIdent(a: PNode): PIdent {.inline, ...raises: [], tags: [], forbids: [].}
Returns underlying PIdent for {nkSym, nkIdent}, or nil. Source   Edit   
proc getStr(a: PNode): string {....raises: [ERecoverableError], tags: [],
                                forbids: [].}
Source   Edit   
proc getStrOrChar(a: PNode): string {....raises: [ERecoverableError], tags: [],
                                      forbids: [].}
Source   Edit   
proc guard(s: PSym): PSym {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc guard=(s: PSym; val: PSym) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc hasElementType(t: PType): bool {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc hasNilSon(n: PNode): bool {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc hasPattern(s: PSym): bool {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc hasSonWith(n: PNode; kind: TNodeKind): bool {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc hasSubnodeWith(n: PNode; kind: TNodeKind): bool {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc idGeneratorForPackage(nextIdWillBe: int32): IdGenerator {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc idGeneratorFromModule(m: PSym): IdGenerator {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc incl(s: PSym; flag: TLocFlag) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc incl(s: PSym; flag: TSymFlag) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc incl(s: PSym; flags: set[TSymFlag]) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc incl(t: PType; flag: TTypeFlag) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc incl(t: PType; flags: set[TTypeFlag]) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc indexType(n: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc info(s: PSym): TLineInfo {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc info=(s: PSym; val: TLineInfo) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc initIdTable[T](): TIdTable[T]
Source   Edit   
proc initNodeTable(ignoreTypes = false): TNodeTable {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc initObjectSet(): TObjectSet {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc initStrTable(): TStrTable {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc instantiatedFrom(s: PSym): PSym {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc instantiatedFrom=(s: PSym; val: PSym) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isAtom(n: PNode): bool {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc isCallExpr(n: PNode): bool {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc isClosure(typ: PType): bool {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isClosureIterator(typ: PType): bool {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isCompileTimeProc(s: PSym): bool {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isEmptyTupleType(t: PType): bool {.inline, ...raises: [], tags: [],
                                        forbids: [].}
Source   Edit   
proc isEmptyType(t: PType): bool {.inline, ...raises: [], tags: [], forbids: [].}
'void' and 'typed' types are often equivalent to 'nil' these days: Source   Edit   
proc isExplicitCallConv(s: PSym): bool {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isGCedMem(t: PType): bool {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc isGenericParams(n: PNode): bool {.inline, ...raises: [], tags: [], forbids: [].}
used to judge whether a node is generic params. Source   Edit   
proc isGenericRoutine(n: PNode): bool {.inline, ...raises: [], tags: [],
                                        forbids: [].}
Source   Edit   
proc isGenericRoutine(s: PSym): bool {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}

determines if this symbol represents a generic routine or an instance of one. This should be renamed accordingly and isGenericRoutineStrict should take this name instead.

Warning/XXX: Unfortunately, it considers a proc kind symbol flagged with sfFromGeneric as a generic routine. Instead this should likely not be the case and the concepts should be teased apart:

  • generic definition
  • generic instance
  • either generic definition or instance
Source   Edit   
proc isGenericRoutineStrict(s: PSym): bool {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
determines if this symbol represents a generic routine the unusual name is so it doesn't collide and eventually replaces isGenericRoutine Source   Edit   
proc isImportedException(t: PType; conf: ConfigRef): bool {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isInfixAs(n: PNode): bool {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc isInlineIterator(typ: PType): bool {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isIterator(typ: PType): bool {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isMetaType(t: PType): bool {....raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc isNewStyleConcept(n: PNode): bool {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc isNimcall(s: PSym): bool {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc isOutParam(t: PType): bool {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isRoutine(s: PSym): bool {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc isSingletonTupleType(t: PType): bool {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc isSinkParam(s: PSym): bool {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isSinkType(t: PType): bool {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isTrue(n: PNode): bool {....raises: [ValueError, IOError, KeyError, OSError,
                                       Exception], tags: [WriteIOEffect,
    ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc isUnresolvedStatic(t: PType): bool {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc kidsLen(t: PType): int {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc kind(s: PSym): TSymKind {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc kind=(s: PSym; val: TSymKind) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc last(n: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc lastSon(n: PNode): PNode {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc len(n: PType): int {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc linkTo(s: PSym; t: PType): PSym {.discardable, ...raises: [ValueError,
    IOError, KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc linkTo(t: PType; s: PSym): PType {.discardable, ...raises: [ValueError,
    IOError, KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc loc(s: PSym): TLoc {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc loc(t: PType): TLoc {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc loc=(s: PSym; val: TLoc) {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc loc=(t: PType; val: TLoc) {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc magic(s: PSym): TMagic {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc magic=(s: PSym; val: TMagic) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc makeStmtList(n: PNode): PNode {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc n(t: PType): PNode {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc n=(t: PType; val: PNode) {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc newAtom(ident: PIdent; info: TLineInfo): PNode {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc newAtom(kind: TNodeKind; floatVal: BiggestFloat; info: TLineInfo): PNode {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc newAtom(kind: TNodeKind; intVal: BiggestInt; info: TLineInfo): PNode {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc newAtom(kind: TNodeKind; strVal: sink string; info: TLineInfo): PNode {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc newFloatNode(kind: TNodeKind; floatVal: BiggestFloat): PNode {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc newIntNode(kind: TNodeKind; intVal: BiggestInt): PNode {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc newIntNode(kind: TNodeKind; intVal: Int128): PNode {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc newIntTypeNode(intVal: BiggestInt; typ: PType): PNode {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc newIntTypeNode(intVal: Int128; typ: PType): PNode {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc newOpenSym(n: PNode): PNode {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc newProcNode(kind: TNodeKind; info: TLineInfo; body: PNode; params, name,
    pattern, genericParams, pragmas, exceptions: PNode): PNode {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc newProcType(info: TLineInfo; idgen: IdGenerator; owner: PSym): PType {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc newSons(father: PNode; length: int) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc newSons(father: PType; length: int) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc newStrNode(kind: TNodeKind; strVal: string): PNode {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc newStrNode(strVal: string; info: TLineInfo): PNode {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc newSym(symKind: TSymKind; name: PIdent; idgen: IdGenerator; owner: PSym;
            info: TLineInfo; options: TOptions = {}): PSym {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc newSymNode(sym: PSym): PNode {....raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc newTree(kind: TNodeKind; children: varargs[PNode]): PNode {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc newTree(kind: TNodeKind; info: TLineInfo; children: varargs[PNode]): PNode {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc newTreeI(kind: TNodeKind; info: TLineInfo; children: varargs[PNode]): PNode {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc newTreeIT(kind: TNodeKind; info: TLineInfo; typ: PType;
               children: varargs[PNode]): PNode {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc newType(kind: TTypeKind; idgen: IdGenerator; owner: PSym;
             son: sink PType = nil): PType {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc nextTypeId(x: IdGenerator): ItemId {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc offset(s: PSym): int32 {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc offset=(s: PSym; val: int32) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc options(s: PSym): TOptions {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc options=(s: PSym; val: TOptions) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc originatingModule(s: PSym): PSym {....raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc owner(s: PSym): PSym {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc owner(s: PType): PSym {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc paddingAtEnd(t: PType): int16 {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc paddingAtEnd=(t: PType; val: int16) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc paramsLen(t: PType): int {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc position(s: PSym): int {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc position=(s: PSym; val: int) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc propagateToOwner(owner, elem: PType; propagateHasAsgn = true) {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc rawAddSon(father, son: PType; propagateHasAsgn = true) {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc replaceFirstSon(n, newson: PNode) {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc replaceSon(n: PNode; i: int; newson: PNode) {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc resetIdTable[T](x: var TIdTable[T])
Source   Edit   
proc returnType(n: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc safeArrLen(n: PNode): int {.inline, ...raises: [], tags: [], forbids: [].}
works for array-like objects (strings passed as openArray in VM). Source   Edit   
proc sameTupleLengths(a, b: PType): bool {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc setIndexType(n, idx: PType) {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc setInfoRecursive(n: PNode; info: TLineInfo) {....raises: [], tags: [],
    forbids: [].}
set line info recursively Source   Edit   
proc setOwner(s: PSym; owner: PSym) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc setOwner(s: PType; owner: PSym) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc setReturnType(n, r: PType) {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc setSnippet(s: PSym; val: sink string) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc setSon(dest: PType; son: sink PType) {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc setSons(dest: PType; sons: sink seq[PType]) {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc setSonsLen(dest: PType; len: int) {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc setupProgram(config: ConfigRef; cache: IdentCache) {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc setUseIc(useIc: bool) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc shallowCopy(src: PNode): PNode {....raises: [KeyError], tags: [], forbids: [].}
Source   Edit   
proc signatureLen(t: PType): int {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc size(t: PType): BiggestInt {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc size=(t: PType; val: BiggestInt) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc skipColon(n: PNode): PNode {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc skipGenericOwner(s: PSym): PSym {....raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Generic instantiations are owned by their originating generic symbol. This proc skips such owners and goes straight to the owner of the generic itself (the module or the enclosing proc). Source   Edit   
proc skipHiddenAddr(n: PNode): PNode {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc skipModifier(n: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc skipPragmaExpr(n: PNode): PNode {....raises: [], tags: [], forbids: [].}
if pragma expr, give the node the pragmas are applied to, otherwise give node itself Source   Edit   
proc skipStmtList(n: PNode): PNode {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc skipTypes(t: PType; kinds: TTypeKinds): PType {....raises: [], tags: [],
    forbids: [].}
Used throughout the compiler code to test whether a type tree contains or doesn't contain a specific type/types - it is often the case that only the last child nodes of a type tree need to be searched. This is a really hot path within the compiler! Source   Edit   
proc skipTypes(t: PType; kinds: TTypeKinds; maxIters: int): PType {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
proc skipTypesOrNil(t: PType; kinds: TTypeKinds): PType {....raises: [], tags: [],
    forbids: [].}
same as skipTypes but handles 'nil' Source   Edit   
proc sons(t: PType): var TTypeSeq {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc sons=(t: PType; val: sink TTypeSeq) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc sym(t: PType): PSym {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc sym=(t: PType; val: PSym) {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc toHumanStr(kind: TSymKind): string {....raises: [], tags: [], forbids: [].}
strips leading sk Source   Edit   
proc toHumanStr(kind: TTypeKind): string {....raises: [], tags: [], forbids: [].}
strips leading tk Source   Edit   
proc toObject(typ: PType): PType {....raises: [], tags: [], forbids: [].}
If typ is a tyRef then its immediate son is returned (which in many cases should be a tyObject). Otherwise typ is simply returned as-is. Source   Edit   
proc toObjectFromRefPtrGeneric(typ: PType): PType {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc toRef(typ: PType; idgen: IdGenerator): PType {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
If typ is a tyObject then it is converted into a ref <typ> and returned. Otherwise typ is simply returned as-is. Source   Edit   
proc toVar(typ: PType; kind: TTypeKind; idgen: IdGenerator): PType {.
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
If typ is not a tyVar then it is converted into a var <typ> and returned. Otherwise typ is simply returned as-is. Source   Edit   
proc transformedBody(s: PSym): PNode {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc transformedBody=(s: PSym; val: PNode) {.inline,
    ...raises: [ValueError, IOError, KeyError, OSError, Exception],
    tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc transitionGenericParamToType(s: PSym) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc transitionIntKind(n: PNode; kind: range[nkCharLit .. nkUInt64Lit]) {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc transitionIntToFloatKind(n: PNode; kind: range[nkFloatLit .. nkFloat128Lit]) {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc transitionNoneToSym(n: PNode) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc transitionRoutineSymKind(s: PSym; kind: range[skProc .. skTemplate]) {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc transitionSonsKind(n: PNode; kind: range[nkComesFrom .. nkTupleConstr]) {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc transitionToLet(s: PSym) {....raises: [], tags: [], forbids: [].}
Source   Edit   
proc truncateInferredTypeCandidates(t: PType) {.inline, ...raises: [], tags: [],
    forbids: [].}
Source   Edit   
proc typ(s: PSym): PType {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc typ=(s: PSym; val: PType) {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc typeBodyImpl(n: PType): PType {.inline, ...raises: [], tags: [], forbids: [].}
Source   Edit   
proc typeInst(t: PType): PType {.inline, ...raises: [ValueError, IOError, KeyError,
    OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect, ReadIOEffect,
                                RootEffect], forbids: [].}
Source   Edit   
proc typeInst=(t: PType; val: PType) {.inline, ...raises: [ValueError, IOError,
    KeyError, OSError, Exception], tags: [WriteIOEffect, ReadEnvEffect,
    ReadIOEffect, RootEffect], forbids: [].}
Source   Edit   
proc withInfo(n: PNode; info: TLineInfo): PNode {....raises: [], tags: [],
    forbids: [].}
Source   Edit  

Iterators

iterator genericBodyParams(t: PType): (int, PType) {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
iterator genericInstParamPairs(a, b: PType): (int, PType, PType) {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
iterator genericInstParams(t: PType): (bool, PType) {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
iterator genericInvocationAndBodyElements(a, b: PType): (PType, PType) {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
iterator genericInvocationParamPairs(a, b: PType): (bool, PType, PType) {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
iterator genericInvocationParams(t: PType): (bool, PType) {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
iterator ikids(t: PType): (int, PType) {....raises: [], tags: [], forbids: [].}
Source   Edit   
iterator kids(t: PType): PType {....raises: [], tags: [], forbids: [].}
Source   Edit   
iterator pairs(n: PNode): tuple[i: int, n: PNode] {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
iterator paramTypePairs(a, b: PType): (PType, PType) {....raises: [], tags: [],
    forbids: [].}
Source   Edit   
iterator paramTypes(t: PType): (int, PType) {....raises: [], tags: [], forbids: [].}
Source   Edit   
iterator signature(t: PType): PType {....raises: [], tags: [], forbids: [].}
Source   Edit   
iterator tupleTypePairs(a, b: PType): (int, PType, PType) {....raises: [],
    tags: [], forbids: [].}
Source   Edit   
iterator underspecifiedPairs(a, b: PType; start = 0; without = 0): (PType, PType) {.
    ...raises: [], tags: [], forbids: [].}
Source   Edit   
iterator userTypeClassInstParams(t: PType): (bool, PType) {....raises: [],
    tags: [], forbids: [].}
Source   Edit  

Templates

template `[]`(n: PType; i: BackwardsIndex): PType
Source   Edit   
template `[]`(n: PType; i: int): PType
Source   Edit   
template `[]=`(n: PType; i: BackwardsIndex; x: PType)
Source   Edit   
template `[]=`(n: PType; i: int; x: PType)
Source   Edit   
template detailedInfo(sym: PSym): string
Source   Edit   
template fileIdx(c: PSym): FileIndex
Source   Edit   
template filename(c: PSym): string
Source   Edit   
template firstSon(n: PNode): PNode
Source   Edit   
template has2Sons(n: PNode): bool
Source   Edit   
template hasDestructor(t: PType): bool
Source   Edit   
template hasSon(n: PNode): bool
Source   Edit   
template id(a: PType | PSym): int
Source   Edit   
template incompleteType(t: PType): bool
Source   Edit   
template initSymMapping(): SymMapping
Source   Edit   
template initTypeMapping(): TypeMapping
Source   Edit   
template paramTypeToNodeIndex(x: int): int
Source   Edit   
template previouslyInferred(t: PType): PType
Source   Edit   
template secondSon(n: PNode): PNode
Source   Edit   
template setLastSon(n: PNode; s: PNode)
Source   Edit   
template toId(a: ItemId): int
Source   Edit   
template typ(n: PNode): PType
Source   Edit   
template typeCompleted(s: PSym)
Source   Edit  

Exports

bitxor, maskUInt16, <, <=, high, castToUInt64, shr, toHex, ==, +, addInt128, abs, One, <=, maskUInt64, $, toUInt8, inc, <, +=, maskBytes, Ten, -, -, *=, Zero, toInt32, ==, -=, toInt64Checked, +, toInt8, toUInt16, mod, toInt128, shl, maskUInt32, toUInt32, fastLog2, toUInt, Int128, <, bitor, <=, toFloat64, -, ==, parseDecimalInt128, bitnot, toInt64, NegOne, div, +, *, toUInt64, low, addToHex, -, maskUInt8, divMod, bitand, toInt128, cmp, *, toInt16, toInt, castToInt64, nkCallKinds, TNodeKind, maskUInt16, <=, ==, ccMember, TIdPair, TPair, maskBytes, +=, TObjectSet, maskUInt32, -, ExportableSymKinds, TNodeSeq, <=, defaultSize, ==, TIdPairSeq, nkFloatLiterals, TLocKind, TTypeSeq, tyMetaTypes, namePos, effectListLen, TNodeTable, tfObjHasKids, bitand, [], shr, ccFastCall, ctfeWhitelist, ConcreteTypes, StructuralEquivTypes, nkSymChoices, toInt64, toInt128, resultPos, ccStdCall, requiresEffects, <=, TSymFlags, toUInt8, -, ensuresEffects, ==, abstractVarRange, toUInt16, forcePartial, TInstantiation, toFloat64, len, exceptionEffects, genericParamsPos, miscPos, TLibKind, sfCppMember, skProcKinds, nkStrKinds, addInt128, TObjectSeq, ccSysCall, sfNoForward, TNodePair, newNodeI, TSymKind, newIdentNode, +, TLocFlags, +, TLib, TNodeFlags, $, -=, ccNimCall, toUInt32, <, TNodeKind, ccInline, patternPos, routineKinds, tyTypeClasses, GenericTypes, sfCompileToObjc, TSymKinds, TNodeKinds, TType, PLib, high, sfExperimental, abstractInst, toInt64Checked, +, ccCDecl, tagEffects, ccNoConvention, TTypeFlags, CompilesId, newNodeIT, toInt32, TSymFlag, cmp, GcTypeKinds, TScope, toHex, hash, bodyPos, Zero, NilableTypes, TNodePairSeq, forbiddenEffects, nkWhen, NegOne, safeLen, nkPragmaCallKinds, ccClosure, bitxor, TImplication, generatedMagics, declarativeDefs, IntegralTypes, sfCompileToCpp, skError, TSym, TTypeKind, toInt8, tyUserTypeClasses, ==, nkLastBlockStmts, abs, tfGcSafe, toInt16, [], TNode, TPairSeq, maskUInt64, $, sfNoInit, nfAllFieldsSet, forcePartial, *=, TCallingConvention, newNodeI, dispatcherPos, ccSafeCall, tfNonConstExpr, low, maskUInt8, TNodeFlag, toInt, procDefs, fastLog2, OverloadableSyms, tyPureObject, routineDefs, PSym, ItemState, addToHex, ConstantDataTypes, <, castToUInt64, nkEffectList, ccThisCall, <, -, inc, newNode, pragmasPos, skLocalVars, TStrTable, sfReorder, bitnot, div, *, TLoc, nkIdentKinds, eqTypeFlags, TMagic, TTypeKinds, newSymNode, toUInt, nkLiterals, -, Int128, ccNoInline, TIdTable, parseDecimalInt128, tfReturnsNew, TStorageLoc, newNode, castToInt64, defaultAlignment, bitor, PInstantiation, paramsPos, toInt128, pragmasEffects, nkWhenExpr, nkCallKinds, defaultOffset, []=, mod, ItemId, TTypeAttachedOp, tfGenericHasDestructor, TTypeFlag, One, divMod, Ten, nkLambdaKinds, PNode, PScope, TLocFlag, shl, sfWrittenTo, callableDefs, items, PersistentNodeFlags, PType, PtrLikeKinds, []=, toUInt64, *, tfUnion

Made with Nim. Generated: 2025-11-27 09:19:19 UTC