Index

Modules: ast/ast, ast/ast_idgen, ast/ast_parsed_types, ast/ast_query, ast/ast_types, ast/astalgo, ast/astmsgs, ast/checked_ast, ast/enumtostr, ast/errorhandling, ast/errorreporting, ast/filter_tmpl, ast/filters, ast/idents, ast/lexer, ast/lineinfos, ast/linter, ast/llstream, ast/ndi, ast/nimlexbase, ast/nimsets, ast/numericbase, ast/parser, ast/renderer, ast/renderverbatim, ast/report_enums, ast/reports, ast/reports_backend, ast/reports_base, ast/reports_base_sem, ast/reports_cmd, ast/reports_debug, ast/reports_external, ast/reports_internal, ast/reports_lexer, ast/reports_parser, ast/reports_sem, ast/reports_vm, ast/syntaxes, ast/trees, ast/treetab, ast/types, ast/typesrenderer, ast/wordrecg, backend/backends, backend/cbackend, backend/ccgflow, backend/ccgutils, backend/cgen, backend/cgendata, backend/cgir, backend/cgirgen, backend/cgirutils, backend/cgmeth, backend/compat, backend/extccomp, backend/jsbackend, backend/jsflow, backend/jsgen, backend/mangling, front/cli_reporter, front/cmdlinehelper, front/commands, front/condsyms, front/depfiles, front/in_options, front/main, front/msgs, front/nimconf, front/options, front/optionsprocessor, front/scripting, front/sexp_reporter, ic/bitabs, ic/cbackend, ic/dce, ic/ic, ic/integrity, ic/packed_ast, ic/replayer, ic/rodfiles, index, mir/analysis, mir/datatables, mir/injecthooks, mir/mirbodies, mir/mirbridge, mir/mirchangesets, mir/mirconstr, mir/mirenv, mir/mirgen, mir/mirgen_blocks, mir/mirpasses, mir/mirtrees, mir/mirtypes, mir/proto_mir, mir/rtchecks, mir/sourcemaps, mir/treechangesets, mir/typemaps, mir/utils, modules/depends, modules/importer, modules/magicsys, modules/modulegraphs, modules/modulepaths, modules/modules, modules/nimblecmd, modules/nimpaths, plugins/active, plugins/itersgen, plugins/locals, sem/aliasanalysis, sem/aliases, sem/ast_analysis, sem/closureiters, sem/evaltempl, sem/guards, sem/injectdestructors, sem/isolation_check, sem/lambdalifting, sem/liftdestructors, sem/lookups, sem/lowerings, sem/macrocacheimpl, sem/mirexec, sem/modulelowering, sem/nilcheck, sem/nilcheck_enums, sem/parampatterns, sem/passaux, sem/passes, sem/patterns, sem/pragmas, sem/procfind, sem/rodutils, sem/sem, sem/semcomptime, sem/semdata, sem/semfold, sem/sempass2, sem/semtypinst, sem/sighashes, sem/sigmatch, sem/sourcemap, sem/transf, sem/typeallowed, sem/unreachable_elim, sem/varpartitions, tools/docgen, tools/docgen2, tools/suggest, utils/astrepr, utils/bitsets, utils/btrees, utils/containers, utils/cursors, utils/debugutils, utils/idioms, utils/int128, utils/nodejs, utils/nversion, utils/pathutils, utils/platform, utils/pluginsupport, utils/prefixmatches, utils/ropes, utils/saturate, vm/compilerbridge, vm/gorgeimpl, vm/identpatterns, vm/packed_env, vm/vm, vm/vm_enums, vm/vmaux, vm/vmbackend, vm/vmchecks, vm/vmcompilerserdes, vm/vmconv, vm/vmdef, vm/vmdeps, vm/vmerrors, vm/vmgen, vm/vmhooks, vm/vmjit, vm/vmjit_checks, vm/vmlegacy, vm/vmmemory, vm/vmobjects, vm/vmops, vm/vmprofiler, vm/vmserialize, vm/vmtypegen, vm/vmtypes, vm/vmutils.

API symbols

`$`:

• ast_query: `$`(s: PSym): string
• ast_query: `$`(x: TLockLevel): string
• ast_types: `$`(a: NodeId): string
• lexer: `$`(tok: Token): string
• renderer: `$`(n: PNode): string
• reports: `$`(point: ReportLineInfo): string
• typesrenderer: `$`(typ: PType): string
• msgs: `$`(conf: ConfigRef; info: TLineInfo): string
• msgs: `$`(info: TLineInfo): string
• options: `$`(c: IdeCmd): string
• bitabs: `$`(x: LitId): string
• modulegraphs: `$`(u: SigHash): string
• nimblecmd: `$`(ver: Version): string
• mirexec: `$`(c: DataFlowGraph): string
• nilcheck: `$`(a: ExprIndex): string
• nilcheck: `$`(a: SetIndex): string
• sourcemap: `$`(sourceNode: SourceNode): string
• varpartitions: `$`(config: ConfigRef; g: MutationInfo): string
• btrees: `$`[Key, Val](b: BTree[Key, Val]): string
• int128: `$`(a: Int128): string
• nversion: `$`(v: Version): string
• pathutils: `$`(x: AnyPath): string
• vmdef: `$`(x: ptr UncheckedArray[byte]): string
• vmdef: `$`(x: PVmType): string
• vmobjects: `$`(s: VmString): string

`%`:

• ropes: `%`(frmt: static[FormatStr]; args: openArray[Rope]): Rope

`&`:

• ropes: `&`(a: openArray[Rope]): Rope

`>=`:

• nilcheck: `>=`(a: ExprIndex; b: ExprIndex): bool
• vmobjects: `>=`(a, b: VmString): bool

`>`:

• nilcheck: `>`(a: ExprIndex; b: ExprIndex): bool
• vmobjects: `>`(a, b: VmString): bool

`<=`:

• bitabs: `<=`(x, y: LitId): bool
• mirtrees: `<=`(a, b: NodePosition): bool
• nilcheck: `<=`(a: ExprIndex; b: ExprIndex): bool
• int128: `<=`(a: BiggestInt; b: Int128): bool
• int128: `<=`(a: Int128; b: BiggestInt): bool
• int128: `<=`(a, b: Int128): bool
• vmdef: `<=`(a, b: FieldIndex): bool
• vmobjects: `<=`(a, b: VmString): bool

`<`:

• bitabs: `<`(x, y: LitId): bool
• mirtrees: `<`(a, b: NodePosition): bool
• nimblecmd: `<`(ver: Version; ver2: Version): bool
• nilcheck: `<`(a: ExprIndex; b: ExprIndex): bool
• int128: `<`(a: BiggestInt; b: Int128): bool
• int128: `<`(a: Int128; b: BiggestInt): bool
• int128: `<`(a, b: Int128): bool
• vmdef: `<`(a, b: FieldIndex): bool
• vmobjects: `<`(a, b: VmString): bool

`*=`:

• int128: `*=`(a: var Int128; b: Int128)
• int128: `*=`(a: var Int128; b: int32): Int128

`*`:

• int128: `*`(lhs, rhs: Int128): Int128
• int128: `*`(a: Int128; b: int32): Int128

`+=`:

• int128: `+=`(a: var Int128; b: Int128)

`+`:

• mirtrees: `+`(a: NodePosition; b: int): NodePosition
• nilcheck: `+`(a: ExprIndex; b: ExprIndex): ExprIndex
• nilcheck: `+`(a: SetIndex; b: SetIndex): SetIndex
• astrepr: `+`(conf: TReprConf; flag: TReprFlag | set[TReprFlag]): TReprConf
• int128: `+`(a: BiggestInt; b: Int128): Int128
• int128: `+`(a: Int128; b: BiggestInt): Int128
• int128: `+`(a, b: Int128): Int128

`-=`:

• int128: `-=`(a: var Int128; b: Int128)

`-`:

• mirtrees: `-`(a: NodePosition; b: int): NodePosition
• nilcheck: `-`(a: ExprIndex; b: ExprIndex): ExprIndex
• nilcheck: `-`(a: SetIndex; b: SetIndex): SetIndex
• astrepr: `-`(conf: TReprConf; flag: TReprFlag | set[TReprFlag]): TReprConf
• int128: `-`(a: BiggestInt; b: Int128): Int128
• int128: `-`(a: Int128): Int128
• int128: `-`(a: Int128; b: BiggestInt): Int128
• int128: `-`(a, b: Int128): Int128
• vmdef: `-`(a: FieldIndex; b: int): FieldIndex

`/`:

• pathutils: `/`(base: AbsoluteDir; f: RelativeDir): AbsoluteDir
• pathutils: `/`(base: AbsoluteDir; f: RelativeFile): AbsoluteFile

`==`:

• ast_types: `==`(a, b: ItemId): bool
• ast_types: `==`(a, b: NodeId): bool
• idents: `==`(a, b: PIdent): bool
• lineinfos: `==`(a, b: FileIndex): bool
• ccgflow: `==`(a, b: CLabelId): bool
• cgir: `==`(x, y: BlockId): bool
• bitabs: `==`(x, y: LitId): bool
• packed_ast: `==`(a, b: NodePos): bool
• packed_ast: `==`(a, b: SymId): bool
• mirtrees: `==`(a, b: AstId): bool
• mirtrees: `==`(a, b: ConstId): bool
• mirtrees: `==`(a, b: DataId): bool
• mirtrees: `==`(a, b: GlobalId): bool
• mirtrees: `==`(a, b: LabelId): bool
• mirtrees: `==`(a, b: LocalId): bool
• mirtrees: `==`(a, b: NodePosition): bool
• mirtrees: `==`(a, b: NumberId): bool
• mirtrees: `==`(a, b: ProcedureId): bool
• mirtrees: `==`(a, b: SourceId): bool
• mirtrees: `==`(a, b: StringId): bool
• mirtrees: `==`(a, b: TypeId): bool
• mirtypes: `==`(a, b: FieldId): bool
• typemaps: `==`(a, b: Type): bool
• modulegraphs: `==`(a, b: SigHash): bool
• nilcheck: `==`(a: ExprIndex; b: ExprIndex): bool
• nilcheck: `==`(a: SetIndex; b: SetIndex): bool
• containers: `==`(a, b: Checkpoint): bool
• int128: `==`(a: BiggestInt; b: Int128): bool
• int128: `==`(a: Int128; b: BiggestInt): bool
• int128: `==`(a, b: Int128): bool
• pathutils: `==`[T: AnyPath](x, y: T): bool
• vmdef: `==`(a, b: FieldIndex): bool
• vmdef: `==`(a, b: FunctionIndex): bool
• vmdef: `==`(a, b: RoutineSigId): bool
• vmobjects: `==`(a: VmString; b: openArray[char]): bool
• vmobjects: `==`(a, b: VmString): bool
• vmobjects: `==`(a, b: VmFunctionPtr): bool

`=copy`:

• vm: `=copy`(x: var VmThread; y: VmThread)

`[]=`:

• ast_parsed_types: `[]=`(node: ParsedNode; idx: int | BackwardsIndex; other: ParsedNode)
• ast_types: `[]=`(n: Indexable; i: BackwardsIndex; x: Indexable)
• ast_types: `[]=`(n: Indexable; i: int; x: Indexable)
• checked_ast: `[]=`(x: var CheckedAst; i: int | BackwardsIndex; n: sink CheckedAst)
• checked_ast: `[]=`(x: var CheckedAst; i: int | BackwardsIndex; n: sink PNode)
• checked_ast: `[]=`(x: var ElaborateAst; i: int | BackwardsIndex; n: PNode)
• checked_ast: `[]=`(x: var ElaborateAst; i: int | BackwardsIndex; n: sink CheckedAst)
• typemaps: `[]=`[T](t: var TypeTable[T]; key: PType; val: sink T)
• containers: `[]=`[K, V](m: var SeqMap[K, V]; key: K; val: sink V)
• containers: `[]=`[I; T](x: OrdinalSeq[I, T]; i: I; item: T): untyped
• containers: `[]=`[I; T](x: var Store[I, T]; i: I; it: T): untyped
• vmobjects: `[]=`(s: var VmString; i: Natural; c: char)

`[]`:

• ast_parsed_types: `[]`(node: ParsedNode; idx: int | BackwardsIndex): ParsedNode
• ast_query: `[]`(node: PNode; pos: NodePosName): PNode
• ast_query: `[]`(node: PNode; slice: NodeSliceName): seq[PNode]
• ast_types: `[]`(n: Indexable; i: BackwardsIndex): Indexable
• ast_types: `[]`(n: Indexable; i: int): Indexable
• checked_ast: `[]`(x: CheckedAst; i: int | BackwardsIndex): PNode
• checked_ast: `[]`(x: var ElaborateAst; i: int | BackwardsIndex): PNode
• cgir: `[]`(b: Body; id: LocalId): Local
• cgir: `[]`(n: CgNode; i: BackwardsIndex): CgNode
• cgir: `[]`(n: CgNode; i: Natural): CgNode
• options: `[]`(conf: ConfigRef; idx: FileIndex): TFileInfo
• bitabs: `[]`[T](t: var BiTable[T]; LitId: LitId): var T
• bitabs: `[]`[T](t: BiTable[T]; LitId: LitId): lent T
• packed_ast: `[]`(tree: PackedTree; i: int): lent PackedNode
• datatables: `[]`(t: DataTable; id: DataId): lent ConstrTree
• mirbodies: `[]`(body: MirBody; id: LocalId): lent Local
• mirbodies: `[]`(body: MirBody; n: NodePosition): lent MirNode
• mirenv: `[]`(env: MirEnv; id: AstId): lent PNode
• mirenv: `[]`(env: MirEnv; id: ConstId): lent PSym
• mirenv: `[]`(env: MirEnv; id: DataId): lent ConstrTree
• mirenv: `[]`(env: MirEnv; id: GlobalId): lent PSym
• mirenv: `[]`(env: MirEnv; id: ProcedureId): lent PSym
• mirenv: `[]`(env: MirEnv; id: StringId): lent string
• mirenv: `[]`[I; T](tab: SymbolTable[I, T]; id: I): lent T
• mirenv: `[]`[I; T](tab: SymbolTable[I, T]; s: PSym): I
• mirenv: `[]`(env: MirEnv; id: TypeId): PType
• mirtrees: `[]`(tree: MirTree; n: NodePosition; index: Natural): lent MirNode
• mirtrees: `[]`(tree: MirTree; n: OpValue; index: Natural): lent MirNode
• mirtrees: `[]`(tree: MirTree; i: NodePosition | OpValue): untyped
• mirtypes: `[]`(env: TypeEnv; id: HeaderId): lent TypeHeader
• mirtypes: `[]`(env: TypeEnv; id: TypeId): lent PType
• mirtypes: `[]`(env: TypeEnv; id: FieldId): RecField
• mirtypes: `[]`(env: TypeEnv; t: PType): TypeId
• sourcemaps: `[]`(m: SourceMap; i: SourceId): PNode
• typemaps: `[]`[T](t: TypeTable[T]; key: PType): T
• modulelowering: `[]`(list: ModuleList; i: FileIndex): Module
• semdata: `[]`(c: PContext; id: LibId): var TLib
• containers: `[]`[I; T](s: PartialStore[I, T]; id: I): lent T
• containers: `[]`[K, V](m: SeqMap[K, V]; key: K): lent V
• containers: `[]`[K, V](m: var SeqMap[K, V]; key: K): var V
• containers: `[]`[I; T](x: OrdinalSeq[I, T]; i: I): untyped
• containers: `[]`[I; T](x: Store[I, T]; i: I): untyped
• cursors: `[]`[T](x: Cursor[T]): lent T
• cursors: `[]`[I: Ordinal; T: seq](s: Cursor[T]; i: I): untyped
• vm: `[]`(t: VmThread; i: Natural): TStackFrame
• vmmemory: `[]`[T](p: VmMemPointer | CellPtr; s: Slice[T]): untyped
• vmobjects: `[]`(s: VmSlice; i: Natural): LocHandle
• vmobjects: `[]`(s: VmString; i: Natural): char

`div`:

• int128: `div`(a, b: Int128): Int128

`in`:

• mirtrees: `in`(p: NodePosition; tree: MirTree): bool

`mod`:

• int128: `mod`(a, b: Int128): Int128

`shl`:

• int128: `shl`(a: Int128; b: int): Int128

`shr`:

• int128: `shr`(a: Int128; b: int): Int128

`|*|`:

• saturate: `|*|`(a, b: BiggestInt): BiggestInt

`|+|`:

• saturate: `|+|`(a, b: BiggestInt): BiggestInt

`|-|`:

• saturate: `|-|`(a, b: BiggestInt): BiggestInt

`|abs|`:

• saturate: `|abs|`(a: BiggestInt): BiggestInt

`|div|`:

• saturate: `|div|`(a, b: BiggestInt): BiggestInt

`|mod|`:

• saturate: `|mod|`(a, b: BiggestInt): BiggestInt

`~`:

• ropes: `~`(r: string): Rope

abs:

• int128: abs(a: Int128): Int128

AbsoluteDir:

• pathutils: AbsoluteDir

AbsoluteFile:

• pathutils: AbsoluteFile

absOutFile:

• options: absOutFile(conf: ConfigRef): AbsoluteFile

abstractInst:

• ast_types: abstractInst

abstractPtrs:

• ast_types: abstractPtrs

abstractRange:

• ast_types: abstractRange

abstractVar:

• ast_types: abstractVar

abstractVarRange:

• ast_types: abstractVarRange

AccessViolationReason:

• vm_enums: AccessViolationReason

actualType:

• reports: actualType(r: SemReport): PType

adCyclicTree:

• AstDiagKind.adCyclicTree

add:

• ast_parsed_types: add(node: ParsedNode; other: ParsedNode)
• ast_types: add(father, son: Indexable)
• checked_ast: add(x: var CheckedAst; n: sink CheckedAst)
• checked_ast: add(x: var CheckedAst; n: sink PNode)
• sexp_reporter: add(self: var SexpNode; str: string; expr: SexpNode)
• mirconstr: add(bu: var MirBuilder; n: sink MirNode)
• mirconstr: add(bu: var MirBuilder; id: SourceId; n: sink MirNode)
• mirenv: add[I; T](tab: var SymbolTable[I, T]; s: PSym): I
• mirgen_blocks: add(c: var BlockCtx; b: Block)
• mirtypes: add(env: var TypeEnv; t: PType): TypeId
• sourcemaps: add(m: var SourceMap; origin: PNode): SourceId
• nilcheck: add[T, U](a: var SeqOfDistinct[T, U]; value: U)
• btrees: add[Key, Val](b: var BTree[Key, Val]; key: Key; val: Val)
• containers: add[I; T](x: var OrdinalSeq[I, T]; item: sink T): I
• containers: add[I; T](s: var PartialStore[I, T]; item: sink T): I
• containers: add[I; T](x: var Store[I, T]; it: sink T): I
• vmobjects: add(s: var string; str: VmString)
• vmobjects: add(s: var VmString; c: char; mm: var VmAllocator)
• vmobjects: add(s: var VmString; chars: openArray[char]; mm: var VmAllocator)
• vmobjects: add(s: var VmString; str: VmString; mm: var VmAllocator)

addAllowNil:

• ast: addAllowNil(father, son: Indexable)

addAsgnFact:

• guards: addAsgnFact(m: var TModel; key, value: PNode)

addCaseBranchFacts:

• guards: addCaseBranchFacts(m: var TModel; n: PNode; i: int)

addCompileOption:

• extccomp: addCompileOption(conf: ConfigRef; option: string)

addCompileOptionCmd:

• extccomp: addCompileOptionCmd(conf: ConfigRef; option: string)

addCompilerProc:

• ic: addCompilerProc(c: var PackedEncoder; m: var PackedModule; s: PSym)

addConverter:

• ic: addConverter(c: var PackedEncoder; m: var PackedModule; s: PSym)
• semdata: addConverter(c: PContext; conv: LazySym)

addConverterDef:

• semdata: addConverterDef(c: PContext; conv: LazySym)

addDecl:

• lookups: addDecl(c: PContext; sym: PSym; info = sym.info; scope = c.currentScope)

addDeclaredLoc:

• astmsgs: addDeclaredLoc(result: var string; conf: ConfigRef; sym: PSym)
• astmsgs: addDeclaredLoc(result: var string; conf: ConfigRef; typ: PType)

addDeclaredLocMaybe:

• astmsgs: addDeclaredLocMaybe(result: var string; conf: ConfigRef; sym: PSym)
• astmsgs: addDeclaredLocMaybe(result: var string; conf: ConfigRef; typ: PType)

addDep:

• modulegraphs: addDep(g: ModuleGraph; m: PSym; dep: FileIndex)

addDiscriminantFact:

• guards: addDiscriminantFact(m: var TModel; n: PNode)

addExport:

• semdata: addExport(c: PContext; s: PSym)

addExported:

• ic: addExported(c: var PackedEncoder; m: var PackedModule; s: PSym)

addExternalFileToCompile:

• extccomp: addExternalFileToCompile(conf: ConfigRef; filename: AbsoluteFile)
• extccomp: addExternalFileToCompile(conf: ConfigRef; c: var Cfile)

addExternalFileToLink:

• extccomp: addExternalFileToLink(conf: ConfigRef; filename: AbsoluteFile)

addf:

• ropes: addf(c: var Rope; frmt: FormatStr; args: openArray[Rope])

addFact:

• guards: addFact(m: var TModel; nn: PNode)

addFactLe:

• guards: addFactLe(m: var TModel; a, b: PNode)

addFactLt:

• guards: addFactLt(m: var TModel; a, b: PNode)

addFactNeg:

• guards: addFactNeg(m: var TModel; n: PNode)

addField:

• lowerings: addField(obj: PType; s: PSym; cache: IdentCache; idgen: IdGenerator)

addFileExt:

• pathutils: addFileExt(x: AbsoluteFile; ext: string): AbsoluteFile
• pathutils: addFileExt(x: RelativeFile; ext: string): RelativeFile

addFileToCompile:

• extccomp: addFileToCompile(conf: ConfigRef; cf: Cfile)

addHidden:

• ic: addHidden(c: var PackedEncoder; m: var PackedModule; s: PSym)

addIdent:

• packed_ast: addIdent(tree: var PackedTree; s: LitId; info: PackedLineInfo)

addImportFileDep:

• ic: addImportFileDep(c: var PackedEncoder; m: var PackedModule; f: FileIndex)
• semdata: addImportFileDep(c: PContext; f: FileIndex)

addIncludeDep:

• modulegraphs: addIncludeDep(g: ModuleGraph; module, includeFile: FileIndex)

addIncludeFileDep:

• ic: addIncludeFileDep(c: var PackedEncoder; m: var PackedModule; f: FileIndex)
• semdata: addIncludeFileDep(c: PContext; f: FileIndex)

addInheritedFields:

• semtypinst: addInheritedFields(check: var IntSet; obj: PType): int

addInNimDebugUtils:

• debugutils: addInNimDebugUtils(c: ConfigRef; action: string)
• debugutils: addInNimDebugUtils(c: ConfigRef; action: string; id: PIdent; resSym: PSym)
• debugutils: addInNimDebugUtils(c: ConfigRef; action: string; n, r: PNode)
• debugutils: addInNimDebugUtils(c: ConfigRef; action: string; n, r: PNode; flags: TExprFlags)
• debugutils: addInNimDebugUtils(c: ConfigRef; action: string; n: PNode; resSym: PSym)
• debugutils: addInNimDebugUtils(c: ConfigRef; action: string; n: PNode; prev, r: PType)
• debugutils: addInNimDebugUtils(c: ConfigRef; action: string; n: PNode; filter: TSymKinds; e: var seq[SemCallMismatch]; res: typed)
• debugutils: addInNimDebugUtils(c: ConfigRef; action: string; n: PNode; res: typed)
• debugutils: addInNimDebugUtils(c: ConfigRef; action: string; s: PSym; n: PNode; res: PNode)
• debugutils: addInNimDebugUtils(c: ConfigRef; action: string; x, y, r: PType)

addInNimDebugUtilsError:

• debugutils: addInNimDebugUtilsError(c: ConfigRef; n, e: PNode)

addInt128:

• int128: addInt128(result: var string; value: Int128)

addInterfaceDecl:

• lookups: addInterfaceDecl(c: PContext; sym: PSym)

addInterfaceDeclAt:

• lookups: addInterfaceDeclAt(c: PContext; scope: PScope; sym: PSym)

addInterfaceOverloadableSymAt:

• lookups: addInterfaceOverloadableSymAt(c: PContext; scope: PScope; sym: PSym)

addLib:

• modulegraphs: addLib(g: ModuleGraph; module: int; lib: sink TLib): LibId
• semdata: addLib(c: PContext; lib: sink TLib): LibId

addLinkOption:

• extccomp: addLinkOption(conf: ConfigRef; option: string)

addLinkOptionCmd:

• extccomp: addLinkOptionCmd(conf: ConfigRef; option: string)

addLocal:

• mirconstr: addLocal(bu: var MirBuilder; data: sink Local): LocalId

addLocalCompileOption:

• extccomp: addLocalCompileOption(conf: ConfigRef; option: string; nimfile: AbsoluteFile)

addMapping:

• sourcemap: addMapping(map: SourceMapGenerator; mapping: Mapping)

addMethod:

• ic: addMethod(c: var PackedEncoder; m: var PackedModule; s: PSym)

addMethodToGeneric:

• modulegraphs: addMethodToGeneric(g: ModuleGraph; module: int; t: PType; col: int; m: PSym)

addModuleId:

• packed_ast: addModuleId(tree: var PackedTree; s: ModuleId; info: PackedLineInfo)

addOverloadableSymAt:

• lookups: addOverloadableSymAt(c: PContext; scope: PScope; fn: PSym)

addParam:

• ast: addParam(procType: PType; param: PSym)
• mirtypes: addParam(b: var ProcBuilder; s: set[ParamFlag]; typ: TypeId)

addPath:

• nimblecmd: addPath(conf: ConfigRef; path: AbsoluteDir)

addPattern:

• semdata: addPattern(c: PContext; p: LazySym)

addPragmaAndCallConvMismatch:

• cli_reporter: addPragmaAndCallConvMismatch(message: var string; formal, actual: PType; conf: ConfigRef)

addPragmaComputation:

• ic: addPragmaComputation(c: var PackedEncoder; m: var PackedModule; n: PNode)
• semdata: addPragmaComputation(c: PContext; n: PNode)

addPrelimDecl:

• lookups: addPrelimDecl(c: PContext; sym: PSym)

addPureEnum:

• ic: addPureEnum(c: var PackedEncoder; m: var PackedModule; s: PSym)
• semdata: addPureEnum(c: PContext; e: LazySym)

addReexport:

• ic: addReexport(c: var PackedEncoder; m: var PackedModule; s: PSym)

addSonNilAllowed:

• ast: addSonNilAllowed(father, son: PNode)

addSonSkipIntLit:

• magicsys: addSonSkipIntLit(parent, kid: PType; id: IdGenerator)

addSym:

• packed_ast: addSym(tree: var PackedTree; s: int32; info: PackedLineInfo)
• lookups: addSym(scope: PScope; s: PSym)

addSymDef:

• packed_ast: addSymDef(tree: var PackedTree; s: SymId; info: PackedLineInfo)

addToGenericCache:

• semdata: addToGenericCache(c: PContext; s: PSym; inst: PType)

addToGenericProcCache:

• semdata: addToGenericProcCache(c: PContext; s: PSym; inst: PInstantiation)

addToHex:

• int128: addToHex(result: var string; arg: Int128)

addToLib:

• semdata: addToLib(lib: LibId; sym: PSym)

addTrmacro:

• ic: addTrmacro(c: var PackedEncoder; m: var PackedModule; s: PSym)

addTypeHeader:

• typesrenderer: addTypeHeader(result: var string; conf: ConfigRef; typ: PType; prefer: TPreferedDesc = preferMixed; getDeclarationPath = true)

addUniqueField:

• lowerings: addUniqueField(obj: PType; s: PSym; cache: IdentCache; idgen: IdGenerator): PSym

addUniqueSym:

• lookups: addUniqueSym(scope: PScope; s: PSym): PSym

addUnmappedField:

• lowerings: addUnmappedField(obj: PType; s: PSym; cache: IdentCache; idgen: IdGenerator): PSym

adSemAlignRequiresPowerOfTwo:

• AstDiagKind.adSemAlignRequiresPowerOfTwo

adSemAmbiguousIdent:

• AstDiagKind.adSemAmbiguousIdent

adSemAmbiguousIdentWithCandidates:

• AstDiagKind.adSemAmbiguousIdentWithCandidates

adSemAsmEmitExpectsStringLiteral:

• AstDiagKind.adSemAsmEmitExpectsStringLiteral

adSemBitsizeRequires1248:

• AstDiagKind.adSemBitsizeRequires1248

adSemBitsizeRequiresPositive:

• AstDiagKind.adSemBitsizeRequiresPositive

adSemBorrowPragmaNonDot:

• AstDiagKind.adSemBorrowPragmaNonDot

adSemCallconvExpected:

• AstDiagKind.adSemCallconvExpected

adSemCallInCompilesContextNotAProcOrField:

• AstDiagKind.adSemCallInCompilesContextNotAProcOrField

adSemCallIndirectTypeMismatch:

• AstDiagKind.adSemCallIndirectTypeMismatch

adSemCallNotAProcOrField:

• AstDiagKind.adSemCallNotAProcOrField

adSemCallOperatorsNotEnabled:

• AstDiagKind.adSemCallOperatorsNotEnabled

adSemCallTypeMismatch:

• AstDiagKind.adSemCallTypeMismatch

adSemCannotAssignTo:

• AstDiagKind.adSemCannotAssignTo

adSemCannotBeConvertedTo:

• AstDiagKind.adSemCannotBeConvertedTo

adSemCannotBeOfSubtype:

• AstDiagKind.adSemCannotBeOfSubtype

adSemCannotBeRaised:

• AstDiagKind.adSemCannotBeRaised

adSemCannotCastToNonConcrete:

• AstDiagKind.adSemCannotCastToNonConcrete

adSemCannotCastTypes:

• AstDiagKind.adSemCannotCastTypes

adSemCannotConvertToRange:

• AstDiagKind.adSemCannotConvertToRange

adSemCannotDeref:

• AstDiagKind.adSemCannotDeref

adSemCannotImportItself:

• AstDiagKind.adSemCannotImportItself

adSemCannotInferTypeOfLiteral:

• AstDiagKind.adSemCannotInferTypeOfLiteral

adSemCannotInstantiate:

• AstDiagKind.adSemCannotInstantiate

adSemCannotMixTypesAndValuesInTuple:

• AstDiagKind.adSemCannotMixTypesAndValuesInTuple

adSemCannotPushCast:

• AstDiagKind.adSemCannotPushCast

adSemCannotRaiseNonException:

• AstDiagKind.adSemCannotRaiseNonException

adSemCannotReturnTypeless:

• AstDiagKind.adSemCannotReturnTypeless

adSemCastRequiresStatement:

• AstDiagKind.adSemCastRequiresStatement

adSemCompilerOptionArgInvalid:

• AstDiagKind.adSemCompilerOptionArgInvalid

adSemCompilerOptionInvalid:

• AstDiagKind.adSemCompilerOptionInvalid

adSemConceptPredicateFailed:

• AstDiagKind.adSemConceptPredicateFailed

adSemConflictingExportnims:

• AstDiagKind.adSemConflictingExportnims

adSemConstantOfTypeHasNoValue:

• AstDiagKind.adSemConstantOfTypeHasNoValue

adSemConstExpressionExpected:

• AstDiagKind.adSemConstExpressionExpected

adSemConstExprExpected:

• AstDiagKind.adSemConstExprExpected

adSemContinueCannotHaveLabel:

• AstDiagKind.adSemContinueCannotHaveLabel

adSemCustomUserError:

• AstDiagKind.adSemCustomUserError

adSemDefNameSym:

• AstDiagKind.adSemDefNameSym

AdSemDefNameSym:

• ast_types: AdSemDefNameSym

adSemDefNameSymExistingError:

• AdSemDefNameSymKind.adSemDefNameSymExistingError

adSemDefNameSymExpectedKindMismatch:

• AdSemDefNameSymKind.adSemDefNameSymExpectedKindMismatch

adSemDefNameSymIdentGenFailed:

• AdSemDefNameSymKind.adSemDefNameSymIdentGenFailed

adSemDefNameSymIllformedAst:

• AdSemDefNameSymKind.adSemDefNameSymIllformedAst

AdSemDefNameSymKind:

• ast_types: AdSemDefNameSymKind

adSemDeprecatedCompilerOpt:

• AstDiagKind.adSemDeprecatedCompilerOpt

adSemDeprecatedCompilerOptArg:

• AstDiagKind.adSemDeprecatedCompilerOptArg

adSemDifferentTypeForReintroducedSymbol:

• AstDiagKind.adSemDifferentTypeForReintroducedSymbol

adSemDisallowedNilDeref:

• AstDiagKind.adSemDisallowedNilDeref

adSemDisallowedTypedescForTupleField:

• AstDiagKind.adSemDisallowedTypedescForTupleField

adSemDistinctDoesNotHaveDefaultValue:

• AstDiagKind.adSemDistinctDoesNotHaveDefaultValue

adSemDotOperatorsNotEnabled:

• AstDiagKind.adSemDotOperatorsNotEnabled

adSemEmptyAsm:

• AstDiagKind.adSemEmptyAsm

adSemExcessiveCompilePragmaArgs:

• AstDiagKind.adSemExcessiveCompilePragmaArgs

adSemExpectedIdentifier:

• AstDiagKind.adSemExpectedIdentifier

adSemExpectedIdentifierInExpr:

• AstDiagKind.adSemExpectedIdentifierInExpr

adSemExpectedIdentifierQuoteLimit:

• AstDiagKind.adSemExpectedIdentifierQuoteLimit

adSemExpectedIdentifierWithExprContext:

• AstDiagKind.adSemExpectedIdentifierWithExprContext

adSemExpectedLabel:

• AstDiagKind.adSemExpectedLabel

adSemExpectedNonemptyPattern:

• AstDiagKind.adSemExpectedNonemptyPattern

adSemExpectedObjectForOf:

• AstDiagKind.adSemExpectedObjectForOf

adSemExpectedObjectOfType:

• AstDiagKind.adSemExpectedObjectOfType

adSemExpectedObjectType:

• AstDiagKind.adSemExpectedObjectType

adSemExpectedOrdinal:

• AstDiagKind.adSemExpectedOrdinal

adSemExpectedOrdinalArrayIdx:

• AstDiagKind.adSemExpectedOrdinalArrayIdx

adSemExpectedRangeType:

• AstDiagKind.adSemExpectedRangeType

adSemExpectedValueForYield:

• AstDiagKind.adSemExpectedValueForYield

adSemExperimentalRequiresToplevel:

• AstDiagKind.adSemExperimentalRequiresToplevel

adSemExpressionCannotBeCalled:

• AstDiagKind.adSemExpressionCannotBeCalled

adSemExpressionHasNoType:

• AstDiagKind.adSemExpressionHasNoType

adSemExprHasNoAddress:

• AstDiagKind.adSemExprHasNoAddress

adSemExternalLocalNotAllowed:

• AstDiagKind.adSemExternalLocalNotAllowed

adSemFatalError:

• AstDiagKind.adSemFatalError

adSemFieldAssignmentInvalid:

• AstDiagKind.adSemFieldAssignmentInvalid

adSemFieldInitTwice:

• AstDiagKind.adSemFieldInitTwice

adSemFieldNotAccessible:

• AstDiagKind.adSemFieldNotAccessible

adSemFoldCannotComputeOffset:

• AstDiagKind.adSemFoldCannotComputeOffset

adSemFoldDivByZero:

• AstDiagKind.adSemFoldDivByZero

adSemFoldOverflow:

• AstDiagKind.adSemFoldOverflow

adSemFoldRangeCheckForLiteralConversionFailed:

• AstDiagKind.adSemFoldRangeCheckForLiteralConversionFailed

adSemForExpectedIterator:

• AstDiagKind.adSemForExpectedIterator

adSemIllegalCompileTime:

• AstDiagKind.adSemIllegalCompileTime

adSemIllegalConversion:

• AstDiagKind.adSemIllegalConversion

adSemIllegalCustomPragma:

• AstDiagKind.adSemIllegalCustomPragma

adSemIllformedAst:

• AstDiagKind.adSemIllformedAst

adSemIllformedAstExpectedOneOf:

• AstDiagKind.adSemIllformedAstExpectedOneOf

adSemIllformedAstExpectedPragmaOrIdent:

• AstDiagKind.adSemIllformedAstExpectedPragmaOrIdent

adSemImplementationExpected:

• AstDiagKind.adSemImplementationExpected

adSemImplementationNotAllowed:

• AstDiagKind.adSemImplementationNotAllowed

adSemImplicitAddrIsNotFirstParam:

• AstDiagKind.adSemImplicitAddrIsNotFirstParam

adSemImplicitDotCallNotAProcOrField:

• AstDiagKind.adSemImplicitDotCallNotAProcOrField

adSemImplicitPragmaError:

• AstDiagKind.adSemImplicitPragmaError

adSemImportjsRequiresJs:

• AstDiagKind.adSemImportjsRequiresJs

adSemIncompatibleDefaultExpr:

• AstDiagKind.adSemIncompatibleDefaultExpr

adSemIndexOutOfBounds:

• AstDiagKind.adSemIndexOutOfBounds

adSemIndexOutOfBoundsStatic:

• AstDiagKind.adSemIndexOutOfBoundsStatic

adSemIntLiteralExpected:

• AstDiagKind.adSemIntLiteralExpected

adSemInvalidBoolDefine:

• AstDiagKind.adSemInvalidBoolDefine

adSemInvalidControlFlow:

• AstDiagKind.adSemInvalidControlFlow

adSemInvalidExpression:

• AstDiagKind.adSemInvalidExpression

adSemInvalidExtern:

• AstDiagKind.adSemInvalidExtern

adSemInvalidIntDefine:

• AstDiagKind.adSemInvalidIntDefine

adSemInvalidOrderInArrayConstructor:

• AstDiagKind.adSemInvalidOrderInArrayConstructor

adSemInvalidPragma:

• AstDiagKind.adSemInvalidPragma

adSemInvalidPragmaBlock:

• AstDiagKind.adSemInvalidPragmaBlock

adSemInvalidTupleConstructorKey:

• AstDiagKind.adSemInvalidTupleConstructorKey

adSemInvalidTupleSubscript:

• AstDiagKind.adSemInvalidTupleSubscript

adSemIsOperatorTakes2Args:

• AstDiagKind.adSemIsOperatorTakes2Args

adSemLetNeedsInit:

• AstDiagKind.adSemLetNeedsInit

adSemLinePragmaExpectsTuple:

• AstDiagKind.adSemLinePragmaExpectsTuple

adSemLocalEscapesStackFrame:

• AstDiagKind.adSemLocalEscapesStackFrame

adSemLocksPragmaBadLevelRange:

• AstDiagKind.adSemLocksPragmaBadLevelRange

adSemLocksPragmaBadLevelString:

• AstDiagKind.adSemLocksPragmaBadLevelString

adSemLocksPragmaExpectsList:

• AstDiagKind.adSemLocksPragmaExpectsList

adSemLowHighInvalidArgument:

• AstDiagKind.adSemLowHighInvalidArgument

adSemMagicExpectTypeOrValue:

• AstDiagKind.adSemMagicExpectTypeOrValue

adSemMismatchedPopPush:

• AstDiagKind.adSemMismatchedPopPush

adSemMisplacedDeprecation:

• AstDiagKind.adSemMisplacedDeprecation

adSemMisplacedEffectsOf:

• AstDiagKind.adSemMisplacedEffectsOf

adSemMissingPragmaArg:

• AstDiagKind.adSemMissingPragmaArg

adSemModuleAliasMustBeIdentifier:

• AstDiagKind.adSemModuleAliasMustBeIdentifier

adSemNamedExprExpected:

• AstDiagKind.adSemNamedExprExpected

adSemNamedExprNotAllowed:

• AstDiagKind.adSemNamedExprNotAllowed

adSemNoReturnHasReturn:

• AstDiagKind.adSemNoReturnHasReturn

adSemNoReturnTypeDeclared:

• AstDiagKind.adSemNoReturnTypeDeclared

adSemNoTupleTypeForConstructor:

• AstDiagKind.adSemNoTupleTypeForConstructor

adSemNoUnionForJs:

• AstDiagKind.adSemNoUnionForJs

adSemObjectDoesNotHaveDefaultValue:

• AstDiagKind.adSemObjectDoesNotHaveDefaultValue

adSemObjectRequiresFieldInit:

• AstDiagKind.adSemObjectRequiresFieldInit

adSemObjectRequiresFieldInitNoDefault:

• AstDiagKind.adSemObjectRequiresFieldInitNoDefault

adSemOnlyDeclaredIdentifierFoundIsError:

• AstDiagKind.adSemOnlyDeclaredIdentifierFoundIsError

adSemOnOrOffExpected:

• AstDiagKind.adSemOnOrOffExpected

adSemPragmaDisallowedForTupleUnpacking:

• AstDiagKind.adSemPragmaDisallowedForTupleUnpacking

adSemPragmaDynlibRequiresExportc:

• AstDiagKind.adSemPragmaDynlibRequiresExportc

adSemPragmaOptionExpected:

• AstDiagKind.adSemPragmaOptionExpected

adSemPragmaRecursiveDependency:

• AstDiagKind.adSemPragmaRecursiveDependency

adSemProcHasNoConcreteType:

• AstDiagKind.adSemProcHasNoConcreteType

adSemProveInit:

• AstDiagKind.adSemProveInit

adSemRaisesPragmaExpectsObject:

• AstDiagKind.adSemRaisesPragmaExpectsObject

adSemRangeIsEmpty:

• AstDiagKind.adSemRangeIsEmpty

adSemRawTypeMismatch:

• AstDiagKind.adSemRawTypeMismatch

adSemRecursiveDependencyIterator:

• AstDiagKind.adSemRecursiveDependencyIterator

adSemReturnNotAllowed:

• AstDiagKind.adSemReturnNotAllowed

adSemSelectorMustBeOfCertainTypes:

• AstDiagKind.adSemSelectorMustBeOfCertainTypes

adSemStackEscape:

• AstDiagKind.adSemStackEscape

adSemStaticFieldNotFound:

• AstDiagKind.adSemStaticFieldNotFound

adSemStringLiteralExpected:

• AstDiagKind.adSemStringLiteralExpected

adSemStringRangeNotAllowed:

• AstDiagKind.adSemStringRangeNotAllowed

adSemSystemNeeds:

• AstDiagKind.adSemSystemNeeds

adSemThreadvarCannotInit:

• AstDiagKind.adSemThreadvarCannotInit

adSemTIsNotAConcreteType:

• AstDiagKind.adSemTIsNotAConcreteType

adSemTypeConversionArgumentMismatch:

• AstDiagKind.adSemTypeConversionArgumentMismatch

adSemTypeExpected:

• AstDiagKind.adSemTypeExpected

adSemTypeKindMismatch:

• AstDiagKind.adSemTypeKindMismatch

adSemTypeMismatch:

• AstDiagKind.adSemTypeMismatch

adSemTypeNotAllowed:

• AstDiagKind.adSemTypeNotAllowed

adSemUnavailableLocation:

• AstDiagKind.adSemUnavailableLocation

adSemUndeclaredField:

• AstDiagKind.adSemUndeclaredField

adSemUndeclaredIdentifier:

• AstDiagKind.adSemUndeclaredIdentifier

adSemUnexpectedEqInObjectConstructor:

• AstDiagKind.adSemUnexpectedEqInObjectConstructor

adSemUnexpectedPattern:

• AstDiagKind.adSemUnexpectedPattern

adSemUnexpectedPushArgument:

• AstDiagKind.adSemUnexpectedPushArgument

adSemUnknownExperimental:

• AstDiagKind.adSemUnknownExperimental

adSemUnknownIdentifier:

• AstDiagKind.adSemUnknownIdentifier

adSemUseOrDiscardExpr:

• AstDiagKind.adSemUseOrDiscardExpr

adSemVarForOutParamNeeded:

• AstDiagKind.adSemVarForOutParamNeeded

adSemWrongIdent:

• AstDiagKind.adSemWrongIdent

adSemWrongNumberOfArguments:

• AstDiagKind.adSemWrongNumberOfArguments

adSemWrongNumberOfGenericParams:

• AstDiagKind.adSemWrongNumberOfGenericParams

adSemWrongNumberOfVariables:

• AstDiagKind.adSemWrongNumberOfVariables

adSemYieldExpectedTupleConstr:

• AstDiagKind.adSemYieldExpectedTupleConstr

adVmAccessNoLocation:

• AstDiagVmKind.adVmAccessNoLocation

adVmAccessOutOfBounds:

• AstDiagVmKind.adVmAccessOutOfBounds

adVmAccessTypeMismatch:

• AstDiagVmKind.adVmAccessTypeMismatch

adVmArgNodeNotASymbol:

• AstDiagVmKind.adVmArgNodeNotASymbol

adVmCacheKeyAlreadyExists:

• AstDiagVmKind.adVmCacheKeyAlreadyExists

adVmCannotAddChild:

• AstDiagVmKind.adVmCannotAddChild

adVmCannotCast:

• AstDiagVmKind.adVmCannotCast

adVmCannotCreateNode:

• AstDiagVmKind.adVmCannotCreateNode

adVmCannotGetChild:

• AstDiagVmKind.adVmCannotGetChild

adVmCannotModifyTypechecked:

• AstDiagVmKind.adVmCannotModifyTypechecked

adVmCannotSetChild:

• AstDiagVmKind.adVmCannotSetChild

adVmDerefAccessOutOfBounds:

• AstDiagKind.adVmDerefAccessOutOfBounds

adVmDerefAccessTypeMismatch:

• AstDiagKind.adVmDerefAccessTypeMismatch

adVmDerefNilAccess:

• AstDiagKind.adVmDerefNilAccess

adVmDivisionByConstZero:

• AstDiagVmKind.adVmDivisionByConstZero

adVmErrInternal:

• AstDiagVmKind.adVmErrInternal

adVmError:

• AstDiagKind.adVmError

adVmFieldNotFound:

• AstDiagVmKind.adVmFieldNotFound

adVmFieldUnavailable:

• AstDiagVmKind.adVmFieldUnavailable

adVmGenCannotCallMethod:

• AstDiagVmGenKind.adVmGenCannotCallMethod

adVmGenCannotCast:

• AstDiagVmGenKind.adVmGenCannotCast

adVmGenCannotEvaluateAtComptime:

• AstDiagVmGenKind.adVmGenCannotEvaluateAtComptime

adVmGenCannotImportc:

• AstDiagVmGenKind.adVmGenCannotImportc

adVmGenCodeGenUnhandledMagic:

• AstDiagVmGenKind.adVmGenCodeGenUnhandledMagic

adVmGenError:

• AstDiagKind.adVmGenError

adVmGenMissingImportcCompleteStruct:

• AstDiagVmGenKind.adVmGenMissingImportcCompleteStruct

adVmGenNotUnused:

• AstDiagVmGenKind.adVmGenNotUnused

adVmGenTooLargeOffset:

• AstDiagVmGenKind.adVmGenTooLargeOffset

adVmGenTooManyRegistersRequired:

• AstDiagVmGenKind.adVmGenTooManyRegistersRequired

adVmIllegalConv:

• AstDiagVmKind.adVmIllegalConv

adVmIllegalConvFromXToY:

• AstDiagVmKind.adVmIllegalConvFromXToY

adVmIndexError:

• AstDiagVmKind.adVmIndexError

adVmMissingCacheKey:

• AstDiagVmKind.adVmMissingCacheKey

adVmNilAccess:

• AstDiagVmKind.adVmNilAccess

adVmNodeNotAProcSymbol:

• AstDiagVmKind.adVmNodeNotAProcSymbol

adVmNodeNotASymbol:

• AstDiagVmKind.adVmNodeNotASymbol

adVmNotAField:

• AstDiagVmKind.adVmNotAField

adVmNoType:

• AstDiagVmKind.adVmNoType

adVmOpcParseExpectedExpression:

• AstDiagVmKind.adVmOpcParseExpectedExpression

adVmOutOfRange:

• AstDiagVmKind.adVmOutOfRange

adVmOverOrUnderflow:

• AstDiagVmKind.adVmOverOrUnderflow

adVmQuit:

• AstDiagKind.adVmQuit

adVmTooManyIterations:

• AstDiagVmKind.adVmTooManyIterations

adVmUnhandledException:

• AstDiagVmKind.adVmUnhandledException

adVmUnsupportedNonNil:

• AstDiagKind.adVmUnsupportedNonNil

adVmUserError:

• AstDiagVmKind.adVmUserError

adWrappedError:

• AstDiagKind.adWrappedError

adWrappedSymError:

• AstDiagKind.adWrappedSymError

akArray:

• AtomKind.akArray

akCallable:

• AtomKind.akCallable

akDiscriminator:

• AtomKind.akDiscriminator

akFloat:

• AtomKind.akFloat

akInt:

• AtomKind.akInt

akObject:

• AtomKind.akObject

akPNode:

• AtomKind.akPNode

akPtr:

• AtomKind.akPtr

akRef:

• AtomKind.akRef

akSeq:

• AtomKind.akSeq

akSet:

• AtomKind.akSet

akString:

• AtomKind.akString

alias:

• mirconstr: alias(typ: TypeId; id: LocalId): Value

aliasSwitchTxtIncremental:

• CmdSwitchTextKind.aliasSwitchTxtIncremental

alignedSize:

• vmtypes: alignedSize(t: PVmType): uint

AliveContext:

• dce: AliveContext

AliveSyms:

• dce: AliveSyms

aliveSymsSection:

• RodSection.aliveSymsSection

AllNodeKinds:

• mirtrees: AllNodeKinds

allNodes:

• packed_ast: allNodes(tree: PackedTree): NodePos

allocator:

• vmdef: allocator(c: TCtx): untyped

allocConstantLocation:

• vmmemory: allocConstantLocation(a: var VmAllocator; typ: PVmType): LocHandle

allocLabel:

• mirconstr: allocLabel(bu: var MirBuilder): LabelId

allocLocationMemory:

• vmmemory: allocLocationMemory(a: var VmAllocator; len: Natural): CellId

allocSingleLocation:

• vmmemory: allocSingleLocation(a: var VmAllocator; typ: PVmType): LocHandle

allocTemp:

• mirconstr: allocTemp(bu: var MirBuilder; t: TypeId; alias = false): Value

allocTypedLocations:

• vmmemory: allocTypedLocations(a: var VmAllocator; typ: PVmType; count, lenInBytes: Natural): CellPtr

allowCast:

• TSandboxFlag.allowCast

AllowCommonBase:

• TTypeCmpFlag.AllowCommonBase

allowedCompileOptionArgs:

• optionsprocessor: allowedCompileOptionArgs(switch: string): seq[string]

allowedCompileOptionsArgs:

• optionsprocessor: allowedCompileOptionsArgs(switch: CmdSwitchKind): seq[string]

allowInfiniteLoops:

• TSandboxFlag.allowInfiniteLoops

allRoutinePragmas:

• pragmas: allRoutinePragmas

allScopes:

• lookups: allScopes(scope: PScope): PScope

allSyms:

• modulegraphs: allSyms(g: ModuleGraph; m: PSym): PSym
• lookups: allSyms(c: PContext): (PSym, int, bool)

analyseObjectWithTypeField:

• types: analyseObjectWithTypeField(t: PType): TTypeFieldResult

anyErrorsWalk:

• errorhandling: anyErrorsWalk(config: ConfigRef; n: PNode): PNode

AnyPath:

• pathutils: AnyPath

Apo:

• nimlexbase: Apo

appendToModule:

• ast: appendToModule(m: PSym; n: PNode)

apply:

• mirchangesets: apply(body: var MirBody; c: sink Changeset)
• treechangesets: apply(tree: var MirTree; c: sink PreparedChangeset)

applyOffset:

• vmdef: applyOffset(p: VmMemPointer | CellPtr; offset: uint): VmMemPointer

applyPasses:

• mirpasses: applyPasses(body: var MirBody; prc: PSym; env: var MirEnv; graph: ModuleGraph; target: TargetBackend)

applyRule:

• patterns: applyRule(c: PContext; s: PSym; n: PNode): PNode

aqNoAlias:

• TAliasRequest.aqNoAlias

aqNone:

• TAliasRequest.aqNone

aqShouldAlias:

• TAliasRequest.aqShouldAlias

arcToExpand:

• options: arcToExpand(conf`gensym76: ConfigRef): StringTableRef

arcToExpand=:

• options: arcToExpand=(conf`gensym76: ConfigRef; val`gensym76: StringTableRef)

arcToExpandDel:

• options: arcToExpandDel(conf`gensym75: ConfigRef; key`gensym75: string)

arcToExpandGet:

• options: arcToExpandGet(conf`gensym75: ConfigRef; key`gensym75: string): string

arcToExpandSet:

• options: arcToExpandSet(conf`gensym75: ConfigRef; key`gensym75: string; value`gensym75: string)

arDiscriminant:

• TAssignableResult.arDiscriminant

argtypeMatches:

• sigmatch: argtypeMatches(c: PContext; f, a: PType; fromHlo = false): bool

argument:

• mirtrees: argument(tree: MirTree; n: NodePosition; i: Natural): OpValue

ArgumentNodes:

• mirtrees: ArgumentNodes

arguments:

• mirtrees: arguments(tree: MirTree; n: NodePosition): (ArgKinds, EffectKind, OpValue)

arLentValue:

• TAssignableResult.arLentValue

arLocalLValue:

• TAssignableResult.arLocalLValue

arLValue:

• TAssignableResult.arLValue

arMaybe:

• TAnalysisResult.arMaybe

arNo:

• TAnalysisResult.arNo

arNone:

• TAssignableResult.arNone

arrayCopy:

• vmobjects: arrayCopy(mm: var VmMemoryManager; dest: var VmMemoryRegion; src: VmMemoryRegion; count: Natural; elemTyp: PVmType; reset: static[bool])

arrayLen:

• mirtypes: arrayLen(desc: TypeHeader; env: TypeEnv): BiggestInt
• vmobjects: arrayLen(loc: LocHandle): int

arStrange:

• TAssignableResult.arStrange

arYes:

• TAnalysisResult.arYes

asCString:

• vmobjects: asCString(s: VmString): cstring

asgn:

• options: asgn(conf: ConfigRef; sto, sfrom: ConfNoteSet)
• options: asgn(conf: ConfigRef; nset: ConfNoteSet; notes: ReportKinds)
• mirconstr: asgn(buf: var MirBuilder; a, b: Value)

asgnMove:

• mirconstr: asgnMove(bu: var MirBuilder; a, b: Value)

asgnRef:

• vmobjects: asgnRef(dst: var HeapSlotHandle; src: HeapSlotHandle; mm: var VmMemoryManager; reset: static[bool])

asgnVmString:

• vmobjects: asgnVmString(dest: var VmString; src: VmString; a: var VmAllocator)

asink:

• liftdestructors: asink(t: PType): PSym

assign:

• checked_ast: assign(x: var CheckedAst; n: sink PNode)

assignIfDefault:

• options: assignIfDefault[T](result: var T; val: T; def = default(T))

assignment:

• liftdestructors: assignment(t: PType): PSym

assignType:

• ast: assignType(dest, src: PType)

astdef:

• ast_query: astdef(s: PSym): PNode

AstDiagKind:

• ast_types: AstDiagKind

astDiagToLegacyReportKind:

• msgs: astDiagToLegacyReportKind(diag: AstDiagKind; vmGenDiag: Option[AstDiagVmGenKind] = none( AstDiagVmGenKind); vmEvent: Option[AstDiagVmKind] = none(AstDiagVmKind)): ReportKind
• msgs: astDiagToLegacyReportKind(diag: PAstDiag): ReportKind

AstDiagVmError:

• ast_types: AstDiagVmError

AstDiagVmGenError:

• ast_types: AstDiagVmGenError

AstDiagVmGenKind:

• ast_types: AstDiagVmGenKind

astDiagVmGenToLegacyReportKind:

• msgs: astDiagVmGenToLegacyReportKind(diag: AstDiagVmGenKind): ReportKind

AstDiagVmKind:

• ast_types: AstDiagVmKind

astDiagVmToLegacyReportKind:

• msgs: astDiagVmToLegacyReportKind(evt: AstDiagVmKind): ReportKind

AstDiagVmTrace:

• ast_types: AstDiagVmTrace

AstId:

• mirtrees: AstId

Atom:

• vmdef: Atom

AtomKind:

• vmdef: AtomKind

AtomNodes:

• mirtrees: AtomNodes

Atoms:

• mirtrees: Atoms

attachedAsgn:

• TTypeAttachedOp.attachedAsgn

attachedDeepCopy:

• TTypeAttachedOp.attachedDeepCopy

attachedDestructor:

• TTypeAttachedOp.attachedDestructor

attachedOpsSection:

• RodSection.attachedOpsSection

AttachedOpToMagic:

• ast_query: AttachedOpToMagic

AttachedOpToStr:

• ast_query: AttachedOpToStr

attachedSink:

• TTypeAttachedOp.attachedSink

attachedTrace:

• TTypeAttachedOp.attachedTrace

avrNoError:

• AccessViolationReason.avrNoError

avrNoLocation:

• AccessViolationReason.avrNoLocation

avrOutOfBounds:

• AccessViolationReason.avrOutOfBounds

avrTypeMismatch:

• AccessViolationReason.avrTypeMismatch

backend:

• options: backend(conf`gensym22: ConfigRef): TBackend

backend=:

• options: backend=(conf`gensym22: ConfigRef; val`gensym22: TBackend)

backendC:

• TBackend.backendC

BackendConfig:

• backends: BackendConfig

BackendEvent:

• backends: BackendEvent

BackendEventKind:

• backends: BackendEventKind

backendFlagsSection:

• RodSection.backendFlagsSection

backendInvalid:

• TBackend.backendInvalid

backendJs:

• TBackend.backendJs

backendNimVm:

• TBackend.backendNimVm

BackendReport:

• reports_backend: BackendReport

BackendReportKind:

• report_enums: BackendReportKind

BackendViewKind:

• types: BackendViewKind

BACKSPACE:

• nimlexbase: BACKSPACE

base:

• types: base(t: PType): PType
• mirtypes: base(desc: TypeHeader; env: TypeEnv): TypeId
• containers: base[I; T](x: OrdinalSeq[I, T]): seq[T]

base10:

• NumericalBase.base10

base16:

• NumericalBase.base16

base2:

• NumericalBase.base2

base8:

• NumericalBase.base8

baseOfDistinct:

• types: baseOfDistinct(t: PType; g: ModuleGraph; idgen: IdGenerator): PType

basicOps:

• vmops: basicOps(): Override

beforeRetNeeded:

• TCProcFlag.beforeRetNeeded

bekConstant:

• BackendEventKind.bekConstant

bekDiscovered:

• BackendEventKind.bekDiscovered

bekImported:

• BackendEventKind.bekImported

bekModule:

• BackendEventKind.bekModule

bekPartial:

• BackendEventKind.bekPartial

bekProcedure:

• BackendEventKind.bekProcedure

BEL:

• nimlexbase: BEL

BinaryOps:

• mirtrees: BinaryOps

bindConcreteTypeToUserTypeClass:

• types: bindConcreteTypeToUserTypeClass(tc, concrete: PType)

bindImmutable:

• mirconstr: bindImmutable(bu: var MirBuilder; tree: MirTree; lval: NodePosition): Value

bindMut:

• mirconstr: bindMut(bu: var MirBuilder; tree: MirTree; lval: NodePosition): Value

BiTable:

• bitabs: BiTable

bitand:

• int128: bitand(a, b: Int128): Int128

bitnot:

• int128: bitnot(a: Int128): Int128

bitor:

• int128: bitor(a, b: Int128): Int128

bitSet:

• vmobjects: bitSet(handle: LocHandle): untyped

bitSetCard:

• bitsets: bitSetCard(x: TBitSetView): BiggestInt

bitSetContains:

• bitsets: bitSetContains(x, y: TBitSetView): bool

bitSetDiff:

• bitsets: bitSetDiff(x: var TBitSetView; y: TBitSetView)

bitSetEquals:

• bitsets: bitSetEquals(x, y: TBitSetView): bool

bitSetExcl:

• bitsets: bitSetExcl(x: var TBitSetView; elem: BiggestInt)

bitSetIn:

• bitsets: bitSetIn(x: TBitSetView; e: BiggestInt): bool

bitSetIncl:

• bitsets: bitSetIncl(x: var TBitSetView; elem: BiggestInt)

bitSetInclRange:

• bitsets: bitSetInclRange(x: var TBitSetView; s: Slice[BiggestInt])

bitSetInit:

• bitsets: bitSetInit(b: var TBitSet; length: int)

bitSetIntersect:

• bitsets: bitSetIntersect(x: var TBitSetView; y: TBitSetView)

bitSetSymDiff:

• bitsets: bitSetSymDiff(x: var TBitSetView; y: TBitSetView)

bitSetUnion:

• bitsets: bitSetUnion(x: var TBitSetView; y: TBitSetView)

bitsize:

• mirtypes: bitsize(f: RecField): int

bitxor:

• int128: bitxor(a, b: Int128): Int128

bkBlock:

• BlockKind.bkBlock

bkExcept:

• BlockKind.bkExcept

bkFinally:

• BlockKind.bkFinally

bkScope:

• BlockKind.bkScope

bkTryExcept:

• BlockKind.bkTryExcept

bkTryFinally:

• BlockKind.bkTryFinally

blekBranch:

• BranchListEntryKind.blekBranch

blekEnd:

• BranchListEntryKind.blekEnd

blekStart:

• BranchListEntryKind.blekStart

Block:

• mirgen_blocks: Block

BlockCtx:

• mirgen_blocks: BlockCtx

blockExit:

• mirgen_blocks: blockExit(c; bu; targetBlock: int)

BlockId:

• cgir: BlockId

BlockKind:

• mirgen_blocks: BlockKind

BModule:

• cgendata: BModule
• jsgen: BModule

BModuleList:

• cgendata: BModuleList

bodiesSection:

• RodSection.bodiesSection

Body:

• cgir: Body

bodyPos:

• ast_query: bodyPos

boolArg:

• filters: boolArg(conf: ConfigRef; n: PNode; name: string; pos: int; default: bool): bool

boolLit:

• liftdestructors: boolLit(g: ModuleGraph; info: TLineInfo; value: bool): PNode

BoolType:

• mirtypes: BoolType

borrowChecking:

• Goal.borrowChecking

BProc:

• cgendata: BProc

bracketKind:

• renderer: bracketKind(g: TSrcGen; n: PNode): BracketKind

branches:

• ast_query: branches(node: PNode): tuple[position: int, n: PNode]

branchLabels:

• ast_query: branchLabels(node: PNode): (int, PNode)

BranchListEntry:

• vmdef: BranchListEntry

BranchListEntryKind:

• vmdef: BranchListEntryKind

BTree:

• btrees: BTree

buildAdd:

• guards: buildAdd(a: PNode; b: BiggestInt; o: Operators): PNode

buildBlock:

• mirconstr: buildBlock(bu: var MirBuilder; id: LabelId; body: untyped)

buildCall:

• mirconstr: buildCall(bu: var MirBuilder; prc: ProcedureId; t: TypeId; body: untyped)
• guards: buildCall(op: PSym; a: PNode): PNode
• guards: buildCall(op: PSym; a, b: PNode): PNode

buildIf:

• mirconstr: buildIf(bu: var MirBuilder; cond, body: untyped)

buildLe:

• guards: buildLe(o: Operators; a, b: PNode): PNode

buildMagicCall:

• mirconstr: buildMagicCall(bu: var MirBuilder; m: TMagic; t: TypeId; body: untyped)

buildProc:

• mirtypes: buildProc(env: var TypeEnv; kind: TypeKind; conv: TCallingConvention; ret: TypeId; builder, body: untyped): TypeId

buildStmt:

• mirconstr: buildStmt(bu: var MirBuilder; k: MirNodeKind; body: untyped)
• mirconstr: buildStmt(bu: var MirBuilder; body: untyped)

buildVoidCall:

• injectdestructors: buildVoidCall(bu: var MirBuilder; env: var MirEnv; p: PSym; body: untyped)

bvcNone:

• BackendViewKind.bvcNone

bvcSequence:

• BackendViewKind.bvcSequence

bvcSingle:

• BackendViewKind.bvcSingle

byteExcess:

• vmdef: byteExcess

byteView:

• vmdef: byteView(x: VmMemPointer | CellPtr; t: PVmType; num: int): untyped
• vmdef: byteView(x: ptr UncheckedArray[byte]; t: PVmType; num: int): untyped
• vmmemory: byteView(handle: LocHandle): untyped
• vmmemory: byteView(c: VmCell): untyped
• vmmemory: byteView(slice: VmSlice): untyped

callableDefs:

• ast_query: callableDefs

CallableKind:

• vmdef: CallableKind

callCCompiler:

• extccomp: callCCompiler(conf: ConfigRef)

callCodegenProc:

• lowerings: callCodegenProc(g: ModuleGraph; name: string; info: TLineInfo = unknownLineInfo; arg1, arg2, arg3, optionalArgs: PNode = nil): PNode

callConv:

• mirtypes: callConv(desc: TypeHeader; env: TypeEnv): TCallingConvention

calledFromInfo:

• reports: calledFromInfo(): ReportLineInfo
• debugutils: calledFromInfo(): InstantiationInfo

callee:

• mirtrees: callee(tree: MirTree; n: NodePosition): NodePosition

CallKinds:

• mirtrees: CallKinds

callLen:

• compat: callLen(n: CgNode): int

callOperator:

• Feature.callOperator

canAlias:

• isolation_check: canAlias(arg, ret: PType): bool

canCaptureFrom:

• sempass2: canCaptureFrom(captor, target: PSym): bool

canFormAcycle:

• types: canFormAcycle(typ: PType): bool

cannotOpen:

• RodFileError.cannotOpen

canon:

• guards: canon(n: PNode; o: Operators): PNode

canonDynlibName:

• options: canonDynlibName(s: string): string

Canonical:

• Level.Canonical

canonical:

• mirtypes: canonical(env: TypeEnv; typ: TypeId): TypeId

canonicalImport:

• options: canonicalImport(conf: ConfigRef; file: AbsoluteFile): string

canonicalImportAux:

• options: canonicalImportAux(conf: ConfigRef; file: AbsoluteFile): string

canonicalize:

• mirbridge: canonicalize(graph: ModuleGraph; idgen: IdGenerator; env: var MirEnv; owner: PSym; body: PNode; config: TranslationConfig): Body

canonicalizePath:

• options: canonicalizePath(conf: ConfigRef; path: AbsoluteFile): AbsoluteFile

canRaise:

• ast_query: canRaise(panicsEnabled: bool; n: PNode): bool

canRaiseConservative:

• ast_query: canRaiseConservative(fn: PNode): bool

canReport:

• options: canReport(conf: ConfigRef; id: NodeId): bool
• options: canReport(conf: ConfigRef; node: PNode): bool

canUseView:

• ast_analysis: canUseView(n: PNode): bool

cardSet:

• nimsets: cardSet(conf: ConfigRef; a: PNode): BiggestInt

castToInt64:

• int128: castToInt64(arg: Int128): int64

castToUInt64:

• int128: castToUInt64(arg: Int128): uint64

category:

• reports: category(kind: ReportKind): ReportCategory

CC:

• extccomp: CC

ccBcc:

• TSystemCC.ccBcc

ccCDecl:

• TCallingConvention.ccCDecl

ccCLang:

• TSystemCC.ccCLang

ccClangCl:

• TSystemCC.ccClangCl

ccClosure:

• TCallingConvention.ccClosure

ccEnv:

• TSystemCC.ccEnv

ccFastCall:

• TCallingConvention.ccFastCall

ccGcc:

• TSystemCC.ccGcc

ccgKeywordsHigh:

• wordrecg: ccgKeywordsHigh

ccgKeywordsLow:

• wordrecg: ccgKeywordsLow

ccHasSaneOverflow:

• extccomp: ccHasSaneOverflow(conf: ConfigRef): bool

ccIcc:

• TSystemCC.ccIcc

ccIcl:

• TSystemCC.ccIcl

ccInline:

• TCallingConvention.ccInline

ccLLVM_Gcc:

• TSystemCC.ccLLVM_Gcc

ccNimCall:

• TCallingConvention.ccNimCall

ccNintendoSwitch:

• TSystemCC.ccNintendoSwitch

ccNoConvention:

• TCallingConvention.ccNoConvention

ccNoInline:

• TCallingConvention.ccNoInline

ccNone:

• TSystemCC.ccNone

cCompiler:

• options: cCompiler(conf`gensym32: ConfigRef): TSystemCC

cCompiler=:

• options: cCompiler=(conf`gensym32: ConfigRef; val`gensym32: TSystemCC)

ccSafeCall:

• TCallingConvention.ccSafeCall

ccStdCall:

• TCallingConvention.ccStdCall

ccSysCall:

• TCallingConvention.ccSysCall

ccTcc:

• TSystemCC.ccTcc

ccVcc:

• TSystemCC.ccVcc

cekFlagError:

• ConfigFileEventKind.cekFlagError

cekInternalError:

• ConfigFileEventKind.cekInternalError

cekInvalidDirective:

• ConfigFileEventKind.cekInvalidDirective

cekLexerErrorDiag:

• ConfigFileEventKind.cekLexerErrorDiag

cekLexerWarningDiag:

• ConfigFileEventKind.cekLexerWarningDiag

cekParseExpectedCloseX:

• ConfigFileEventKind.cekParseExpectedCloseX

cekParseExpectedIdent:

• ConfigFileEventKind.cekParseExpectedIdent

cekParseExpectedX:

• ConfigFileEventKind.cekParseExpectedX

cekProgressConfStart:

• ConfigFileEventKind.cekProgressConfStart

cekProgressPathAdded:

• ConfigFileEventKind.cekProgressPathAdded

cekWriteConfig:

• ConfigFileEventKind.cekWriteConfig

CellId:

• vmdef: CellId

CellPtr:

• vmdef: CellPtr

Cfile:

• options: Cfile

CfileFlag:

• options: CfileFlag

CfileList:

• options: CfileList

cfsData:

• TCFileSection.cfsData

cfsDatInitProc:

• TCFileSection.cfsDatInitProc

cfsDebugInit:

• TCFileSection.cfsDebugInit

cfsFieldInfo:

• TCFileSection.cfsFieldInfo

cfsForwardTypes:

• TCFileSection.cfsForwardTypes

cfsFrameDefines:

• TCFileSection.cfsFrameDefines

cfsHeaders:

• TCFileSection.cfsHeaders

cfsInitProc:

• TCFileSection.cfsInitProc

cfsMergeInfo:

• TCFileSection.cfsMergeInfo

cfsProcHeaders:

• TCFileSection.cfsProcHeaders

cfsProcs:

• TCFileSection.cfsProcs

cfsSeqTypes:

• TCFileSection.cfsSeqTypes

cfsTypeInfo:

• TCFileSection.cfsTypeInfo

cfsTypeInit1:

• TCFileSection.cfsTypeInit1

cfsTypeInit2:

• TCFileSection.cfsTypeInit2

cfsTypeInit3:

• TCFileSection.cfsTypeInit3

cfsTypes:

• TCFileSection.cfsTypes

cfsVars:

• TCFileSection.cfsVars

cgenModules:

• cgendata: cgenModules(g: BModuleList): BModule

cgenWriteModules:

• cgen: cgenWriteModules(backend: RootRef; config: ConfigRef)

cgfAllowMeta:

• CodeGenFlag.cgfAllowMeta

CgNode:

• cgir: CgNode

CgNodeKind:

• cgir: CgNodeKind

change:

• mirexec: change(dfg: var DataFlowGraph; instrs: openArray[InstrPos]; to: Opcode)

changeDetectedViaJsonBuildInstructions:

• extccomp: changeDetectedViaJsonBuildInstructions(conf: ConfigRef; jsonFile: AbsoluteFile): bool

changeFileExt:

• pathutils: changeFileExt(x: AbsoluteFile; ext: string): AbsoluteFile
• pathutils: changeFileExt(x: RelativeFile; ext: string): RelativeFile

Changeset:

• mirchangesets: Changeset

changeTree:

• mirchangesets: changeTree(c: var Changeset; tree: MirTree; at: NodePosition; with: MirNode)
• treechangesets: changeTree(c: var Changeset; tree: MirTree; at: NodePosition; with: sink MirNode)

charArg:

• filters: charArg(conf: ConfigRef; n: PNode; name: string; pos: int; default: char): char

CharType:

• mirtypes: CharType

check:

• semcomptime: check(n: PNode): PNode

checkAmbiguity:

• TLookupFlag.checkAmbiguity

checkBorrowedLocations:

• varpartitions: checkBorrowedLocations(par: var Partitions; body: PNode; config: ConfigRef)

checkConstructedType:

• semtypinst: checkConstructedType(conf: ConfigRef; info: TLineInfo; typ: PType)

CheckedAst:

• checked_ast: CheckedAst

checkFieldAccess:

• guards: checkFieldAccess(m: TModel; n: PNode; conf: ConfigRef)

checkForHoles:

• ic: checkForHoles(m: PackedModule; config: ConfigRef; moduleId: int)

checkForSideEffects:

• parampatterns: checkForSideEffects(n: PNode): TSideEffectAnalysis

checkForSink:

• sempass2: checkForSink(config: ConfigRef; idgen: IdGenerator; owner: PSym; arg: PNode)

checkIntegrity:

• integrity: checkIntegrity(g: ModuleGraph)

checkIsolate:

• isolation_check: checkIsolate(n: PNode): bool

checkMethodEffects:

• sempass2: checkMethodEffects(g: ModuleGraph; disp, branch: PSym)

checkMinSonsLen:

• semdata: checkMinSonsLen(n: PNode; length: int; conf: ConfigRef)

checkModule:

• TLookupFlag.checkModule

checkModuleName:

• modulepaths: checkModuleName(conf: ConfigRef; n: PNode; doLocalError = true): FileIndex

checkNil:

• nilcheck: checkNil(s: PSym; body: PNode; conf: ConfigRef; idgen: IdGenerator)

checkpoint:

• datatables: checkpoint(t: DataTable): Checkpoint
• mirenv: checkpoint(env: MirEnv): EnvCheckpoint
• mirenv: checkpoint[I, T](tab: SymbolTable[I, T]): Checkpoint

Checkpoint:

• containers: Checkpoint

checkpoint:

• containers: checkpoint(s: Store): Checkpoint

checkPragmaUse:

• linter: checkPragmaUse(conf: ConfigRef; info: TLineInfo; w: TSpecialWord; pragmaName: string)

checkPureEnumFields:

• TLookupFlag.checkPureEnumFields

checkSonsLen:

• semdata: checkSonsLen(n: PNode; length: int; conf: ConfigRef)

ChecksOptions:

• options: ChecksOptions

checkSumsSection:

• RodSection.checkSumsSection

checkUndeclared:

• TLookupFlag.checkUndeclared

checkValid:

• vmchecks: checkValid(al: VmAllocator; h: LocHandle): AccessViolationReason

child:

• mirtrees: child(tree: MirTree; n: NodePosition; index: Natural): NodePosition

Child:

• sourcemap: Child

child:

• sourcemap: child(node: SourceNode): Child
• sourcemap: child(s: string): Child

cIncludes:

• options: cIncludes(conf`gensym46: ConfigRef): seq[AbsoluteDir]

cIncludes=:

• options: cIncludes=(conf`gensym46: ConfigRef; val`gensym46: seq[AbsoluteDir])

cIncludesAdd:

• options: cIncludesAdd(conf`gensym45: ConfigRef; item`gensym45: AbsoluteDir | seq[AbsoluteDir])

CInstr:

• ccgflow: CInstr

ckCallback:

• CallableKind.ckCallback

ckDefault:

• CallableKind.ckDefault

CLabel:

• ccgflow: CLabel

CLabelId:

• ccgflow: CLabelId

CLabelSpecifier:

• ccgflow: CLabelSpecifier

clampLineCol:

• lineinfos: clampLineCol(line, col: int): LineColPair

classify:

• types: classify(t: PType): OrdinalType
• proto_mir: classify(e: seq[ProtoItem]): ExprKind
• proto_mir: classify(e: seq[ProtoItem]; i: int): ExprKind

classifyBackendView:

• types: classifyBackendView(t: PType): BackendViewKind

classifyViewType:

• types: classifyViewType(t: PType): ViewTypeKind

clearNimblePath:

• options: clearNimblePath(conf: ConfigRef)

clearPasses:

• passes: clearPasses(g: ModuleGraph)

cLibs:

• options: cLibs(conf`gensym48: ConfigRef): seq[AbsoluteDir]

cLibs=:

• options: cLibs=(conf`gensym48: ConfigRef; val`gensym48: seq[AbsoluteDir])

cLibsAdd:

• options: cLibsAdd(conf`gensym47: ConfigRef; item`gensym47: AbsoluteDir | seq[AbsoluteDir])

CliEvent:

• commands: CliEvent

CliEventKind:

• commands: CliEventKind

cliEventLogger:

• commands: cliEventLogger(conf: ConfigRef; evt: CliEvent)

cliEvtErrCmdExpectedNoAdditionalArgs:

• CliEventKind.cliEvtErrCmdExpectedNoAdditionalArgs

cliEvtErrCmdMissing:

• CliEventKind.cliEvtErrCmdMissing

cliEvtErrFlagArgExpectedFromList:

• CliEventKind.cliEvtErrFlagArgExpectedFromList

cliEvtErrFlagArgForbidden:

• CliEventKind.cliEvtErrFlagArgForbidden

cliEvtErrFlagArgNotFromValidList:

• CliEventKind.cliEvtErrFlagArgNotFromValidList

cliEvtErrFlagProcessing:

• CliEventKind.cliEvtErrFlagProcessing

cliEvtErrGenDependFailed:

• CliEventKind.cliEvtErrGenDependFailed

cliEvtErrInvalidCommand:

• CliEventKind.cliEvtErrInvalidCommand

cliEvtErrNoCliParamsProvided:

• CliEventKind.cliEvtErrNoCliParamsProvided

cliEvtErrRunCmdFailed:

• CliEventKind.cliEvtErrRunCmdFailed

cliEvtErrUnexpectedRunOpt:

• CliEventKind.cliEvtErrUnexpectedRunOpt

cliEvtHintPathAdded:

• CliEventKind.cliEvtHintPathAdded

cliEvtWarnSwitchValDeprecatedNoop:

• CliEventKind.cliEvtWarnSwitchValDeprecatedNoop

cliFlagHelp:

• CliFlagKind.cliFlagHelp

cliFlagHelpAdvanced:

• CliFlagKind.cliFlagHelpAdvanced

cliFlagHelpFull:

• CliFlagKind.cliFlagHelpFull

CliFlagKind:

• commands: CliFlagKind

cliFlagMsgFormat:

• CliFlagKind.cliFlagMsgFormat

cliFlagVersion:

• CliFlagKind.cliFlagVersion

cliFmt:

• commands: cliFmt(conf: ConfigRef; info: TLineInfo; useColor: bool): string

cliFmtLineInfo:

• commands: cliFmtLineInfo(filename: string; line, col: int; useColor: bool): string

cliFmtMsgOrigin:

• commands: cliFmtMsgOrigin(origin: InstantiationInfo; showSuffix, useColor: bool): string

cliFmtSrcCodeOrigin:

• commands: cliFmtSrcCodeOrigin(origin: InstantiationInfo; useColor: bool): string

cLinkedLibs:

• options: cLinkedLibs(conf`gensym50: ConfigRef): seq[string]

cLinkedLibs=:

• options: cLinkedLibs=(conf`gensym50: ConfigRef; val`gensym50: seq[string])

cLinkedLibsAdd:

• options: cLinkedLibsAdd(conf`gensym49: ConfigRef; item`gensym49: string | seq[string])

close:

• ndi: close(f: var NdiFile; conf: ConfigRef)
• rodfiles: close(f: var RodFile)

closeBaseLexer:

• nimlexbase: closeBaseLexer(L: var TBaseLexer)

closeBlock:

• mirgen_blocks: closeBlock(c; bu): bool

closed:

• modulelowering: closed(modules: ModuleList): lent Module

closeLexer:

• lexer: closeLexer(lex: var Lexer)

closeParser:

• parser: closeParser(p: var Parser)

closeRodFile:

• modulegraphs: closeRodFile(g: ModuleGraph; m: PSym)

closeScope:

• mirgen_blocks: closeScope(c; bu; nextScope: int; hasStructuredExit: bool)
• lookups: closeScope(c: PContext)

closeShadowScope:

• lookups: closeShadowScope(c: PContext)

closest:

• mirgen_blocks: closest(c: BlockCtx): int

cmd:

• options: cmd(conf`gensym29: ConfigRef): Command

cmd=:

• options: cmd=(conf`gensym29: ConfigRef; val`gensym29: Command)

cmdBackends:

• options: cmdBackends

cmdBuildindex:

• Command.cmdBuildindex

cmdCheck:

• Command.cmdCheck

cmdCompileToC:

• Command.cmdCompileToC

cmdCompileToJS:

• Command.cmdCompileToJS

cmdCompileToVM:

• Command.cmdCompileToVM

cmdCrun:

• Command.cmdCrun

cmdCtags:

• Command.cmdCtags

cmdDoc:

• Command.cmdDoc

cmdDoc2tex:

• Command.cmdDoc2tex

cmdDocLike:

• options: cmdDocLike

cmdDump:

• Command.cmdDump

cmdGendepend:

• Command.cmdGendepend

cmdIdeTools:

• Command.cmdIdeTools

cmdInteractive:

• Command.cmdInteractive

cmdJsondoc:

• Command.cmdJsondoc

cmdJsonscript:

• Command.cmdJsonscript

cmdlineNotes:

• options: cmdlineNotes(conf: ConfigRef): ReportKinds

cmdlineNotes=:

• options: cmdlineNotes=(conf: ConfigRef; nset: ReportKinds)

cmdNimfix:

• Command.cmdNimfix

cmdNimscript:

• Command.cmdNimscript

cmdNone:

• Command.cmdNone

cmdNop:

• Command.cmdNop

cmdOutInternalDbg:

• CmdOutputKind.cmdOutInternalDbg

CmdOutputKind:

• commands: CmdOutputKind

cmdOutStatus:

• CmdOutputKind.cmdOutStatus

cmdOutUser:

• CmdOutputKind.cmdOutUser

cmdOutUserProf:

• CmdOutputKind.cmdOutUserProf

cmdParse:

• Command.cmdParse

CmdReport:

• reports_cmd: CmdReport

CmdReportKind:

• report_enums: CmdReportKind

cmdRod:

• Command.cmdRod

cmdRst2html:

• Command.cmdRst2html

cmdRst2tex:

• Command.cmdRst2tex

cmdScan:

• Command.cmdScan

cmdSwitchApp:

• CmdSwitchKind.cmdSwitchApp

cmdSwitchAsm:

• CmdSwitchKind.cmdSwitchAsm

cmdSwitchAssertions:

• CmdSwitchKind.cmdSwitchAssertions

cmdSwitchBackend:

• CmdSwitchKind.cmdSwitchBackend

cmdSwitchBenchmarkvm:

• CmdSwitchKind.cmdSwitchBenchmarkvm

cmdSwitchBoundchecks:

• CmdSwitchKind.cmdSwitchBoundchecks

cmdSwitchCc:

• CmdSwitchKind.cmdSwitchCc

cmdSwitchChecks:

• CmdSwitchKind.cmdSwitchChecks

cmdSwitchCincludes:

• CmdSwitchKind.cmdSwitchCincludes

cmdSwitchClearnimblepath:

• CmdSwitchKind.cmdSwitchClearnimblepath

cmdSwitchClib:

• CmdSwitchKind.cmdSwitchClib

cmdSwitchClibdir:

• CmdSwitchKind.cmdSwitchClibdir

cmdSwitchCmdexitgcstats:

• CmdSwitchKind.cmdSwitchCmdexitgcstats

cmdSwitchColors:

• CmdSwitchKind.cmdSwitchColors

cmdSwitchCompile:

• CmdSwitchKind.cmdSwitchCompile

cmdSwitchCompileonly:

• CmdSwitchKind.cmdSwitchCompileonly

cmdSwitchConfigVar:

• CmdSwitchKind.cmdSwitchConfigVar

cmdSwitchCppdefine:

• CmdSwitchKind.cmdSwitchCppdefine

cmdSwitchCpu:

• CmdSwitchKind.cmdSwitchCpu

cmdSwitchCursorinference:

• CmdSwitchKind.cmdSwitchCursorinference

cmdSwitchDebugger:

• CmdSwitchKind.cmdSwitchDebugger

cmdSwitchDebuginfo:

• CmdSwitchKind.cmdSwitchDebuginfo

cmdSwitchDeclaredlocs:

• CmdSwitchKind.cmdSwitchDeclaredlocs

cmdSwitchDeepcopy:

• CmdSwitchKind.cmdSwitchDeepcopy

cmdSwitchDefine:

• CmdSwitchKind.cmdSwitchDefine

cmdSwitchDepfile:

• CmdSwitchKind.cmdSwitchDepfile

cmdSwitchDoccmd:

• CmdSwitchKind.cmdSwitchDoccmd

cmdSwitchDocinternal:

• CmdSwitchKind.cmdSwitchDocinternal

cmdSwitchDocroot:

• CmdSwitchKind.cmdSwitchDocroot

cmdSwitchDocseesrcurl:

• CmdSwitchKind.cmdSwitchDocseesrcurl

cmdSwitchDynliboverride:

• CmdSwitchKind.cmdSwitchDynliboverride

cmdSwitchDynliboverrideall:

• CmdSwitchKind.cmdSwitchDynliboverrideall

cmdSwitchEmbedsrc:

• CmdSwitchKind.cmdSwitchEmbedsrc

cmdSwitchErrormax:

• CmdSwitchKind.cmdSwitchErrormax

cmdSwitchExceptions:

• CmdSwitchKind.cmdSwitchExceptions

cmdSwitchExcessivestacktrace:

• CmdSwitchKind.cmdSwitchExcessivestacktrace

cmdSwitchExcludepath:

• CmdSwitchKind.cmdSwitchExcludepath

cmdSwitchExpandarc:

• CmdSwitchKind.cmdSwitchExpandarc

cmdSwitchExpandmacro:

• CmdSwitchKind.cmdSwitchExpandmacro

cmdSwitchExperimental:

• CmdSwitchKind.cmdSwitchExperimental

cmdSwitchFieldchecks:

• CmdSwitchKind.cmdSwitchFieldchecks

cmdSwitchFilenames:

• CmdSwitchKind.cmdSwitchFilenames

cmdSwitchFloatchecks:

• CmdSwitchKind.cmdSwitchFloatchecks

cmdSwitchForcebuild:

• CmdSwitchKind.cmdSwitchForcebuild

cmdSwitchFromcmd:

• CmdSwitchKind.cmdSwitchFromcmd

cmdSwitchGc:

• CmdSwitchKind.cmdSwitchGc

cmdSwitchGenmapping:

• CmdSwitchKind.cmdSwitchGenmapping

cmdSwitchGenscript:

• CmdSwitchKind.cmdSwitchGenscript

cmdSwitchHeader:

• CmdSwitchKind.cmdSwitchHeader

cmdSwitchHint:

• CmdSwitchKind.cmdSwitchHint

cmdSwitchHintaserror:

• CmdSwitchKind.cmdSwitchHintaserror

cmdSwitchHints:

• CmdSwitchKind.cmdSwitchHints

cmdSwitchImplicitstatic:

• CmdSwitchKind.cmdSwitchImplicitstatic

cmdSwitchImport:

• CmdSwitchKind.cmdSwitchImport

cmdSwitchInclude:

• CmdSwitchKind.cmdSwitchInclude

cmdSwitchIncremental:

• CmdSwitchKind.cmdSwitchIncremental

cmdSwitchIndex:

• CmdSwitchKind.cmdSwitchIndex

cmdSwitchInfchecks:

• CmdSwitchKind.cmdSwitchInfchecks

CmdSwitchKind:

• optionsprocessor: CmdSwitchKind

cmdSwitchLib:

• CmdSwitchKind.cmdSwitchLib

cmdSwitchLinedir:

• CmdSwitchKind.cmdSwitchLinedir

cmdSwitchLinetrace:

• CmdSwitchKind.cmdSwitchLinetrace

cmdSwitchLink:

• CmdSwitchKind.cmdSwitchLink

cmdSwitchListcmd:

• CmdSwitchKind.cmdSwitchListcmd

cmdSwitchListfullpaths:

• CmdSwitchKind.cmdSwitchListfullpaths

cmdSwitchMaxloopiterationsvm:

• CmdSwitchKind.cmdSwitchMaxloopiterationsvm

cmdSwitchMemtracker:

• CmdSwitchKind.cmdSwitchMemtracker

cmdSwitchMultimethods:

• CmdSwitchKind.cmdSwitchMultimethods

cmdSwitchNanchecks:

• CmdSwitchKind.cmdSwitchNanchecks

cmdSwitchNimblepath:

• CmdSwitchKind.cmdSwitchNimblepath

cmdSwitchNimcache:

• CmdSwitchKind.cmdSwitchNimcache

cmdSwitchNolinking:

• CmdSwitchKind.cmdSwitchNolinking

cmdSwitchNomain:

• CmdSwitchKind.cmdSwitchNomain

cmdSwitchNonimblepath:

• CmdSwitchKind.cmdSwitchNonimblepath

cmdSwitchObjchecks:

• CmdSwitchKind.cmdSwitchObjchecks

cmdSwitchOpt:

• CmdSwitchKind.cmdSwitchOpt

cmdSwitchOs:

• CmdSwitchKind.cmdSwitchOs

cmdSwitchOut:

• CmdSwitchKind.cmdSwitchOut

cmdSwitchOutdir:

• CmdSwitchKind.cmdSwitchOutdir

cmdSwitchOverflowchecks:

• CmdSwitchKind.cmdSwitchOverflowchecks

cmdSwitchPanics:

• CmdSwitchKind.cmdSwitchPanics

cmdSwitchParallelbuild:

• CmdSwitchKind.cmdSwitchParallelbuild

cmdSwitchPassc:

• CmdSwitchKind.cmdSwitchPassc

cmdSwitchPassl:

• CmdSwitchKind.cmdSwitchPassl

cmdSwitchPath:

• CmdSwitchKind.cmdSwitchPath

cmdSwitchProcessing:

• CmdSwitchKind.cmdSwitchProcessing

cmdSwitchProfiler:

• CmdSwitchKind.cmdSwitchProfiler

cmdSwitchProfilevm:

• CmdSwitchKind.cmdSwitchProfilevm

cmdSwitchProject:

• CmdSwitchKind.cmdSwitchProject

cmdSwitchProjStdin:

• CmdSwitchKind.cmdSwitchProjStdin

cmdSwitchPutenv:

• CmdSwitchKind.cmdSwitchPutenv

cmdSwitchRangechecks:

• CmdSwitchKind.cmdSwitchRangechecks

cmdSwitchRun:

• CmdSwitchKind.cmdSwitchRun

cmdSwitchSeqsv2:

• CmdSwitchKind.cmdSwitchSeqsv2

cmdSwitchShowallmismatches:

• CmdSwitchKind.cmdSwitchShowallmismatches

cmdSwitchShowIr:

• CmdSwitchKind.cmdSwitchShowIr

cmdSwitchSinkinference:

• CmdSwitchKind.cmdSwitchSinkinference

cmdSwitchSkipcfg:

• CmdSwitchKind.cmdSwitchSkipcfg

cmdSwitchSkipparentcfg:

• CmdSwitchKind.cmdSwitchSkipparentcfg

cmdSwitchSkipprojcfg:

• CmdSwitchKind.cmdSwitchSkipprojcfg

cmdSwitchSkipusercfg:

• CmdSwitchKind.cmdSwitchSkipusercfg

cmdSwitchSourcemap:

• CmdSwitchKind.cmdSwitchSourcemap

cmdSwitchSpellsuggest:

• CmdSwitchKind.cmdSwitchSpellsuggest

cmdSwitchStacktrace:

• CmdSwitchKind.cmdSwitchStacktrace

cmdSwitchStacktracemsgs:

• CmdSwitchKind.cmdSwitchStacktracemsgs

cmdSwitchStaticboundchecks:

• CmdSwitchKind.cmdSwitchStaticboundchecks

cmdSwitchStdout:

• CmdSwitchKind.cmdSwitchStdout

cmdSwitchStylecheck:

• CmdSwitchKind.cmdSwitchStylecheck

cmdSwitchStylechecks:

• CmdSwitchKind.cmdSwitchStylechecks

CmdSwitchTextKind:

• optionsprocessor: CmdSwitchTextKind

cmdSwitchThreadanalysis:

• CmdSwitchKind.cmdSwitchThreadanalysis

cmdSwitchThreads:

• CmdSwitchKind.cmdSwitchThreads

cmdSwitchTlsemulation:

• CmdSwitchKind.cmdSwitchTlsemulation

cmdSwitchTrmacros:

• CmdSwitchKind.cmdSwitchTrmacros

cmdSwitchUndef:

• CmdSwitchKind.cmdSwitchUndef

cmdSwitchUnitsep:

• CmdSwitchKind.cmdSwitchUnitsep

cmdSwitchUsenimcache:

• CmdSwitchKind.cmdSwitchUsenimcache

cmdSwitchVerbosity:

• CmdSwitchKind.cmdSwitchVerbosity

cmdSwitchWarning:

• CmdSwitchKind.cmdSwitchWarning

cmdSwitchWarningaserror:

• CmdSwitchKind.cmdSwitchWarningaserror

cmdSwitchWarnings:

• CmdSwitchKind.cmdSwitchWarnings

cmdTcc:

• Command.cmdTcc

cmdUnknown:

• Command.cmdUnknown

cmp:

• int128: cmp(a, b: Int128): int
• vmobjects: cmp(a, b: VmString): int

cmpCandidates:

• sigmatch: cmpCandidates(a, b: TCandidate): int

cmpIgnoreStyle:

• idents: cmpIgnoreStyle(a, b: cstring; blen: int): int

CmpLocsResult:

• aliasanalysis: CmpLocsResult

cmpPaths:

• pathutils: cmpPaths(x, y: AbsoluteDir): int

cmpTypes:

• sigmatch: cmpTypes(c: PContext; f, a: PType): TTypeRelation

cnCmdline:

• ConfNoteSet.cnCmdline

cnCurrent:

• ConfNoteSet.cnCurrent

cnForeign:

• ConfNoteSet.cnForeign

cnHintAsError:

• ConfNoteSet.cnHintAsError

cnkAdd:

• CgNodeKind.cnkAdd

cnkAddr:

• CgNodeKind.cnkAddr

cnkArrayAccess:

• CgNodeKind.cnkArrayAccess

cnkArrayConstr:

• CgNodeKind.cnkArrayConstr

cnkAsgn:

• CgNodeKind.cnkAsgn

cnkAsmStmt:

• CgNodeKind.cnkAsmStmt

cnkAstLit:

• CgNodeKind.cnkAstLit

cnkAtoms:

• cgir: cnkAtoms

cnkBinding:

• CgNodeKind.cnkBinding

cnkBranch:

• CgNodeKind.cnkBranch

cnkCall:

• CgNodeKind.cnkCall

cnkCaseStmt:

• CgNodeKind.cnkCaseStmt

cnkCast:

• CgNodeKind.cnkCast

cnkCheckedCall:

• CgNodeKind.cnkCheckedCall

cnkClosureConstr:

• CgNodeKind.cnkClosureConstr

cnkConst:

• CgNodeKind.cnkConst

cnkContinueStmt:

• CgNodeKind.cnkContinueStmt

cnkConv:

• CgNodeKind.cnkConv

cnkDef:

• CgNodeKind.cnkDef

cnkDeref:

• CgNodeKind.cnkDeref

cnkDerefView:

• CgNodeKind.cnkDerefView

cnkDiv:

• CgNodeKind.cnkDiv

cnkEmitStmt:

• CgNodeKind.cnkEmitStmt

cnkEmpty:

• CgNodeKind.cnkEmpty

cnkEnd:

• CgNodeKind.cnkEnd

cnkExcept:

• CgNodeKind.cnkExcept

cnkFastAsgn:

• CgNodeKind.cnkFastAsgn

cnkField:

• CgNodeKind.cnkField

cnkFieldAccess:

• CgNodeKind.cnkFieldAccess

cnkFinally:

• CgNodeKind.cnkFinally

cnkFloatLit:

• CgNodeKind.cnkFloatLit

cnkGlobal:

• CgNodeKind.cnkGlobal

cnkGotoStmt:

• CgNodeKind.cnkGotoStmt

cnkHiddenAddr:

• CgNodeKind.cnkHiddenAddr

cnkHiddenConv:

• CgNodeKind.cnkHiddenConv

cnkIfStmt:

• CgNodeKind.cnkIfStmt

cnkIntLit:

• CgNodeKind.cnkIntLit

cnkInvalid:

• CgNodeKind.cnkInvalid

cnkJoinStmt:

• CgNodeKind.cnkJoinStmt

cnkLabel:

• CgNodeKind.cnkLabel

cnkLeave:

• CgNodeKind.cnkLeave

cnkLiterals:

• cgir: cnkLiterals

cnkLocal:

• CgNodeKind.cnkLocal

cnkLoopJoinStmt:

• CgNodeKind.cnkLoopJoinStmt

cnkLoopStmt:

• CgNodeKind.cnkLoopStmt

cnkLvalueConv:

• CgNodeKind.cnkLvalueConv

cnkMagic:

• CgNodeKind.cnkMagic

cnkModI:

• CgNodeKind.cnkModI

cnkMul:

• CgNodeKind.cnkMul

cnkNeg:

• CgNodeKind.cnkNeg

cnkNilLit:

• CgNodeKind.cnkNilLit

cnkObjConstr:

• CgNodeKind.cnkObjConstr

cnkObjDownConv:

• CgNodeKind.cnkObjDownConv

cnkObjUpConv:

• CgNodeKind.cnkObjUpConv

cnkProc:

• CgNodeKind.cnkProc

cnkRaiseStmt:

• CgNodeKind.cnkRaiseStmt

cnkRange:

• CgNodeKind.cnkRange

cnkResume:

• CgNodeKind.cnkResume

cnkSetConstr:

• CgNodeKind.cnkSetConstr

cnkStmtList:

• CgNodeKind.cnkStmtList

cnkStrLit:

• CgNodeKind.cnkStrLit

cnkSub:

• CgNodeKind.cnkSub

cnkTargetList:

• CgNodeKind.cnkTargetList

cnkToSlice:

• CgNodeKind.cnkToSlice

cnkTupleAccess:

• CgNodeKind.cnkTupleAccess

cnkTupleConstr:

• CgNodeKind.cnkTupleConstr

cnkType:

• CgNodeKind.cnkType

cnkUIntLit:

• CgNodeKind.cnkUIntLit

cnkVoidStmt:

• CgNodeKind.cnkVoidStmt

cnkWithItems:

• cgir: cnkWithItems

cnkWithOperand:

• cgir: cnkWithOperand

cnMainPackage:

• ConfNoteSet.cnMainPackage

cnModifiedy:

• ConfNoteSet.cnModifiedy

cnstFloat:

• ConstantKind.cnstFloat

cnstInt:

• ConstantKind.cnstInt

cnstNode:

• ConstantKind.cnstNode

cnstSliceListFloat:

• ConstantKind.cnstSliceListFloat

cnstSliceListInt:

• ConstantKind.cnstSliceListInt

cnWarnAsError:

• ConfNoteSet.cnWarnAsError

CodeGenCtx:

• vmgen: CodeGenCtx

CodegenFlag:

• cgendata: CodegenFlag

CodeGenFlag:

• vmdef: CodeGenFlag

CodeInfo:

• vmdef: CodeInfo

codeListing:

• vmutils: codeListing(c: TCtx; start = 0; last = -1): seq[DebugVmCodeEntry]

CoDistinct:

• ConsiderFlag.CoDistinct

CoHashTypeInsideNode:

• ConsiderFlag.CoHashTypeInsideNode

CoIgnoreRange:

• ConsiderFlag.CoIgnoreRange

collectPass:

• modulelowering: collectPass

ColOffset:

• msgs: ColOffset

Command:

• in_options: Command

commandBuildIndex:

• docgen: commandBuildIndex(conf: ConfigRef; dir: string; outFile = RelativeFile"")

commandLineDesc:

• options: commandLineDesc

commandLineIdx:

• lineinfos: commandLineIdx

commandRst2Html:

• docgen: commandRst2Html(cache: IdentCache; conf: ConfigRef)

commandRst2TeX:

• docgen: commandRst2TeX(cache: IdentCache; conf: ConfigRef)

commandTags:

• docgen: commandTags(cache: IdentCache; conf: ConfigRef)

comment:

• ast_types: comment(n: PNode): string

comment=:

• ast_types: comment=(n: PNode; a: string)

commonOptimizations:

• transf: commonOptimizations(g: ModuleGraph; idgen: IdGenerator; c: PSym; n: PNode): PNode

commonSuperclass:

• types: commonSuperclass(a, b: PType): PType

commonType:

• sem: commonType(c: PContext; x: PType; y: PNode): PType
• sem: commonType(c: PContext; x, y: PType): PType

commonTypeBegin:

• sem: commonTypeBegin(): PType

compactTReprConf:

• astrepr: compactTReprConf

compare:

• aliasanalysis: compare(body: MirTree; a, b: Path): CmpLocsResult

compareTypes:

• types: compareTypes(x, y: PType; cmp: TDistinctCompare = dcEq; flags: TTypeCmpFlags = {}): bool

compatibleEffects:

• types: compatibleEffects(formal, actual: PType): EffectsCompat

compilationCachePresent:

• options: compilationCachePresent(conf: ConfigRef): untyped

compile:

• vmjit: compile(jit: var JitState; c: var TCtx; fnc: FunctionIndex): VmGenResult

compileModule:

• modules: compileModule(graph: ModuleGraph; fileIdx: FileIndex; flags: TSymFlags; fromModule: PSym = nil): PSym

compileOptArgCheckFailedWithInvalidOption:

• CompileOptArgCheckResult.compileOptArgCheckFailedWithInvalidOption

compileOptArgCheckFailedWithUnexpectedValue:

• CompileOptArgCheckResult.compileOptArgCheckFailedWithUnexpectedValue

CompileOptArgCheckResult:

• optionsprocessor: CompileOptArgCheckResult

compileOptArgCheckSuccessFalse:

• CompileOptArgCheckResult.compileOptArgCheckSuccessFalse

compileOptArgCheckSuccessTrue:

• CompileOptArgCheckResult.compileOptArgCheckSuccessTrue

compileOptArgCheckWarnFalseDeprecated:

• CompileOptArgCheckResult.compileOptArgCheckWarnFalseDeprecated

compileOptCheckFailedWithInvalidOption:

• CompileOptCheckResult.compileOptCheckFailedWithInvalidOption

CompileOptCheckResult:

• optionsprocessor: CompileOptCheckResult

compileOptCheckSuccessFalse:

• CompileOptCheckResult.compileOptCheckSuccessFalse

compileOptCheckSuccessTrue:

• CompileOptCheckResult.compileOptCheckSuccessTrue

compileOptCheckWarnFalseDeprecated:

• CompileOptCheckResult.compileOptCheckWarnFalseDeprecated

compileOptionsCmd:

• options: compileOptionsCmd(conf`gensym54: ConfigRef): seq[string]

compileOptionsCmd=:

• options: compileOptionsCmd=(conf`gensym54: ConfigRef; val`gensym54: seq[string])

compileOptionsCmdAdd:

• options: compileOptionsCmdAdd(conf`gensym53: ConfigRef; item`gensym53: string | seq[string])

compileProject:

• modules: compileProject(graph: ModuleGraph; projectFileIdx = InvalidFileIdx)

compilerInfoPos:

• ast_query: compilerInfoPos

compilerInstInfo:

• errorhandling: compilerInstInfo(e: PNode): InstantiationInfo

compilerProcsSection:

• RodSection.compilerProcsSection

CompilerTrace:

• debugutils: CompilerTrace

compilerTraceDefined:

• CompilerTraceKind.compilerTraceDefined

compilerTraceEnd:

• CompilerTraceKind.compilerTraceEnd

CompilerTraceKind:

• debugutils: CompilerTraceKind

compilerTraceLine:

• CompilerTraceKind.compilerTraceLine

compilerTraceStart:

• CompilerTraceKind.compilerTraceStart

compilerTraceStep:

• CompilerTraceKind.compilerTraceStep

compilerTraceUndefined:

• CompilerTraceKind.compilerTraceUndefined

CompilerVerbosity:

• lineinfos: CompilerVerbosity

CompilerVersion:

• nversion: CompilerVersion

CompilerVersionSuffix:

• nversion: CompilerVersionSuffix

CompilesId:

• ast_types: CompilesId

compileSystemModule:

• modules: compileSystemModule(graph: ModuleGraph)

compileTimeOps:

• vmops: compileTimeOps(): Override

complement:

• nimsets: complement(conf: ConfigRef; a: PNode): PNode

completeCfilePath:

• extccomp: completeCfilePath(conf: ConfigRef; cfile: AbsoluteFile; createSubDir: bool = true): AbsoluteFile

completeGeneratedExtFilePath:

• options: completeGeneratedExtFilePath(conf: ConfigRef; f: AbsoluteFile): AbsoluteFile

completeGeneratedFilePath:

• options: completeGeneratedFilePath(conf: ConfigRef; f: AbsoluteFile; createSubDir: bool = true): AbsoluteFile

completePartialOp:

• modulegraphs: completePartialOp(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym)

computeAliveSyms:

• dce: computeAliveSyms(g: PackedModuleGraph; graph: ModuleGraph; conf: ConfigRef): AliveSyms

computeCursors:

• varpartitions: computeCursors(s: PSym; n: PNode; g: ModuleGraph)

computeDepth:

• mirtypes: computeDepth(env: TypeEnv; desc: TypeHeader; pos: int32): int

computeDfg:

• mirexec: computeDfg(tree: MirTree): DataFlowGraph

computeGraphPartitions:

• varpartitions: computeGraphPartitions(s: PSym; n: PNode; g: ModuleGraph; goals: set[Goal]): Partitions

computePath:

• aliasanalysis: computePath(tree: MirTree; at: NodePosition): Path

computeSize:

• types: computeSize(conf: ConfigRef; typ: PType): BiggestInt

computeSpan:

• mirtrees: computeSpan(tree: MirTree; n: NodePosition): Slice[NodePosition]

computeTypeName:

• mangling: computeTypeName(g: ModuleGraph; env: TypeEnv; typ: TypeId): string

compVerbosityDefault:

• CompilerVerbosity.compVerbosityDefault

compVerbosityHigh:

• CompilerVerbosity.compVerbosityHigh

compVerbosityMax:

• CompilerVerbosity.compVerbosityMax

compVerbosityMin:

• CompilerVerbosity.compVerbosityMin

ConcreteTypes:

• ast_query: ConcreteTypes

config:

• cgendata: config(m: BModule): ConfigRef
• cgendata: config(p: BProc): ConfigRef
• jsgen: config(p: PProc): ConfigRef
• semdata: config(c: PContext): ConfigRef

configComplete:

• modulegraphs: configComplete(g: ModuleGraph)

ConfigFileEvent:

• nimconf: ConfigFileEvent

ConfigFileEventKind:

• nimconf: ConfigFileEventKind

configMismatch:

• RodFileError.configMismatch

ConfigRef:

• options: ConfigRef

configSection:

• RodSection.configSection

configVars:

• options: configVars(conf`gensym70: ConfigRef): StringTableRef

configVars=:

• options: configVars=(conf`gensym70: ConfigRef; val`gensym70: StringTableRef)

configVarsDel:

• options: configVarsDel(conf`gensym69: ConfigRef; key`gensym69: string)

configVarsGet:

• options: configVarsGet(conf`gensym69: ConfigRef; key`gensym69: string): string

configVarsSet:

• options: configVarsSet(conf`gensym69: ConfigRef; key`gensym69: string; value`gensym69: string)

ConfNoteSet:

• in_options: ConfNoteSet

connectCallbacks:

• modules: connectCallbacks(graph: ModuleGraph)

ConsiderFlag:

• sighashes: ConsiderFlag

considerGenSyms:

• semdata: considerGenSyms(c: PContext; n: PNode)

considerQuotedIdent:

• lookups: considerQuotedIdent(c: PContext; n: PNode): PIdentResult

ConstantDataTypes:

• ast_query: ConstantDataTypes

ConstantId:

• vmdef: ConstantId

ConstantKind:

• vmdef: ConstantKind

constDataToMir:

• mirgen: constDataToMir(env: var MirEnv; n: PNode): MirTree
• vmjit: constDataToMir(c: var TCtx; jit: var JitState; e: PNode): MirTree

ConstId:

• mirtrees: ConstId

constParameters:

• Goal.constParameters

constPragmas:

• pragmas: constPragmas

ConstrTree:

• datatables: ConstrTree

ConstrTreeNodes:

• mirtrees: ConstrTreeNodes

consts:

• cgendata: consts(m: BModule): untyped

contains:

• options: contains(s: var ReportSet; id: NodeId): bool
• mirenv: contains[I, T](tab: SymbolTable[I, T]; s: PSym): bool
• btrees: contains[Key, Val](b: BTree[Key, Val]; key: Key): bool
• containers: contains[K, V](m: SeqMap[K, V]; key: K): bool

containsCompileTimeOnly:

• types: containsCompileTimeOnly(t: PType): bool

containsGarbageCollectedRef:

• types: containsGarbageCollectedRef(typ: PType): bool

containsGenericType:

• types: containsGenericType(t: PType): bool

containsHiddenPointer:

• types: containsHiddenPointer(typ: PType): bool

containsManagedMemory:

• types: containsManagedMemory(typ: PType): bool

containsNode:

• ast_query: containsNode(n: PNode; kinds: TNodeKinds): bool

containsObject:

• types: containsObject(t: PType): bool

containsSets:

• nimsets: containsSets(conf: ConfigRef; a, b: PNode): bool

containsTyRef:

• types: containsTyRef(typ: PType): bool

context:

• reports: context(report: Report): seq[ReportContext]

Context:

• mirconstr: Context

context=:

• reports: context=(report: var Report; context: seq[ReportContext])

converterPragmas:

• pragmas: converterPragmas

convertersSection:

• RodSection.convertersSection

CoOwnerSig:

• ConsiderFlag.CoOwnerSig

COpcode:

• ccgflow: COpcode

CoProc:

• ConsiderFlag.CoProc

copyFile:

• pathutils: copyFile(source, dest: AbsoluteFile)

copyIdTable:

• ast: copyIdTable(dest: var TIdTable; src: TIdTable)

copyInto:

• packed_ast: copyInto(dest, n, body)

copyIntoKind:

• packed_ast: copyIntoKind(dest, kind, info, body)

copyNode:

• ast: copyNode(src: PNode): PNode

copyNodeWithKids:

• ast: copyNodeWithKids(src: PNode): PNode

copyObjectSet:

• ast: copyObjectSet(dest: var TObjectSet; src: TObjectSet)

copyrightYear:

• options: copyrightYear

copyStrTable:

• ast: copyStrTable(dest: var TStrTable; src: TStrTable)

copySym:

• ast: copySym(s: PSym; id: ItemId): PSym

copyToLocation:

• vmobjects: copyToLocation(mm: var VmMemoryManager; dest: var VmMemoryRegion; src: VmMemoryRegion; typ: PVmType; reset: static[bool] = true)

copyTree:

• ast: copyTree(src: PNode): PNode
• packed_ast: copyTree(dest: var PackedTree; tree: PackedTree; n: NodePos)

copyTreeWithoutNode:

• ast: copyTreeWithoutNode(src, skippedNode: PNode): PNode

copyTreeWithoutNodes:

• ast: copyTreeWithoutNodes(src: PNode; skippedNodes: varargs[PNode]): PNode

copyType:

• ast: copyType(t: PType; id: ItemId; owner: PSym): PType

copyTypeProps:

• modulegraphs: copyTypeProps(g: ModuleGraph; module: int; dest, src: PType)

copyVmSeq:

• vmobjects: copyVmSeq(dest: var VmSeq; src: VmSeq; typ: PVmType; mm: var VmMemoryManager)

CoType:

• ConsiderFlag.CoType

count:

• mirtypes: count(desc: TypeHeader): uint32

countDefinedSymbols:

• options: countDefinedSymbols(conf: ConfigRef): int

cpExact:

• TCheckPointResult.cpExact

cpFuzzy:

• TCheckPointResult.cpFuzzy

cpNone:

• TCheckPointResult.cpNone

cppDefine:

• options: cppDefine(c: ConfigRef; define: string)

cppDefines:

• options: cppDefines(conf`gensym28: ConfigRef): HashSet[string]

cppDefines=:

• options: cppDefines=(conf`gensym28: ConfigRef; val`gensym28: HashSet[string])

cpsInit:

• TCProcSection.cpsInit

cpsLocals:

• TCProcSection.cpsLocals

cpsStmts:

• TCProcSection.cpsStmts

CPU:

• platform: CPU

cpuAlpha:

• TSystemCPU.cpuAlpha

cpuAmd64:

• TSystemCPU.cpuAmd64

cpuArm:

• TSystemCPU.cpuArm

cpuArm64:

• TSystemCPU.cpuArm64

cpuAVR:

• TSystemCPU.cpuAVR

cpuE2k:

• TSystemCPU.cpuE2k

cpuEsp:

• TSystemCPU.cpuEsp

cpuHppa:

• TSystemCPU.cpuHppa

cpuI386:

• TSystemCPU.cpuI386

cpuIa64:

• TSystemCPU.cpuIa64

cpuJS:

• TSystemCPU.cpuJS

cpuLoongArch64:

• TSystemCPU.cpuLoongArch64

cpuM68k:

• TSystemCPU.cpuM68k

cpuMips:

• TSystemCPU.cpuMips

cpuMips64:

• TSystemCPU.cpuMips64

cpuMips64el:

• TSystemCPU.cpuMips64el

cpuMipsel:

• TSystemCPU.cpuMipsel

cpuMSP430:

• TSystemCPU.cpuMSP430

cpuNimVM:

• TSystemCPU.cpuNimVM

cpuNone:

• TSystemCPU.cpuNone

cpuPowerpc:

• TSystemCPU.cpuPowerpc

cpuPowerpc64:

• TSystemCPU.cpuPowerpc64

cpuPowerpc64el:

• TSystemCPU.cpuPowerpc64el

cpuRiscV32:

• TSystemCPU.cpuRiscV32

cpuRiscV64:

• TSystemCPU.cpuRiscV64

cpuSparc:

• TSystemCPU.cpuSparc

cpuSparc64:

• TSystemCPU.cpuSparc64

cpuVm:

• TSystemCPU.cpuVm

cpuWasm32:

• TSystemCPU.cpuWasm32

CR:

• nimlexbase: CR

create:

• rodfiles: create(filename: string): RodFile

createBody:

• mirconstr: createBody(builder: sink MirBuilder; sm: sink SourceMap): MirBody

createDir:

• pathutils: createDir(x: AbsoluteDir)

createDocLink:

• lineinfos: createDocLink(urlSuffix: string): string

createMagic:

• modulegraphs: createMagic(g: ModuleGraph; idgen: IdGenerator; name: string; m: TMagic): PSym

createModuleAlias:

• ast: createModuleAlias(s: PSym; id: ItemId; newIdent: PIdent; info: TLineInfo; options: TOptions): PSym

createObj:

• lowerings: createObj(g: ModuleGraph; idgen: IdGenerator; owner: PSym; info: TLineInfo; final = true): PType

createSemIllformedAstMsg:

• msgs: createSemIllformedAstMsg(node: PNode; expected: set[TNodeKind]): string

createStackTrace:

• vm: createStackTrace(c: TCtx; thread: VmThread; recursionLimit: int = 100): VmStackTrace

createTypeBoundOps:

• liftdestructors: createTypeBoundOps(g: ModuleGraph; c: PContext; orig: PType; info: TLineInfo; idgen: IdGenerator)

createUndeclaredIdentifierError:

• lookups: createUndeclaredIdentifierError(c: PContext; n: PNode; name: string; candidates: seq[SemSpellCandidate] = @[]): PNode

csEmpty:

• TCandidateState.csEmpty

csMatch:

• TCandidateState.csMatch

csNoMatch:

• TCandidateState.csNoMatch

CstringType:

• mirtypes: CstringType

ctArray:

• TCTypeKind.ctArray

ctBool:

• TCTypeKind.ctBool

ctChar:

• TCTypeKind.ctChar

ctCString:

• TCTypeKind.ctCString

ctfeWhitelist:

• ast_types: ctfeWhitelist

ctFloat:

• TCTypeKind.ctFloat

ctFloat32:

• TCTypeKind.ctFloat32

ctFloat64:

• TCTypeKind.ctFloat64

ctInt:

• TCTypeKind.ctInt

ctInt16:

• TCTypeKind.ctInt16

ctInt32:

• TCTypeKind.ctInt32

ctInt64:

• TCTypeKind.ctInt64

ctInt8:

• TCTypeKind.ctInt8

ctNimOpenArray:

• TCTypeKind.ctNimOpenArray

ctNimSeq:

• TCTypeKind.ctNimSeq

ctNimStr:

• TCTypeKind.ctNimStr

ctProc:

• TCTypeKind.ctProc

ctPtr:

• TCTypeKind.ctPtr

ctPtrToArray:

• TCTypeKind.ctPtrToArray

ctStruct:

• TCTypeKind.ctStruct

ctUInt:

• TCTypeKind.ctUInt

ctUInt16:

• TCTypeKind.ctUInt16

ctUInt32:

• TCTypeKind.ctUInt32

ctUInt64:

• TCTypeKind.ctUInt64

ctUInt8:

• TCTypeKind.ctUInt8

ctVoid:

• TCTypeKind.ctVoid

CurrentConf:

• in_options: CurrentConf

currentException:

• vmdef: currentException(a: VmArgs): HeapSlotHandle

currentException=:

• vmdef: currentException=(a: VmArgs; h: HeapSlotHandle)

Cursor:

• cursors: Cursor

cursor:

• cursors: cursor[T](x: T): untyped

cursorInference:

• Goal.cursorInference

customizeForBackend:

• main: customizeForBackend(graph: ModuleGraph; conf: ConfigRef; backend: TBackend)

cyclicTree:

• trees: cyclicTree(n: PNode): bool

cyclicType:

• liftdestructors: cyclicType(t: PType; g: ModuleGraph): bool

data:

• vmdef: data(s: VmString): CellPtr

DataEncoder:

• packed_env: DataEncoder

DataFlowGraph:

• mirexec: DataFlowGraph

dataFor:

• mirenv: dataFor(env: MirEnv; id: ConstId): DataId

DataId:

• mirtrees: DataId

DataTable:

• datatables: DataTable

dcEq:

• TDistinctCompare.dcEq

dcEqIgnoreDistinct:

• TDistinctCompare.dcEqIgnoreDistinct

dcEqOrDistinctOf:

• TDistinctCompare.dcEqOrDistinctOf

dealloc:

• vmmemory: dealloc(a: var VmAllocator; c: CellId)
• vmmemory: dealloc(a: var VmAllocator; p: CellPtr)
• vmmemory: dealloc(a: var VmAllocator; handle: LocHandle)

debug:

• ic: debug(tree: PackedTree; m: PackedModule)
• astrepr: debug(conf: ConfigRef; it: Debugable)
• astrepr: debug(conf: ConfigRef; it: Debugable; tconf: TReprConf)
• astrepr: debug(it: Debugable; tconf: TReprConf)
• astrepr: debug(it: ParsedNode)
• astrepr: debug(it: PIdent)
• astrepr: debug(it: PNode)
• astrepr: debug(it: PSym)
• astrepr: debug(it: PType)

debugAst:

• astrepr: debugAst(it: PNode)

DebugCallableCandidate:

• debugutils: DebugCallableCandidate

debugOps:

• vmops: debugOps(): Override

debugParsedAst:

• astrepr: debugParsedAst(it: ParsedNode)

DebugReport:

• reports_debug: DebugReport

DebugReportBase:

• reports_base: DebugReportBase

DebugReportKind:

• report_enums: DebugReportKind

debugScopes:

• lookups: debugScopes(c: PContext; limit = 0; max = int.high)

DebugSemStep:

• debugutils: DebugSemStep

DebugSemStepDirection:

• debugutils: DebugSemStepDirection

DebugSemStepKind:

• debugutils: DebugSemStepKind

debugSym:

• astrepr: debugSym(it: PSym)

debugType:

• astrepr: debugType(it: PType)

DebugVmCodeEntry:

• vmutils: DebugVmCodeEntry

dec:

• mirtrees: dec(a: var NodePosition)

declarativeDefs:

• ast_query: declarativeDefs

declarePureEnumField:

• importer: declarePureEnumField(c: PContext; s: PSym)

declareThreadVar:

• cgen: declareThreadVar(m: BModule; id: GlobalId; isExtern: bool)

decodeStr:

• rodutils: decodeStr(s: cstring; pos: var int): string

decodeStrArray:

• rodutils: decodeStrArray(s: cstring): string

decodeVBiggestInt:

• rodutils: decodeVBiggestInt(s: cstring; pos: var int): BiggestInt

decodeVInt:

• rodutils: decodeVInt(s: cstring; pos: var int): int

decodeVIntArray:

• rodutils: decodeVIntArray(s: cstring): int

deduplicate:

• nimsets: deduplicate(conf: ConfigRef; a: PNode): PNode

defaultAlignment:

• ast_query: defaultAlignment

DefaultConfig:

• options: DefaultConfig

DefaultConfigNims:

• options: DefaultConfigNims

DefaultGlobalOptions:

• options: DefaultGlobalOptions

defaultOffset:

• ast_query: defaultOffset

DefaultOptions:

• options: DefaultOptions

defaultParamSeparator:

• typesrenderer: defaultParamSeparator

defaultSize:

• ast_query: defaultSize

defaultTReprConf:

• astrepr: defaultTReprConf

definedSymbolNames:

• options: definedSymbolNames(conf: ConfigRef): string

defineGlobal:

• jsgen: defineGlobal(globals: PGlobals; m: BModule; id: GlobalId)

defineGlobalVar:

• cgen: defineGlobalVar(m: BModule; id: GlobalId)

defineSymbol:

• options: defineSymbol(conf: ConfigRef; symbol: string; value: string = "true")

defNameErrorNodeAllowsSymUpdate:

• sem: defNameErrorNodeAllowsSymUpdate(n: PNode): bool

DefNodes:

• mirtrees: DefNodes

delSon:

• ast: delSon(father: PNode; idx: int)

demanglePackageName:

• options: demanglePackageName(path: string): string

depfile:

• options: depfile(conf`gensym37: ConfigRef): AbsoluteFile

depfile=:

• options: depfile=(conf`gensym37: ConfigRef; val`gensym37: AbsoluteFile)

deps:

• backends: deps(tree: MirTree): lent MirNode

depsSection:

• RodSection.depsSection

deref:

• vmmemory: deref(handle: LocHandle): ptr Atom

DerefFailureCode:

• vmmemory: DerefFailureCode

deserialize:

• vmcompilerserdes: deserialize(c: TCtx; handle: LocHandle; asType: PType; info: TLineInfo): PNode

deserializeArray:

• vmcompilerserdes: deserializeArray(c: TCtx; m: VmMemoryRegion; count: int; stride: int; eTyp: PVmType; f: PType; info: TLineInfo): PNode

deserializeNimNode:

• vmcompilerserdes: deserializeNimNode(c: TCtx; n: PNode; formal: PType; info: TLineInfo): PNode

deserializeRef:

• vmcompilerserdes: deserializeRef(c: TCtx; slot: HeapSlotHandle; vt: PVmType; f, con: PType; info: TLineInfo): PNode

destructor:

• Feature.destructor
• liftdestructors: destructor(t: PType): PSym

detailedInfo:

• ast_query: detailedInfo(sym: PSym): string

dfcFreed:

• DerefFailureCode.dfcFreed

dfcInvalid:

• DerefFailureCode.dfcInvalid

dfcNil:

• DerefFailureCode.dfcNil

dfcTypeMismatch:

• DerefFailureCode.dfcTypeMismatch

diagOffset:

• lexer: diagOffset(L: Lexer): int

diagToHumanStr:

• lexer: diagToHumanStr(d: LexerDiag): string

diffSets:

• nimsets: diffSets(conf: ConfigRef; a, b: PNode): PNode

directIntLit:

• packed_ast: directIntLit

directViewType:

• types: directViewType(t: PType): ViewTypeKind

dirExists:

• pathutils: dirExists(x: AbsoluteDir): bool

disabledSf:

• SymbolFilesOption.disabledSf

disableNimblePath:

• options: disableNimblePath(conf: ConfigRef)

discardSons:

• ast: discardSons(father: PNode)

discover:

• backends: discover(env: var MirEnv; progress: EnvCheckpoint): tuple[s: PSym, n: MirNode]

discoverFrom:

• backends: discoverFrom(env: var MirEnv; decl: PNode)

DiscoveryData:

• backends: DiscoveryData

discr:

• mirtypes: discr(desc: TypeHeader; env: TypeEnv): FieldId

dispatcherPos:

• ast_query: dispatcherPos

dispatchers:

• cgmeth: dispatchers(g: ModuleGraph): PSym

dispose:

• vm: dispose(c: var TCtx; t: sink VmThread)

divMod:

• int128: divMod(dividend, divisor: Int128): tuple[quotient, remainder: Int128]

dllOverrides:

• options: dllOverrides(conf`gensym68: ConfigRef): StringTableRef

dllOverrides=:

• options: dllOverrides=(conf`gensym68: ConfigRef; val`gensym68: StringTableRef)

dllOverridesDel:

• options: dllOverridesDel(conf`gensym67: ConfigRef; key`gensym67: string)

dllOverridesGet:

• options: dllOverridesGet(conf`gensym67: ConfigRef; key`gensym67: string): string

dllOverridesSet:

• options: dllOverridesSet(conf`gensym67: ConfigRef; key`gensym67: string; value`gensym67: string)

doAbort:

• TErrorHandling.doAbort

DocConfig:

• options: DocConfig

docCss:

• nimpaths: docCss

docgen2JsonPass:

• docgen2: docgen2JsonPass

docgen2Pass:

• docgen2: docgen2Pass

docgen2TexPass:

• docgen2: docgen2TexPass

docHackJs:

• nimpaths: docHackJs

docHackJsFname:

• nimpaths: docHackJsFname

docHackNim:

• nimpaths: docHackNim

docRootDefault:

• options: docRootDefault

DocTexConfig:

• options: DocTexConfig

documentRaises:

• docgen: documentRaises(cache: IdentCache; n: PNode)

doDefault:

• TErrorHandling.doDefault

doesGlobalEscape:

• analysis: doesGlobalEscape(tree: MirTree; scope: Subgraph; start: InstrPos; s: GlobalId): bool

doesImply:

• guards: doesImply(facts: TModel; prop: PNode): TImplication

doInternalAssert:

• msgs: doInternalAssert(conf: ConfigRef; instLoc: InstantiationInfo; msg: string; info = unknownLineInfo)

doInternalUnreachable:

• msgs: doInternalUnreachable(conf: ConfigRef; info: TLineInfo; msg: string; instLoc: InstantiationInfo)

doNothing:

• TErrorHandling.doNothing

dontInlineConstant:

• trees: dontInlineConstant(orig, cnst: PNode): bool

doRaise:

• TErrorHandling.doRaise

dotdotMangle:

• nimpaths: dotdotMangle

dotOperators:

• Feature.dotOperators

dump:

• vmprofiler: dump(conf: ConfigRef; prof: Profiler): string

dumpVmProfilerData:

• compilerbridge: dumpVmProfilerData(graph: ModuleGraph): string

eachCategory:

• reports: eachCategory(report: Report; field: untyped): untyped

earlyExit:

• mirgen_blocks: earlyExit(c; bu)

ecfExplicit:

• ExecutionConFlag.ecfExplicit

ecfStatic:

• ExecutionConFlag.ecfStatic

echoInput:

• mirbridge: echoInput(config: ConfigRef; owner: PSym; body: PNode)

echoMir:

• mirbridge: echoMir(config: ConfigRef; owner: PSym; body: MirBody; env: MirEnv)

echoOutput:

• mirbridge: echoOutput(config: ConfigRef; owner: PSym; body: Body)
• mirbridge: echoOutput(config: ConfigRef; owner: PSym; body: MirBody; env: MirEnv)

efAllowStmt:

• TExprFlag.efAllowStmt

efCompat:

• EffectsCompat.efCompat

efEffectsDelayed:

• EffectsCompat.efEffectsDelayed

efExplain:

• TExprFlag.efExplain

effect:

• mirtrees: effect(tree: MirTree; n: NodePosition): EffectKind

EffectKind:

• mirtrees: EffectKind

effectListLen:

• ast_types: effectListLen

EffectsCompat:

• ast_types: EffectsCompat

effectSpec:

• trees: effectSpec(n: PNode; effectType: TSpecialWord): PNode

efFromHlo:

• TExprFlag.efFromHlo

efInCall:

• TExprFlag.efInCall

efInTypeof:

• TExprFlag.efInTypeof

efLockLevelsDiffer:

• EffectsCompat.efLockLevelsDiffer

efLValue:

• TExprFlag.efLValue

efNoEvaluateGeneric:

• TExprFlag.efNoEvaluateGeneric

efNoSem2Check:

• TExprFlag.efNoSem2Check

efNoSemCheck:

• TExprFlag.efNoSemCheck

efNoUndeclared:

• TExprFlag.efNoUndeclared

efOperand:

• TExprFlag.efOperand

efRaisesDiffer:

• EffectsCompat.efRaisesDiffer

efRaisesUnknown:

• EffectsCompat.efRaisesUnknown

efTagsDiffer:

• EffectsCompat.efTagsDiffer

efTagsUnknown:

• EffectsCompat.efTagsUnknown

efWantIterator:

• TExprFlag.efWantIterator

efWantStmt:

• TExprFlag.efWantStmt

efWantValue:

• TExprFlag.efWantValue

EhInstr:

• vmdef: EhInstr

ehoEnd:

• EhOpcode.ehoEnd

ehoExcept:

• EhOpcode.ehoExcept

ehoExceptWithFilter:

• EhOpcode.ehoExceptWithFilter

ehoFinally:

• EhOpcode.ehoFinally

ehoLeave:

• EhOpcode.ehoLeave

ehoNext:

• EhOpcode.ehoNext

EhOpcode:

• vmdef: EhOpcode

ekInvalidate:

• EffectKind.ekInvalidate

ekKill:

• EffectKind.ekKill

ekMutate:

• EffectKind.ekMutate

ekNone:

• EffectKind.ekNone

ekReassign:

• EffectKind.ekReassign

ElaborateAst:

• checked_ast: ElaborateAst

elem:

• mirtypes: elem(desc: TypeHeader): TypeId

ElemSize:

• bitsets: ElemSize

elemType:

• types: elemType(t: PType): PType
• vmtypes: elemType(typ: PVmType): PVmType

eliminateUnreachable:

• unreachable_elim: eliminateUnreachable(graph: ModuleGraph; n: PNode): PNode

emConst:

• TEvalMode.emConst

emitByName:

• mirconstr: emitByName(bu: var MirBuilder; val: Value; e: EffectKind)
• mirconstr: emitByName(bu: var MirBuilder; e: EffectKind; body: untyped)

emitByVal:

• mirconstr: emitByVal(bu: var MirBuilder; y: Value)

emitFrom:

• mirconstr: emitFrom(bu: var MirBuilder; tree: MirTree; n: NodePosition)

emOptimize:

• TEvalMode.emOptimize

emptyNodeId:

• packed_ast: emptyNodeId

emptyRange:

• nimsets: emptyRange(a, b: PNode): bool

emRepl:

• TEvalMode.emRepl

emStandalone:

• TEvalMode.emStandalone

emStaticExpr:

• TEvalMode.emStaticExpr

emStaticStmt:

• TEvalMode.emStaticStmt

emulatedThreadVars:

• cgen: emulatedThreadVars(conf: ConfigRef): bool

encode:

• sourcemap: encode(i: int): string

encoder:

• semdata: encoder(c): untyped

encodeStr:

• rodutils: encodeStr(s: string; result: var string)

encodeVBiggestInt:

• rodutils: encodeVBiggestInt(x: BiggestInt; result: var string)

encodeVInt:

• rodutils: encodeVInt(x: int; result: var string)

EndianToStr:

• platform: EndianToStr

EndOfFile:

• nimlexbase: EndOfFile

endsInNoReturn:

• ast_query: endsInNoReturn(n: PNode): bool

endsWith:

• llstream: endsWith(x: string; s: set[char]): bool

endsWithOpr:

• llstream: endsWithOpr(x: string): bool

ensureEnvParam:

• lambdalifting: ensureEnvParam(graph: ModuleGraph; idgen: IdGenerator; prc: PSym)

ensureKind:

• vm: ensureKind(n: var TFullReg; k: TRegisterKind; mm: var VmMemoryManager)

enter:

• vmprofiler: enter(prof: var Profiler)

entityDefs:

• ast_query: entityDefs

enumFieldPragmas:

• pragmas: enumFieldPragmas

enumHasHoles:

• types: enumHasHoles(t: PType): bool

enumToStringProcsSection:

• RodSection.enumToStringProcsSection

env:

• cgendata: env(p: BProc): untyped
• jsgen: env(p: PProc): untyped
• vmjit: env(jit: JitState): lent MirEnv

EnvCheckpoint:

• mirenv: EnvCheckpoint

envName:

• lambdalifting: envName

eqTypeFlags:

• ast_types: eqTypeFlags

equalParams:

• types: equalParams(a, b: PNode): TParamsEquality

equalSets:

• nimsets: equalSets(conf: ConfigRef; a, b: PNode): bool

equalsFile:

• ropes: equalsFile(r: Rope; filename: AbsoluteFile): bool
• ropes: equalsFile(s: Rope; f: File): bool

eraseVoidParams:

• semtypinst: eraseVoidParams(t: PType)

ERecoverableError:

• lineinfos: ERecoverableError

errorHandling:

• errorreporting: errorHandling(err: PNode): TErrorHandling

errorKind:

• errorhandling: errorKind(e: PNode): AstDiagKind

errorKindPos:

• ast_query: errorKindPos

errorNode:

• semdata: errorNode(c: PContext; n: PNode): PNode

errorReportToString:

• vmdeps: errorReportToString(c: ConfigRef; error: Report): string

errorsHintsAndWarnings:

• lexer: errorsHintsAndWarnings(L: Lexer; diagOffset = 0): LexerDiag

errorSubNode:

• errorhandling: errorSubNode(n: PNode): PNode

errorSym:

• lookups: errorSym(c: PContext; n, err: PNode): PSym

errorType:

• semdata: errorType(c: PContext): PType
• semfold: errorType(g: ModuleGraph): PType

errorUndeclaredIdentifier:

• lookups: errorUndeclaredIdentifier(c: PContext; info: TLineInfo; name: string; candidates: seq[SemSpellCandidate] = @[])

errorUndeclaredIdentifierHint:

• lookups: errorUndeclaredIdentifierHint(c: PContext; n: PNode; ident: PIdent): PSym

errorUndeclaredIdentifierWithHint:

• lookups: errorUndeclaredIdentifierWithHint(c: PContext; n: PNode; name: string; candidates: seq[SemSpellCandidate] = @[]): PSym

errorUseQualifier:

• lookups: errorUseQualifier(c: PContext; n: PNode; s: PSym): PSym

ESC:

• nimlexbase: ESC

eStdErr:

• TErrorOutput.eStdErr

eStdOut:

• TErrorOutput.eStdOut

ESuggestDone:

• lineinfos: ESuggestDone

evalConstExpr:

• compilerbridge: evalConstExpr(module: PSym; idgen: IdGenerator; g: ModuleGraph; e: PNode): PNode

EvalContext:

• compilerbridge: EvalContext

evalFrom:

• importer: evalFrom(c: PContext; n: PNode): PNode

evalImport:

• importer: evalImport(c: PContext; n: PNode): PNode

evalImportExcept:

• importer: evalImportExcept(c: PContext; n: PNode): PNode

evalMacroCall:

• compilerbridge: evalMacroCall(jit: var JitState; c: var TCtx; call, args: PNode; sym: PSym): PNode
• compilerbridge: evalMacroCall(module: PSym; idgen: IdGenerator; g: ModuleGraph; templInstCounter: ref int; call, args: PNode; sym: PSym): PNode

evalOnce:

• lowerings: evalOnce(g: ModuleGraph; value: PNode; idgen: IdGenerator; owner: PSym): PNode

evalOp:

• semfold: evalOp(m: TMagic; n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): PNode

evalPass:

• compilerbridge: evalPass

evalStaticExpr:

• compilerbridge: evalStaticExpr(module: PSym; idgen: IdGenerator; g: ModuleGraph; e: PNode; prc: PSym): PNode

evalStaticStmt:

• compilerbridge: evalStaticStmt(module: PSym; idgen: IdGenerator; g: ModuleGraph; e: PNode; prc: PSym): PNode

evalTemplate:

• evaltempl: evalTemplate(n: PNode; tmpl, genSymOwner: PSym; conf: ConfigRef; ic: IdentCache; instID: ref int; idgen: IdGenerator; fromHlo = false): PNode

evalTemplateArgs:

• evaltempl: evalTemplateArgs(n: PNode; s: PSym; conf: ConfigRef; fromHlo: bool): PNode

evalTemplateLimit:

• evaltempl: evalTemplateLimit

ExactConstraints:

• TTypeCmpFlag.ExactConstraints

ExactGcSafety:

• TTypeCmpFlag.ExactGcSafety

ExactGenericParams:

• TTypeCmpFlag.ExactGenericParams

exactReplica:

• ast: exactReplica(t: PType): PType

ExactTypeDescValues:

• TTypeCmpFlag.ExactTypeDescValues

exc:

• options: exc(conf`gensym31: ConfigRef): ExceptionSystem

exc=:

• options: exc=(conf`gensym31: ConfigRef; val`gensym31: ExceptionSystem)

exceptionEffects:

• ast_types: exceptionEffects

ExceptionSystem:

• in_options: ExceptionSystem

excGoto:

• ExceptionSystem.excGoto

excl:

• options: excl(conf: ConfigRef; nset: ConfNoteSet; note: ReportKind)
• options: excl(conf`gensym61: ConfigRef; item`gensym61: TOption | TOptions)
• options: excl(conf`gensym63: ConfigRef; item`gensym63: TGlobalOption | TGlobalOptions)
• options: excl(conf`gensym65: ConfigRef; item`gensym65: Feature | set[Feature])
• astrepr: excl(conf: var TReprConf; flag: TReprFlag | set[TReprFlag])

excNative:

• ExceptionSystem.excNative

excNone:

• ExceptionSystem.excNone

execCon:

• semdata: execCon(c: PContext): ExecutionCon

ExecErrorKind:

• compilerbridge: ExecErrorKind

execErrorQuit:

• ExecErrorKind.execErrorQuit

ExecErrorReport:

• compilerbridge: ExecErrorReport

execErrorVm:

• ExecErrorKind.execErrorVm

execErrorVmGen:

• ExecErrorKind.execErrorVmGen

execExternalProgramFailedMsg:

• main: execExternalProgramFailedMsg(cmd: string; exitCode: int): string

execProc:

• compilerbridge: execProc(jit: var JitState; c: var TCtx; sym: PSym; args: openArray[PNode]): PNode

execute:

• vm: execute(c: var TCtx; thread: var VmThread): YieldReason

executeCmd:

• suggest: executeCmd(cmd: IdeCmd; file, dirtyfile: AbsoluteFile; line, col: int; graph: ModuleGraph)

ExecutionCon:

• semdata: ExecutionCon

ExecutionConFlag:

• semdata: ExecutionConFlag

ExecutionResult:

• compilerbridge: ExecutionResult

exfDynamicLib:

• ExternalFlag.exfDynamicLib

exfExportLib:

• ExternalFlag.exfExportLib

exfFullExternalName:

• ExternalFlag.exfFullExternalName

exfHeader:

• ExternalFlag.exfHeader

exfImportCompilerProc:

• ExternalFlag.exfImportCompilerProc

exfNoDecl:

• ExternalFlag.exfNoDecl

existsConfigVar:

• options: existsConfigVar(conf: ConfigRef; key: string): bool

ExitLabel:

• ccgflow: ExitLabel

experimentalFeatures:

• in_options: experimentalFeatures

explanationsBaseUrl:

• lineinfos: explanationsBaseUrl

ExportableSymKinds:

• ast_types: ExportableSymKinds

exportsSection:

• RodSection.exportsSection

exportSym:

• semdata: exportSym(c: PContext; s: PSym)

ExprKind:

• proto_mir: ExprKind

ExprKinds:

• mirtrees: ExprKinds

exprPragmas:

• pragmas: exprPragmas

exprRoot:

• parampatterns: exprRoot(n: PNode): PSym

exprStructuralEquivalent:

• trees: exprStructuralEquivalent(a, b: PNode): bool

exprStructuralEquivalentStrictSym:

• trees: exprStructuralEquivalentStrictSym(a, b: PNode): bool

exprStructuralEquivalentStrictSymAndComm:

• trees: exprStructuralEquivalentStrictSymAndComm(a, b: PNode): bool

exprToMir:

• mirgen: exprToMir(graph: ModuleGraph; env: var MirEnv; config: TranslationConfig; e: PNode): MirBody

exprToPmir:

• proto_mir: exprToPmir(options: TOptions; config: ConfigRef; pickVm: bool; n: PNode; sink, mutable: bool): seq[ProtoItem]

exprToStr:

• utils: exprToStr(tree: MirTree; n: NodePosition; env: ptr MirEnv = nil; body: ptr MirBody = nil): string

ExternalFlag:

• ast_types: ExternalFlag

ExternalFlags:

• ast_types: ExternalFlags

externalObjFile:

• extccomp: externalObjFile(conf: ConfigRef; cfile: AbsoluteFile): AbsoluteFile

ExternalReport:

• reports_external: ExternalReport

ExternalReportKind:

• report_enums: ExternalReportKind

externIntLit:

• packed_ast: externIntLit

externSIntLit:

• packed_ast: externSIntLit

externUIntLit:

• packed_ast: externUIntLit

extract:

• checked_ast: extract(c: ConfigRef; n: sink CheckedAst): PNode
• checked_ast: extract(c: ConfigRef; n: sink ElaborateAst): PNode
• mirtrees: extract(id: ConstId): DataId

extractFilename:

• pathutils: extractFilename(x: AbsoluteFile): string

extractGlobals:

• transf: extractGlobals(body: PNode; output: var seq[PNode]; isNimVm: bool)

extractRange:

• trees: extractRange(k: TNodeKind; n: PNode; a, b: int): PNode

extractRunnableExamplesSource:

• renderverbatim: extractRunnableExamplesSource(conf: ConfigRef; n: PNode; indent = 0): string

FailureCodeToEvent:

• vmmemory: FailureCodeToEvent

FakeVarParams:

• ast_query: FakeVarParams

fastLog2:

• int128: fastLog2(a: Int128): int

fatalReport:

• msgs: fatalReport(conf: ConfigRef; info: TLineInfo; report: ReportTypes)

Feature:

• in_options: Feature

features:

• options: features(conf`gensym66: ConfigRef): set[Feature]

features=:

• options: features=(conf`gensym66: ConfigRef; val`gensym66: set[Feature])

FF:

• nimlexbase: FF

field:

• mirtrees: field(tree: MirTree; n: NodePosition): int32

fieldAt:

• vmdef: fieldAt(x: PVmType; i: FieldIndex): untyped
• vmdef: fieldAt(x: VmType; i: FieldIndex): untyped

FieldId:

• mirtypes: FieldId

FieldIndex:

• vmdef: FieldIndex

fieldOffset:

• mirtypes: fieldOffset(desc: TypeHeader; env: TypeEnv): int32

FieldPosition:

• vmdef: FieldPosition

fieldPragmas:

• pragmas: fieldPragmas

fields:

• cgendata: fields(m: BModule): untyped
• mirtypes: fields(env: TypeEnv; desc: TypeHeader; offset = 0): (FieldId, RecField)

fieldVisible:

• lookups: fieldVisible(c: PContext; f: PSym): bool

fileExists:

• pathutils: fileExists(x: AbsoluteFile): bool

fileIdx:

• ast_query: fileIdx(c: PSym): FileIndex

FileIndex:

• lineinfos: FileIndex

fileInfoIdx:

• options: fileInfoIdx(conf: ConfigRef; filename: AbsoluteFile): FileIndex
• options: fileInfoIdx(conf: ConfigRef; filename: AbsoluteFile; isKnownFile: var bool): FileIndex

fileInfoKnown:

• options: fileInfoKnown(conf: ConfigRef; filename: AbsoluteFile): bool

filename:

• ast_query: filename(c: PSym): string
• semdata: filename(c: PContext): string

FilenameOption:

• in_options: FilenameOption

filenameOption:

• options: filenameOption(conf`gensym33: ConfigRef): FilenameOption

filenameOption=:

• options: filenameOption=(conf`gensym33: ConfigRef; val`gensym33: FilenameOption)

fillGlobalLoc:

• cgen: fillGlobalLoc(m: BModule; id: GlobalId)

fillProcEntry:

• vmaux: fillProcEntry(e: var FuncTableEntry; info: CodeInfo)

fillProcLoc:

• cgen: fillProcLoc(m: BModule; id: ProcedureId)

fillTypeS:

• semdata: fillTypeS(dest: PType; kind: TTypeKind; c: PContext)

filterReplace:

• filters: filterReplace(conf: ConfigRef; stdin: PLLStream; filename: AbsoluteFile; call: PNode): PLLStream

filterStrip:

• filters: filterStrip(conf: ConfigRef; stdin: PLLStream; filename: AbsoluteFile; call: PNode): PLLStream

filterTmpl:

• filter_tmpl: filterTmpl(conf: ConfigRef; stdin: PLLStream; filename: AbsoluteFile; call: PNode): PLLStream

finalizeMainModule:

• cgen: finalizeMainModule(m: BModule)

finalizeModule:

• cgen: finalizeModule(m: BModule)

FinallyInfo:

• ccgflow: FinallyInfo

finalTarget:

• jsflow: finalTarget(n: CgNode): CgNode

find:

• mirexec: find(dfg: DataFlowGraph; n: NodePosition): InstrPos

findBlock:

• mirgen_blocks: findBlock(c: BlockCtx; label: PSym): int

findDef:

• mirtrees: findDef(tree: MirTree; n: NodePosition): NodePosition

findDiscrBranchEntry:

• vmtypes: findDiscrBranchEntry(t: PVmType; idx: FieldIndex): uint32

findFile:

• options: findFile(conf: ConfigRef; f: string; suppressStdlib = false): AbsoluteFile

findMatchingBranch:

• vmaux: findMatchingBranch(recCase: PNode; val: Int128): int

findModule:

• options: findModule(conf: ConfigRef; modulename, currentModule: string): AbsoluteFile

findNodeJs:

• nodejs: findNodeJs(): string

findParent:

• mirtrees: findParent(tree: MirTree; start: NodePosition; kind: MirNodeKind): NodePosition

findPragma:

• trees: findPragma(n: PNode; which: TSpecialWord): PNode

findProjectNimFile:

• options: findProjectNimFile(conf: ConfigRef; pkg: string): string

findRecCase:

• vmaux: findRecCase(t: PType; d: PSym): PNode

findStr:

• wordrecg: findStr[T: enum](values: set[T]; s: string; default: T): T
• wordrecg: findStr[T: enum](a, b: static[T]; s: string; default: T): T

findTrackedSym:

• suggest: findTrackedSym(g: ModuleGraph): PSym

findUnresolvedStatic:

• ast_query: findUnresolvedStatic(n: PNode): PNode

finish:

• mirconstr: finish(bu: var MirBuilder; saved: Context)
• mirconstr: finish(bu: sink MirBuilder): auto
• mirconstr: finish(bu: sink MirBuilder; locals: sink Store[LocalId, Local]): auto

finishClosureIterator:

• lambdalifting: finishClosureIterator(g: ModuleGraph; idgen: IdGenerator; iter: PSym)

finishDoc2Pass:

• docgen2: finishDoc2Pass(project: string)

finishGenerateDoc:

• docgen: finishGenerateDoc(d: var PDoc)

finishProc:

• cgen: finishProc(p: BProc; id: ProcedureId): string
• jsgen: finishProc(p: PProc): string

firstABxInstr:

• vm_enums: firstABxInstr

firstArgPos:

• ast_query: firstArgPos

FirstCallConv:

• pragmas: FirstCallConv

firstFloat:

• types: firstFloat(t: PType): BiggestFloat

firstIdentExcluding:

• astalgo: firstIdentExcluding(ti: var TIdentIter; tab: TStrTable; s: PIdent; excluding: IntSet): PSym

firstOrd:

• types: firstOrd(conf: ConfigRef; t: PType): Int128

firstSon:

• packed_ast: firstSon(n: NodePos): NodePos
• packed_ast: firstSon(tree: PackedTree; n: NodePos): NodePos

fixSpelling:

• lookups: fixSpelling(c: PContext; ident: PIdent): seq[SemSpellCandidate]

flags:

• packed_ast: flags(n: NodePos): TNodeFlags

flattenExpr:

• trees: flattenExpr(expr: PNode; stmts: var seq[PNode]): PNode

flattenIf:

• checked_ast: flattenIf(n: var CheckedAst; kind: TNodeKind)

flattenStmts:

• trees: flattenStmts(n: PNode): PNode

flip:

• in_options: flip[I](s: var set[I]; it: I; val: bool)
• options: flip(conf: ConfigRef; nset: ConfNoteSet; note: ReportKind; state: bool)

Float32Type:

• mirtypes: Float32Type

Float64Type:

• mirtypes: Float64Type

floatInt64Align:

• options: floatInt64Align(conf: ConfigRef): int16

FloatLike:

• OrdinalType.FloatLike

floatRangeCheck:

• types: floatRangeCheck(x: BiggestFloat; t: PType): bool

flushDot:

• msgs: flushDot(conf: ConfigRef)

foAbs:

• FilenameOption.foAbs

foCanonical:

• FilenameOption.foCanonical

foldAlignOf:

• types: foldAlignOf(conf: ConfigRef; n: PNode; fallback: PNode): PNode

foldInAst:

• semfold: foldInAst(m: PSym; n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode

foldOffsetOf:

• types: foldOffsetOf(conf: ConfigRef; n: PNode; fallback: PNode): PNode

foldSizeOf:

• types: foldSizeOf(conf: ConfigRef; n: PNode; fallback: PNode): PNode

foLegacyRelProj:

• FilenameOption.foLegacyRelProj

foName:

• FilenameOption.foName

foreignPackageNotes:

• options: foreignPackageNotes(conf: ConfigRef): ReportKinds

foreignPackageNotes=:

• options: foreignPackageNotes=(conf: ConfigRef; nset: ReportKinds)

foRelProject:

• FilenameOption.foRelProject

fork:

• containers: fork[I; T](s: Store[I, T]): PartialStore[I, T]

forLoopDefs:

• ast_query: forLoopDefs(forStmt: PNode): PNode

formalType:

• reports: formalType(r: SemReport): PType

formalTypeKind:

• reports: formalTypeKind(r: SemReport): set[TTypeKind]

formatPath:

• msgs: formatPath(conf: ConfigRef; path: string): string

FormatStr:

• ropes: FormatStr

formatTrace:

• cli_reporter: formatTrace(conf: ConfigRef; trace: seq[StackTraceEntry]): string

forVarPragmas:

• pragmas: forVarPragmas

foStacktrace:

• FilenameOption.foStacktrace

fpos:

• vmdef: fpos(x: int): FieldPosition

Fragment:

• mirconstr: Fragment

frameDeclared:

• CodegenFlag.frameDeclared

frameMsg:

• debugutils: frameMsg(c: ConfigRef; n: PNode)
• debugutils: frameMsg(c: ConfigRef; info: TLineInfo)

frEmbedded:

• TTypeFieldResult.frEmbedded

freshVarForClosureIter:

• lambdalifting: freshVarForClosureIter(g: ModuleGraph; s: PSym; idgen: IdGenerator; owner: PSym): PNode

frHeader:

• TTypeFieldResult.frHeader

frNone:

• TTypeFieldResult.frNone

fromSystem:

• astalgo: fromSystem(op: PSym): bool

FullId:

• modulegraphs: FullId

fullSwitchShowIr:

• CmdSwitchTextKind.fullSwitchShowIr

fullSwitchTxtApp:

• CmdSwitchTextKind.fullSwitchTxtApp

fullSwitchTxtAsm:

• CmdSwitchTextKind.fullSwitchTxtAsm

fullSwitchTxtAssertions:

• CmdSwitchTextKind.fullSwitchTxtAssertions

fullSwitchTxtBackend:

• CmdSwitchTextKind.fullSwitchTxtBackend

fullSwitchTxtBenchmarkvm:

• CmdSwitchTextKind.fullSwitchTxtBenchmarkvm

fullSwitchTxtBoundchecks:

• CmdSwitchTextKind.fullSwitchTxtBoundchecks

fullSwitchTxtCc:

• CmdSwitchTextKind.fullSwitchTxtCc

fullSwitchTxtChecks:

• CmdSwitchTextKind.fullSwitchTxtChecks

fullSwitchTxtCincludes:

• CmdSwitchTextKind.fullSwitchTxtCincludes

fullSwitchTxtClearnimblepath:

• CmdSwitchTextKind.fullSwitchTxtClearnimblepath

fullSwitchTxtClib:

• CmdSwitchTextKind.fullSwitchTxtClib

fullSwitchTxtClibdir:

• CmdSwitchTextKind.fullSwitchTxtClibdir

fullSwitchTxtCmdexitgcstats:

• CmdSwitchTextKind.fullSwitchTxtCmdexitgcstats

fullSwitchTxtColors:

• CmdSwitchTextKind.fullSwitchTxtColors

fullSwitchTxtCompile:

• CmdSwitchTextKind.fullSwitchTxtCompile

fullSwitchTxtCompileonly:

• CmdSwitchTextKind.fullSwitchTxtCompileonly

fullSwitchTxtConfigVar:

• CmdSwitchTextKind.fullSwitchTxtConfigVar

fullSwitchTxtCppdefine:

• CmdSwitchTextKind.fullSwitchTxtCppdefine

fullSwitchTxtCpu:

• CmdSwitchTextKind.fullSwitchTxtCpu

fullSwitchTxtCursorinference:

• CmdSwitchTextKind.fullSwitchTxtCursorinference

fullSwitchTxtDebugger:

• CmdSwitchTextKind.fullSwitchTxtDebugger

fullSwitchTxtDebuginfo:

• CmdSwitchTextKind.fullSwitchTxtDebuginfo

fullSwitchTxtDeclaredlocs:

• CmdSwitchTextKind.fullSwitchTxtDeclaredlocs

fullSwitchTxtDeepcopy:

• CmdSwitchTextKind.fullSwitchTxtDeepcopy

fullSwitchTxtDefine:

• CmdSwitchTextKind.fullSwitchTxtDefine

fullSwitchTxtDepfile:

• CmdSwitchTextKind.fullSwitchTxtDepfile

fullSwitchTxtDoccmd:

• CmdSwitchTextKind.fullSwitchTxtDoccmd

fullSwitchTxtDocinternal:

• CmdSwitchTextKind.fullSwitchTxtDocinternal

fullSwitchTxtDocroot:

• CmdSwitchTextKind.fullSwitchTxtDocroot

fullSwitchTxtDocseesrcurl:

• CmdSwitchTextKind.fullSwitchTxtDocseesrcurl

fullSwitchTxtDynliboverride:

• CmdSwitchTextKind.fullSwitchTxtDynliboverride

fullSwitchTxtDynliboverrideall:

• CmdSwitchTextKind.fullSwitchTxtDynliboverrideall

fullSwitchTxtEmbedsrc:

• CmdSwitchTextKind.fullSwitchTxtEmbedsrc

fullSwitchTxtErrormax:

• CmdSwitchTextKind.fullSwitchTxtErrormax

fullSwitchTxtExceptions:

• CmdSwitchTextKind.fullSwitchTxtExceptions

fullSwitchTxtExcessivestacktrace:

• CmdSwitchTextKind.fullSwitchTxtExcessivestacktrace

fullSwitchTxtExcludepath:

• CmdSwitchTextKind.fullSwitchTxtExcludepath

fullSwitchTxtExpandarc:

• CmdSwitchTextKind.fullSwitchTxtExpandarc

fullSwitchTxtExpandmacro:

• CmdSwitchTextKind.fullSwitchTxtExpandmacro

fullSwitchTxtExperimental:

• CmdSwitchTextKind.fullSwitchTxtExperimental

fullSwitchTxtFieldchecks:

• CmdSwitchTextKind.fullSwitchTxtFieldchecks

fullSwitchTxtFilenames:

• CmdSwitchTextKind.fullSwitchTxtFilenames

fullSwitchTxtFloatchecks:

• CmdSwitchTextKind.fullSwitchTxtFloatchecks

fullSwitchTxtForcebuild:

• CmdSwitchTextKind.fullSwitchTxtForcebuild

fullSwitchTxtFromcmd:

• CmdSwitchTextKind.fullSwitchTxtFromcmd

fullSwitchTxtGc:

• CmdSwitchTextKind.fullSwitchTxtGc

fullSwitchTxtGenmapping:

• CmdSwitchTextKind.fullSwitchTxtGenmapping

fullSwitchTxtGenscript:

• CmdSwitchTextKind.fullSwitchTxtGenscript

fullSwitchTxtHeader:

• CmdSwitchTextKind.fullSwitchTxtHeader

fullSwitchTxtHint:

• CmdSwitchTextKind.fullSwitchTxtHint

fullSwitchTxtHintaserror:

• CmdSwitchTextKind.fullSwitchTxtHintaserror

fullSwitchTxtHints:

• CmdSwitchTextKind.fullSwitchTxtHints

fullSwitchTxtImplicitstatic:

• CmdSwitchTextKind.fullSwitchTxtImplicitstatic

fullSwitchTxtImport:

• CmdSwitchTextKind.fullSwitchTxtImport

fullSwitchTxtInclude:

• CmdSwitchTextKind.fullSwitchTxtInclude

fullSwitchTxtIncremental:

• CmdSwitchTextKind.fullSwitchTxtIncremental

fullSwitchTxtIndex:

• CmdSwitchTextKind.fullSwitchTxtIndex

fullSwitchTxtInfchecks:

• CmdSwitchTextKind.fullSwitchTxtInfchecks

fullSwitchTxtInvalid:

• CmdSwitchTextKind.fullSwitchTxtInvalid

fullSwitchTxtLib:

• CmdSwitchTextKind.fullSwitchTxtLib

fullSwitchTxtLinedir:

• CmdSwitchTextKind.fullSwitchTxtLinedir

fullSwitchTxtLinetrace:

• CmdSwitchTextKind.fullSwitchTxtLinetrace

fullSwitchTxtLink:

• CmdSwitchTextKind.fullSwitchTxtLink

fullSwitchTxtListcmd:

• CmdSwitchTextKind.fullSwitchTxtListcmd

fullSwitchTxtListfullpaths:

• CmdSwitchTextKind.fullSwitchTxtListfullpaths

fullSwitchTxtMaxloopiterationsvm:

• CmdSwitchTextKind.fullSwitchTxtMaxloopiterationsvm

fullSwitchTxtMemtracker:

• CmdSwitchTextKind.fullSwitchTxtMemtracker

fullSwitchTxtMultimethods:

• CmdSwitchTextKind.fullSwitchTxtMultimethods

fullSwitchTxtNanchecks:

• CmdSwitchTextKind.fullSwitchTxtNanchecks

fullSwitchTxtNimblepath:

• CmdSwitchTextKind.fullSwitchTxtNimblepath

fullSwitchTxtNimcache:

• CmdSwitchTextKind.fullSwitchTxtNimcache

fullSwitchTxtNolinking:

• CmdSwitchTextKind.fullSwitchTxtNolinking

fullSwitchTxtNomain:

• CmdSwitchTextKind.fullSwitchTxtNomain

fullSwitchTxtNonimblepath:

• CmdSwitchTextKind.fullSwitchTxtNonimblepath

fullSwitchTxtObjchecks:

• CmdSwitchTextKind.fullSwitchTxtObjchecks

fullSwitchTxtOpt:

• CmdSwitchTextKind.fullSwitchTxtOpt

fullSwitchTxtOs:

• CmdSwitchTextKind.fullSwitchTxtOs

fullSwitchTxtOut:

• CmdSwitchTextKind.fullSwitchTxtOut

fullSwitchTxtOutdir:

• CmdSwitchTextKind.fullSwitchTxtOutdir

fullSwitchTxtOverflowchecks:

• CmdSwitchTextKind.fullSwitchTxtOverflowchecks

fullSwitchTxtPanics:

• CmdSwitchTextKind.fullSwitchTxtPanics

fullSwitchTxtParallelbuild:

• CmdSwitchTextKind.fullSwitchTxtParallelbuild

fullSwitchTxtPassc:

• CmdSwitchTextKind.fullSwitchTxtPassc

fullSwitchTxtPassl:

• CmdSwitchTextKind.fullSwitchTxtPassl

fullSwitchTxtPath:

• CmdSwitchTextKind.fullSwitchTxtPath

fullSwitchTxtProcessing:

• CmdSwitchTextKind.fullSwitchTxtProcessing

fullSwitchTxtProfiler:

• CmdSwitchTextKind.fullSwitchTxtProfiler

fullSwitchTxtProfilevm:

• CmdSwitchTextKind.fullSwitchTxtProfilevm

fullSwitchTxtProject:

• CmdSwitchTextKind.fullSwitchTxtProject

fullSwitchTxtPutenv:

• CmdSwitchTextKind.fullSwitchTxtPutenv

fullSwitchTxtRangechecks:

• CmdSwitchTextKind.fullSwitchTxtRangechecks

fullSwitchTxtRun:

• CmdSwitchTextKind.fullSwitchTxtRun

fullSwitchTxtSeqsv2:

• CmdSwitchTextKind.fullSwitchTxtSeqsv2

fullSwitchTxtShowallmismatches:

• CmdSwitchTextKind.fullSwitchTxtShowallmismatches

fullSwitchTxtSinkinference:

• CmdSwitchTextKind.fullSwitchTxtSinkinference

fullSwitchTxtSkipcfg:

• CmdSwitchTextKind.fullSwitchTxtSkipcfg

fullSwitchTxtSkipparentcfg:

• CmdSwitchTextKind.fullSwitchTxtSkipparentcfg

fullSwitchTxtSkipprojcfg:

• CmdSwitchTextKind.fullSwitchTxtSkipprojcfg

fullSwitchTxtSkipusercfg:

• CmdSwitchTextKind.fullSwitchTxtSkipusercfg

fullSwitchTxtSourcemap:

• CmdSwitchTextKind.fullSwitchTxtSourcemap

fullSwitchTxtSpellsuggest:

• CmdSwitchTextKind.fullSwitchTxtSpellsuggest

fullSwitchTxtStacktrace:

• CmdSwitchTextKind.fullSwitchTxtStacktrace

fullSwitchTxtStacktracemsgs:

• CmdSwitchTextKind.fullSwitchTxtStacktracemsgs

fullSwitchTxtStaticboundchecks:

• CmdSwitchTextKind.fullSwitchTxtStaticboundchecks

fullSwitchTxtStdout:

• CmdSwitchTextKind.fullSwitchTxtStdout

fullSwitchTxtStylecheck:

• CmdSwitchTextKind.fullSwitchTxtStylecheck

fullSwitchTxtStylechecks:

• CmdSwitchTextKind.fullSwitchTxtStylechecks

fullSwitchTxtThreadanalysis:

• CmdSwitchTextKind.fullSwitchTxtThreadanalysis

fullSwitchTxtThreads:

• CmdSwitchTextKind.fullSwitchTxtThreads

fullSwitchTxtTlsemulation:

• CmdSwitchTextKind.fullSwitchTxtTlsemulation

fullSwitchTxtTrmacros:

• CmdSwitchTextKind.fullSwitchTxtTrmacros

fullSwitchTxtUndef:

• CmdSwitchTextKind.fullSwitchTxtUndef

fullSwitchTxtUnitsep:

• CmdSwitchTextKind.fullSwitchTxtUnitsep

fullSwitchTxtUsenimcache:

• CmdSwitchTextKind.fullSwitchTxtUsenimcache

fullSwitchTxtVerbosity:

• CmdSwitchTextKind.fullSwitchTxtVerbosity

fullSwitchTxtWarning:

• CmdSwitchTextKind.fullSwitchTxtWarning

fullSwitchTxtWarningaserror:

• CmdSwitchTextKind.fullSwitchTxtWarningaserror

fullSwitchTxtWarnings:

• CmdSwitchTextKind.fullSwitchTxtWarnings

FuncTableEntry:

• vmdef: FuncTableEntry

FunctionIndex:

• vmdef: FunctionIndex

gABC:

• vmgen: gABC(ctx: var TCtx; i: TLineInfo; opc: TOpcode; a, b, c: TRegister = 0)
• vmgen: gABC(ctx: var TCtx; n: CgNode; opc: TOpcode; a, b, c: TRegister = 0)

gABx:

• vmgen: gABx(c: var TCtx; i: TLineInfo; opc: TOpcode; a: TRegister = 0; bx: int)

gcArc:

• TGCMode.gcArc

gCmdLineInfo:

• msgs: gCmdLineInfo

gcNative:

• TGCMode.gcNative

gcOrc:

• TGCMode.gcOrc

GcTypeKinds:

• ast_types: GcTypeKinds

gcUnselected:

• TGCMode.gcUnselected

gen:

• sourcemap: gen(map: SourceMapGenerator): SourceMap

genAddrOf:

• lowerings: genAddrOf(n: PNode; idgen: IdGenerator; typeKind = tyPtr): PNode

genBuiltin:

• liftdestructors: genBuiltin(g: ModuleGraph; idgen: IdGenerator; magic: TMagic; name: string; i: PNode): PNode

genCaseObjDiscMapping:

• enumtostr: genCaseObjDiscMapping(t: PType; field: PSym; info: TLineInfo; g: ModuleGraph; idgen: IdGenerator): PSym

GenClosure:

• vmtypegen: GenClosure

genConstant:

• jsgen: genConstant(g: PGlobals; m: BModule; id: ConstId)

genConstDefinition:

• cgen: genConstDefinition(q: BModule; id: ConstId)

genDatInitCode:

• cgen: genDatInitCode(m: BModule): bool

gendependPass:

• depends: gendependPass

genDeref:

• lowerings: genDeref(n: PNode; k = nkHiddenDeref): PNode

genDestroy:

• injecthooks: genDestroy(bu: var MirBuilder; graph: ModuleGraph; env: var MirEnv; target: Value)

genEnumToStrProc:

• enumtostr: genEnumToStrProc(t: PType; info: TLineInfo; g: ModuleGraph; idgen: IdGenerator): PSym

generateAssignment:

• mirgen: generateAssignment(graph: ModuleGraph; env: var MirEnv; config: TranslationConfig; n: PNode; builder: var MirBuilder; source: var SourceMap)

generateCode:

• cbackend: generateCode(graph: ModuleGraph; g: BModuleList; mlist: sink ModuleList)
• cbackend: generateCode(graph: ModuleGraph; mlist: sink ModuleList)
• jsbackend: generateCode(graph: ModuleGraph; mlist: sink ModuleList)
• cbackend: generateCode(g: ModuleGraph)
• mirgen: generateCode(graph: ModuleGraph; env: var MirEnv; owner: PSym; config: TranslationConfig; body: PNode): MirBody
• vmbackend: generateCode(g: ModuleGraph; mlist: sink ModuleList)

generateDoc:

• docgen: generateDoc(d: PDoc; n, orig: PNode; docFlags: DocFlags = kDefault)

generateDot:

• depends: generateDot(graph: ModuleGraph; project: AbsoluteFile)

generateIndex:

• docgen: generateIndex(d: PDoc)

generateIR:

• backends: generateIR(graph: ModuleGraph; idgen: IdGenerator; env: var MirEnv; owner: PSym; body: sink MirBody): Body
• cgirgen: generateIR(graph: ModuleGraph; idgen: IdGenerator; env: var MirEnv; owner: PSym; body: sink MirBody): Body

generateJson:

• docgen: generateJson(d: PDoc; n: PNode; includeComments: bool = true)

generateMain:

• backends: generateMain(graph: ModuleGraph; modules: ModuleList; result: PNode)

generateMainProcedure:

• backends: generateMainProcedure(graph: ModuleGraph; idgen: IdGenerator; modules: ModuleList): PSym

generateMethodDispatchers:

• cgmeth: generateMethodDispatchers(g: ModuleGraph)

generateTags:

• docgen: generateTags(d: PDoc; n: PNode; r: var string)

generateTeardown:

• backends: generateTeardown(graph: ModuleGraph; modules: ModuleList; result: PNode)

generateThreadTeardown:

• backends: generateThreadTeardown(graph: ModuleGraph; modules: ModuleList; result: PNode)

generateTypeInstance:

• semtypinst: generateTypeInstance(p: PContext; pt: TIdTable; info: TLineInfo; t: PType): PType
• semtypinst: generateTypeInstance(p: PContext; pt: TIdTable; arg: PNode; t: PType): untyped

genericParamsInMacroCall:

• ast_query: genericParamsInMacroCall(macroSym: PSym; call: PNode): (PSym, PNode)

genericParamsPos:

• ast_query: genericParamsPos

GenericTypes:

• ast_query: GenericTypes

genExpr:

• vmjit: genExpr(jit: var JitState; c: var TCtx; n: PNode): VmGenResult

genFieldDefect:

• astmsgs: genFieldDefect(conf: ConfigRef; field: string; disc: PSym): string

genHeader:

• jsgen: genHeader(): Rope

genHigh:

• lowerings: genHigh(g: ModuleGraph; n: PNode): PNode

genLen:

• lowerings: genLen(g: ModuleGraph; n: PNode): PNode

genMainProc:

• cgen: genMainProc(m: BModule; body: Rope)

GenOption:

• mirgen: GenOption

genPartial:

• cgen: genPartial(p: BProc; n: CgNode)
• jsgen: genPartial(p: PProc; n: CgNode)

genPrefix:

• lowerings: genPrefix

genProc:

• cgen: genProc(m: BModule; id: ProcedureId; procBody: sink Body): Rope
• jsgen: genProc(g: PGlobals; module: BModule; id: ProcedureId; body: sink Body): Rope
• vmgen: genProc(c: var TCtx; s: PSym; body: sink Body): VmGenResult

genProcPrototype:

• cgen: genProcPrototype(m: BModule; id: ProcedureId)

genSourceMap:

• sourcemap: genSourceMap(source: string; outFile: string): (Rope, SourceMap)

genStmt:

• vmgen: genStmt(c: var TCtx; body: sink Body): Result[int, VmGenDiag]
• vmjit: genStmt(jit: var JitState; c: var TCtx; n: PNode): VmGenResult

genStmts:

• cgen: genStmts(p: BProc; n: CgNode)

genSubDir:

• options: genSubDir

genTopLevelStmt:

• jsgen: genTopLevelStmt(globals: PGlobals; m: BModule; body: sink Body)

genTypeInfo:

• cgen: genTypeInfo(config: ConfigRef; m: BModule; t: PType; info: TLineInfo): Rope

genVarPrototype:

• cgen: genVarPrototype(m: BModule; id: GlobalId)

get:

• checked_ast: get(n: CheckedAst): PNode
• mirtypes: get(env: TypeEnv; id: TypeId): lent TypeSym
• semdata: get(p: PProcCon; key: PSym): PSym
• vmobjects: get(ctx: VariantFieldIterCtx): tuple[valid: bool, idx: FieldIndex]

getAlign:

• types: getAlign(conf: ConfigRef; typ: PType): BiggestInt

getAttachedOp:

• modulegraphs: getAttachedOp(g: ModuleGraph; t: PType; op: TTypeAttachedOp): PSym

getBody:

• modulegraphs: getBody(g: ModuleGraph; s: PSym): PNode

getBool:

• vmhooks: getBool(a: VmArgs; i: Natural): bool

getCalleeMagic:

• compat: getCalleeMagic(env: MirEnv; callee: CgNode): TMagic

getClockStr:

• options: getClockStr(): string

getClosureIterResult:

• lambdalifting: getClosureIterResult(g: ModuleGraph; iter: PSym; idgen: IdGenerator): PSym

getColNumber:

• nimlexbase: getColNumber(L: TBaseLexer; pos: int): int

getCompileCFileCmd:

• extccomp: getCompileCFileCmd(conf: ConfigRef; cfile: Cfile; isMainFile = false; produceOutput = false): string

getCompileOptionsStr:

• options: getCompileOptionsStr(conf: ConfigRef): string

getCompilerProc:

• magicsys: getCompilerProc(g: ModuleGraph; name: string): PSym

getConfigVar:

• options: getConfigVar(conf: ConfigRef; key: string; default = ""): string

getConstExpr:

• semfold: getConstExpr(m: PSym; n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode

getConstExprError:

• semfold: getConstExprError(m: PSym; n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode

getContext:

• msgs: getContext(conf: ConfigRef; lastinfo: TLineInfo): seq[ReportContext]

getCurrentLine:

• nimlexbase: getCurrentLine(L: TBaseLexer; marker: bool = true): string

getCurrOwner:

• semdata: getCurrOwner(c: PContext): PSym

getDateStr:

• options: getDateStr(): string

getDatInitName:

• cgen: getDatInitName(m: BModule): Rope

getDeclPragma:

• ast_query: getDeclPragma(n: PNode): PNode

getDefined:

• options: getDefined(conf: ConfigRef; sym: string): string

getDefNameSymOrRecover:

• sem: getDefNameSymOrRecover(n: PNode): PSym

getDispatcher:

• cgmeth: getDispatcher(s: PSym): PSym

getDocHacksJs:

• nimpaths: getDocHacksJs(nimr: string; nim = getCurrentCompilerExe(); forceRebuild = false): string

getEnumNames:

• wordrecg: getEnumNames[E: enum](values: set[E]): seq[string]

getEnvParam:

• lambdalifting: getEnvParam(routine: PSym): PSym
• vmaux: getEnvParam(prc: PSym): PSym

getFieldAndOwner:

• vmtypes: getFieldAndOwner(t: PVmType; p: FieldPosition): (PVmType, FieldIndex)

getFieldFromObj:

• lowerings: getFieldFromObj(t: PType; v: PSym): PSym

getFieldHandle:

• vmmemory: getFieldHandle(h: LocHandle; idx: FieldIndex): LocHandle
• vmmemory: getFieldHandle(loc: LocHandle; pos: FieldPosition): LocHandle

getFloat:

• ast_query: getFloat(a: PNode): BiggestFloat
• mirenv: getFloat(env: MirEnv; id: NumberId): BiggestFloat
• vmhooks: getFloat(a: VmArgs; i: Natural): BiggestFloat

getFloatLitType:

• magicsys: getFloatLitType(g: ModuleGraph; literal: PNode): PType

getFloatVal:

• packed_env: getFloatVal(pe: PackedEnv; n: PackedDataNode): BiggestFloat

getFloatValue:

• types: getFloatValue(n: PNode): BiggestFloat

getGenSym:

• semdata: getGenSym(c: PContext; s: PSym): PSym

getGlobal:

• vmjit: getGlobal(jit: JitState; g: PSym): LinkIndex

getGlobalValue:

• compilerbridge: getGlobalValue(c: EvalContext; s: PSym): PNode

getHandle:

• vmhooks: getHandle(a: VmArgs; i: Natural): LocHandle

getHash:

• msgs: getHash(conf: ConfigRef; fileIdx: FileIndex): string

getIdent:

• idents: getIdent(ic: IdentCache; identifier: cstring; length: int; h: Hash): PIdent
• idents: getIdent(ic: IdentCache; identifier: string): PIdent
• idents: getIdent(ic: IdentCache; identifier: string; h: Hash): PIdent

getIdentLineInfo:

• ast_query: getIdentLineInfo(n: PNode): TLineInfo

getInfoContext:

• msgs: getInfoContext(conf: ConfigRef; index: int): TLineInfo

getInfoContextLen:

• msgs: getInfoContextLen(conf: ConfigRef): int

getInitName:

• cgen: getInitName(m: BModule): Rope

getInt:

• ast_query: getInt(a: PNode): Int128
• compat: getInt(n: CgNode): Int128
• mirenv: getInt(env: MirEnv; id: NumberId): BiggestInt
• vmhooks: getInt(a: VmArgs; i: Natural): BiggestInt

getInt64:

• ast_query: getInt64(a: PNode): int64

getIntLitType:

• semdata: getIntLitType(c: PContext; literal: PNode): PType

getIntVal:

• packed_env: getIntVal(pe: PackedEnv; n: PackedDataNode): BiggestInt

getItemHandle:

• vmobjects: getItemHandle(loc: LocHandle; index: Natural; a: VmAllocator): LocHandle
• vmobjects: getItemHandle(s: VmSeq; typ: PVmType; index: Natural; a: VmAllocator): LocHandle

getKeyId:

• bitabs: getKeyId[T](t: BiTable[T]; v: T): LitId

getLib:

• modulegraphs: getLib(g: ModuleGraph; id: LibId): var TLib

getLineInfo:

• lexer: getLineInfo(L: Lexer): TLineInfo
• lexer: getLineInfo(L: Lexer; tok: Token): TLineInfo

getLinkOptionsStr:

• options: getLinkOptionsStr(conf: ConfigRef): string

getMagic:

• trees: getMagic(op: PNode): TMagic
• compat: getMagic(env: MirEnv; op: CgNode): TMagic

getMagicEqForType:

• magicsys: getMagicEqForType(t: PType): TMagic

getMagicEqSymForType:

• magicsys: getMagicEqSymForType(g: ModuleGraph; t: PType; info: TLineInfo): PSym

getMagicLeForType:

• magicsys: getMagicLeForType(t: PType): TMagic

getMagicLessForType:

• magicsys: getMagicLessForType(t: PType): tuple[le, lt: TMagic]

getModule:

• astalgo: getModule(s: PSym): PSym
• modulegraphs: getModule(g: ModuleGraph; fileIdx: FileIndex): PSym

getModuleName:

• modulepaths: getModuleName(conf: ConfigRef; n: PNode): string

getNamedParamFromList:

• astalgo: getNamedParamFromList(list: PNode; ident: PIdent): PSym

getNextTok:

• renderer: getNextTok(r: var TSrcGen; kind: var TokType; literal: var string)

getnimblePkg:

• ast_query: getnimblePkg(a: PSym): PSym

getnimblePkgId:

• ast_query: getnimblePkgId(a: PSym): int

getNimcacheDir:

• options: getNimcacheDir(conf: ConfigRef): AbsoluteDir
• options: getNimcacheDir(conf: CurrentConf): AbsoluteDir

getNimScriptSymbol:

• magicsys: getNimScriptSymbol(g: ModuleGraph; name: string): PSym

getNode:

• vmhooks: getNode(a: VmArgs; i: Natural): PNode

getNodeId:

• packed_ast: getNodeId(tree: PackedTree): NodeId

getNotFoundIdent:

• idents: getNotFoundIdent(ic: IdentCache): PIdent

getOp:

• injecthooks: getOp(g: ModuleGraph; t: PType; kind: TTypeAttachedOp): PSym

getOrCreate:

• vmgen: getOrCreate(c: var TCtx; typ: PType; noClosure = false): PVmType
• vmtypegen: getOrCreate(c: var TCtx; typ: PType; noClosure = false): PVmType
• vmtypegen: getOrCreate(c: var TypeInfoCache; conf: ConfigRef; typ: PType; noClosure: bool; cl: var GenClosure): PVmType

getOrDefault:

• typemaps: getOrDefault[T](t: TypeTable[T]; key: PType; def: T): T
• btrees: getOrDefault[Key, Val](b: BTree[Key, Val]; key: Key): Val

getOrdValue:

• types: getOrdValue(n: PNode; onError = high(Int128)): Int128
• compat: getOrdValue(n: CgNode): Int128

getOrIncl:

• bitabs: getOrIncl[T](t: var BiTable[T]; v: T): LitId
• mirenv: getOrIncl(env: var MirEnv; v: BiggestInt | BiggestUInt | BiggestFloat): NumberId
• mirenv: getOrIncl(env: var MirEnv; str: string): StringId

getOrPut:

• datatables: getOrPut(t: var DataTable; tree: sink MirTree): DataId

getOutFile:

• options: getOutFile(conf: ConfigRef; filename: RelativeFile; ext: string): AbsoluteFile

getPathVersionChecksum:

• nimblecmd: getPathVersionChecksum(p: string): tuple[name, version, checksum: string]

getPIdent:

• ast_query: getPIdent(a: PNode): PIdent

getPkgDesc:

• options: getPkgDesc(conf: ConfigRef; modulePath: string): PkgDesc

getPlugin:

• active: getPlugin(ic: IdentCache; fn: PSym): Transformation

getPragmaVal:

• pragmas: getPragmaVal(procAst: PNode; name: TSpecialWord): PNode

getPrecedence:

• lexer: getPrecedence(ident: PIdent): int
• lexer: getPrecedence(tok: Token): int

getPrefixDir:

• options: getPrefixDir(conf: ConfigRef): AbsoluteDir

getProcConvMismatch:

• types: getProcConvMismatch(c: ConfigRef; f, a: PType; rel = isNone): ( set[ProcConvMismatch], TTypeRelation)

getRelativePathFromConfigPath:

• options: getRelativePathFromConfigPath(conf: ConfigRef; f: AbsoluteFile; isTitle = false): RelativeFile

getReportHook:

• options: getReportHook(conf: ConfigRef): ReportHook

getResultHandle:

• vmhooks: getResultHandle(a: VmArgs): LocHandle

getReturnType:

• types: getReturnType(s: PSym): PType

getRoot:

• trees: getRoot(n: PNode): PSym
• aliasanalysis: getRoot(tree: MirTree; n: OpValue): OpValue

getSize:

• types: getSize(conf: ConfigRef; typ: PType): BiggestInt

getStateField:

• lambdalifting: getStateField(g: ModuleGraph; owner: PSym): PSym

getStdlibVersion:

• options: getStdlibVersion(conf: ConfigRef): NimVer

getStr:

• ast_query: getStr(a: PNode): string

getString:

• vmhooks: getString(a: VmArgs; i: Natural): string

getStrOrChar:

• ast_query: getStrOrChar(a: PNode): string

getSurroundingSrc:

• msgs: getSurroundingSrc(conf: ConfigRef; info: TLineInfo): string

getSymFromList:

• astalgo: getSymFromList(list: PNode; ident: PIdent; start: int = 0): PSym

getSymRepr:

• cli_reporter: getSymRepr(conf: ConfigRef; s: PSym; getDeclarationPath = true): string

getSysMagic:

• magicsys: getSysMagic(g: ModuleGraph; info: TLineInfo; name: string; m: TMagic): PSym

getSysSym:

• magicsys: getSysSym(g: ModuleGraph; info: TLineInfo; name: string): PSym

getSystemConfigPath:

• nimconf: getSystemConfigPath(conf: ConfigRef; filename: RelativeFile): AbsoluteFile

getSysType:

• magicsys: getSysType(g: ModuleGraph; info: TLineInfo; kind: TTypeKind): PType

getToken:

• ast_parsed_types: getToken(n: ParsedNode): ParsedToken

getTokSym:

• renderer: getTokSym(r: TSrcGen): PSym

getToStringProc:

• modulegraphs: getToStringProc(g: ModuleGraph; t: PType): PSym

getTransformed:

• modulegraphs: getTransformed(g: ModuleGraph; prc: PSym): PNode

getTypeRel:

• vmtypes: getTypeRel(a, b: PVmType): VmTypeRel

getUInt:

• mirenv: getUInt(env: MirEnv; id: NumberId): BiggestUInt

getUniqueType:

• ccgutils: getUniqueType(key: PType): PType

getUsedMem:

• vmmemory: getUsedMem(a: VmAllocator): uint

getUserConfigPath:

• nimconf: getUserConfigPath(filename: RelativeFile): AbsoluteFile

getVar:

• vmhooks: getVar(a: VmArgs; i: Natural): LocHandle

ggDebug:

• ast: ggDebug

globalAssert:

• msgs: globalAssert(conf: ConfigRef; cond: untyped; info: TLineInfo = unknownLineInfo; arg = "")

GlobalId:

• mirtrees: GlobalId

globalOptions:

• options: globalOptions(conf`gensym64: ConfigRef): TGlobalOptions

globalOptions=:

• options: globalOptions=(conf`gensym64: ConfigRef; val`gensym64: TGlobalOptions)

globalReport:

• msgs: globalReport(conf: ConfigRef; report: ReportTypes)
• msgs: globalReport(conf: ConfigRef; info: TLineInfo; report: ReportTypes)

globals:

• cgendata: globals(m: BModule): untyped

gloptNone:

• TGlobalOption.gloptNone

Goal:

• varpartitions: Goal

goGenTypeExpr:

• GenOption.goGenTypeExpr

goIsCompileTime:

• GenOption.goIsCompileTime

goIsNimvm:

• GenOption.goIsNimvm

gorgeOps:

• vmops: gorgeOps(): Override

goto:

• mirconstr: goto(bu: var MirBuilder; label: LabelId)

growBy:

• vmobjects: growBy(s: var VmSeq; typ: PVmType; num: Natural; mm: var VmMemoryManager)

GrowthFactor:

• ast: GrowthFactor

HackController:

• options: HackController

handleCmdInput:

• optionsprocessor: handleCmdInput(conf: ConfigRef)

handleCR:

• nimlexbase: handleCR(L: var TBaseLexer; pos: int): int

handleDocOutputOptions:

• docgen: handleDocOutputOptions(conf: ConfigRef)

handleLexerDiag:

• msgs: handleLexerDiag(conf: ConfigRef; diag: LexerDiag; reportFrom: InstantiationInfo; eh: TErrorHandling = doNothing)

handleLF:

• nimlexbase: handleLF(L: var TBaseLexer; pos: int): int

handleParserDiag:

• msgs: handleParserDiag(conf: ConfigRef; diag: ParseDiag; reportFrom: InstantiationInfo; eh: TErrorHandling = doNothing)

handleReport:

• msgs: handleReport(conf: ConfigRef; diag: PAstDiag; reportFrom: InstantiationInfo; eh: TErrorHandling = doNothing)
• msgs: handleReport(conf: ConfigRef; r: Report; reportFrom: InstantiationInfo; eh: TErrorHandling = doNothing)

HandlerTableEntry:

• vmdef: HandlerTableEntry

handleStdinInput:

• optionsprocessor: handleStdinInput(conf: ConfigRef)

harmlessOptions:

• options: harmlessOptions

hasAssume:

• TInfoCCProp.hasAssume

hasAtLeastXsons:

• packed_ast: hasAtLeastXsons(tree: PackedTree; n: NodePos; x: int): bool

hasAttribute:

• TInfoCCProp.hasAttribute

hasComputedGoto:

• TInfoCCProp.hasComputedGoto

hasCurFramePointer:

• TCProcFlag.hasCurFramePointer

HasDatInitProc:

• ModuleBackendFlag.HasDatInitProc

hasDeclspec:

• TInfoCCProp.hasDeclspec

hasDestructor:

• ast_query: hasDestructor(t: PType): bool

hasDisabledAsgn:

• modulegraphs: hasDisabledAsgn(g: ModuleGraph; t: PType): bool

hasFauxMatch:

• sigmatch: hasFauxMatch(c: TCandidate): bool

hasGcGuard:

• TInfoCCProp.hasGcGuard

hasGnuAsm:

• TInfoCCProp.hasGnuAsm

hash:

• ast_types: hash(x: ItemId): Hash
• ast_types: hash(a: NodeId): Hash
• idents: hash(x: PIdent): Hash
• lineinfos: hash(i: TLineInfo): Hash
• bitabs: hash[T](t: BiTable[T]): Hash
• bitabs: hash(x: LitId): Hash
• packed_ast: hash(a: SymId): Hash
• typemaps: hash(x: Type): Hash
• modulegraphs: hash(x: FileIndex): Hash
• modulegraphs: hash(u: SigHash): Hash

hasHint:

• options: hasHint(conf: ConfigRef; note: ReportKind): bool

hashMainCompilationParams:

• main: hashMainCompilationParams(conf: ConfigRef): string

hashNode:

• astalgo: hashNode(p: RootRef): Hash

hashNonProc:

• sighashes: hashNonProc(s: PSym): SigHash

hashOwner:

• sighashes: hashOwner(s: PSym): SigHash

hashProc:

• sighashes: hashProc(s: PSym): SigHash

hashString:

• ccgutils: hashString(conf: ConfigRef; s: string): BiggestInt

hashTree:

• treetab: hashTree(n: PNode): Hash

hashType:

• sighashes: hashType(t: PType; flags: set[ConsiderFlag] = {CoType}): SigHash

hasLitId:

• bitabs: hasLitId[T](t: BiTable[T]; x: LitId): bool

HasModuleInitProc:

• ModuleBackendFlag.HasModuleInitProc

hasNext:

• btrees: hasNext[Key, Val](b: BTree[Key, Val]; index: int): bool

hasNilSon:

• ast_query: hasNilSon(n: PNode): bool

hasPattern:

• ast_query: hasPattern(s: PSym): bool

hasPragma:

• pragmas: hasPragma(n: PNode; pragma: TSpecialWord): bool

hasSideEffect:

• varpartitions: hasSideEffect(c: var Partitions; info: var MutationInfo): bool

hasSonWith:

• ast_query: hasSonWith(n: PNode; kind: TNodeKind): bool

hasSubnodeWith:

• ast_query: hasSubnodeWith(n: PNode; kind: TNodeKind): bool

hasSwitchRange:

• TInfoCCProp.hasSwitchRange

hasTinyCBackend:

• options: hasTinyCBackend

hasUnassigned:

• mirconstr: hasUnassigned(bu: MirBuilder): bool

hasVarargs:

• mirtypes: hasVarargs(desc: TypeHeader; env: TypeEnv): bool

hasWarn:

• options: hasWarn(conf: ConfigRef; note: ReportKind): bool

hasXsons:

• packed_ast: hasXsons(tree: PackedTree; n: NodePos; x: int): bool

headerFor:

• mirtypes: headerFor(env: TypeEnv; id: TypeId; phase: Level): lent TypeHeader

HeaderId:

• mirtypes: HeaderId

heap:

• vmdef: heap(c: TCtx): untyped

heapDecRef:

• vmmemory: heapDecRef(heap: var VmHeap; a: var VmAllocator; slot: HeapSlotHandle)

heapIncRef:

• vmmemory: heapIncRef(heap: var VmHeap; slot: HeapSlotHandle)

heapNew:

• vmmemory: heapNew(heap: var VmHeap; a: var VmAllocator; typ: PVmType): HeapSlotHandle

HeapSlot:

• vmdef: HeapSlot

HeapSlotHandle:

• vmdef: HeapSlotHandle

hExt:

• extccomp: hExt

hiddenSection:

• RodSection.hiddenSection

high:

• int128: high(t: typedesc[Int128]): Int128

highBound:

• guards: highBound(conf: ConfigRef; x: PNode; o: Operators): PNode

hintsAsErrors:

• options: hintsAsErrors(conf: ConfigRef): ReportKinds

hintsAsErrors=:

• options: hintsAsErrors=(conf: ConfigRef; nset: ReportKinds)

HOslice:

• idioms: HOslice

htmldocsDir:

• options: htmldocsDir

htmldocsDirname:

• nimpaths: htmldocsDirname

HtmlExt:

• options: HtmlExt

id:

• ast_query: id(a: PIdObj): int

ideChk:

• IdeCmd.ideChk

IdeCmd:

• options: IdeCmd

ideCon:

• IdeCmd.ideCon

ideDef:

• IdeCmd.ideDef

ideDus:

• IdeCmd.ideDus

ideHighlight:

• IdeCmd.ideHighlight

ideKnown:

• IdeCmd.ideKnown

IdeLocCmds:

• options: IdeLocCmds

ideMod:

• IdeCmd.ideMod

ideMsg:

• IdeCmd.ideMsg

ideNone:

• IdeCmd.ideNone

IdentCache:

• idents: IdentCache

identLen:

• linter: identLen(line: string; start: int): int

IdentPattern:

• identpatterns: IdentPattern

ideOutline:

• IdeCmd.ideOutline

ideProject:

• IdeCmd.ideProject

ideSug:

• IdeCmd.ideSug

ideUse:

• IdeCmd.ideUse

IdGenerator:

• ast_idgen: IdGenerator

idGeneratorFromModule:

• ast_idgen: idGeneratorFromModule(m: PSym): IdGenerator

idgenFromLoadedModule:

• ic: idgenFromLoadedModule(m: LoadedModule): IdGenerator

idNodeTableGet:

• astalgo: idNodeTableGet(t: TIdNodeTable; key: PIdObj): PNode

idNodeTablePut:

• astalgo: idNodeTablePut(t: var TIdNodeTable; key: PIdObj; val: PNode)

idOrSig:

• sighashes: idOrSig(s: PSym; currentModule: string; sigCollisions: var CountTable[SigHash]): Rope

idTableGet:

• astalgo: idTableGet(t: TIdTable; key: int): RootRef
• astalgo: idTableGet(t: TIdTable; key: PIdObj): RootRef

idTableHasObjectAsKey:

• astalgo: idTableHasObjectAsKey(t: TIdTable; key: PIdObj): bool

idTablePairs:

• astalgo: idTablePairs(t: TIdTable): tuple[key: PIdObj, val: RootRef]

idTablePut:

• astalgo: idTablePut(t: var TIdTable; key: PIdObj; val: RootRef)

Iface:

• modulegraphs: Iface

ifErrorWalkErrors:

• errorhandling: ifErrorWalkErrors(config: ConfigRef; n: PNode): PNode

IgnoreCC:

• TTypeCmpFlag.IgnoreCC

IgnoreTupleFields:

• TTypeCmpFlag.IgnoreTupleFields

iiTableGet:

• astalgo: iiTableGet(t: TIITable; key: int): int

iiTablePut:

• astalgo: iiTablePut(t: var TIITable; key, val: int)

illegalCustomPragma:

• pragmas: illegalCustomPragma(c: PContext; n: PNode; s: PSym): PNode

immutableView:

• ViewTypeKind.immutableView

implicitCompilerTraceReprConf:

• astrepr: implicitCompilerTraceReprConf

implicitDeref:

• Feature.implicitDeref

implicitImports:

• options: implicitImports(conf`gensym42: ConfigRef): seq[string]

implicitImports=:

• options: implicitImports=(conf`gensym42: ConfigRef; val`gensym42: seq[string])

implicitImportsAdd:

• options: implicitImportsAdd(conf`gensym41: ConfigRef; item`gensym41: string | seq[string])

implicitIncludes:

• options: implicitIncludes(conf`gensym44: ConfigRef): seq[string]

implicitIncludes=:

• options: implicitIncludes=(conf`gensym44: ConfigRef; val`gensym44: seq[string])

implicitIncludesAdd:

• options: implicitIncludesAdd(conf`gensym43: ConfigRef; item`gensym43: string | seq[string])

implicitPragmas:

• pragmas: implicitPragmas(c: PContext; sym: PSym; n: PNode; validPragmas: TSpecialWords): PNode

implicitTReprConf:

• astrepr: implicitTReprConf

impliesNotNil:

• guards: impliesNotNil(m: TModel; arg: PNode): TImplication

impNo:

• TImplication.impNo

importAll:

• ImportMode.importAll

importAllSymbols:

• importer: importAllSymbols(c: PContext; fromMod: PSym)

importantComments:

• options: importantComments(conf: ConfigRef): bool

importcCond:

• vmgen: importcCond(c: TCtx; s: PSym): bool

importcCondVar:

• vmgen: importcCondVar(s: PSym): bool

importedItems:

• lookups: importedItems(c: PContext; name: PIdent): PSym

ImportedModule:

• semdata: ImportedModule

importExcept:

• ImportMode.importExcept

ImportMode:

• semdata: ImportMode

importModule:

• modules: importModule(graph: ModuleGraph; s: PSym; fileIdx: FileIndex): PSym

importSet:

• ImportMode.importSet

impUnknown:

• TImplication.impUnknown

impYes:

• TImplication.impYes

inc:

• mirtrees: inc(a: var NodePosition)
• int128: inc(a: var Int128; y: uint32 = 1)

inCheckpoint:

• suggest: inCheckpoint(current, trackPos: TLineInfo): TCheckPointResult

incl:

• options: incl(conf: ConfigRef; nset: ConfNoteSet; note: ReportKind)
• options: incl(s: var ReportSet; id: NodeId)
• options: incl(conf`gensym61: ConfigRef; item`gensym61: TOption | TOptions)
• options: incl(conf`gensym63: ConfigRef; item`gensym63: TGlobalOption | TGlobalOptions)
• options: incl(conf`gensym65: ConfigRef; item`gensym65: Feature | set[Feature])
• astrepr: incl(conf: var TReprConf; flag: TReprFlag | set[TReprFlag])

inclDynlibOverride:

• options: inclDynlibOverride(conf: ConfigRef; lib: string)

inclTreeSet:

• nimsets: inclTreeSet(result: var TBitSetView; conf: ConfigRef; s: PNode)

includeFileChanged:

• RodFileError.includeFileChanged

includeHeader:

• cgendata: includeHeader(this: BModule; header: string)

includeModule:

• modules: includeModule(graph: ModuleGraph; s: PSym; fileIdx: FileIndex): PNode

includesStringh:

• CodegenFlag.includesStringh

inCompileTimeOnlyContext:

• semdata: inCompileTimeOnlyContext(c: PContext): bool

incompleteType:

• ast_query: incompleteType(t: PType): bool

inDebug:

• options: inDebug(conf: ConfigRef): bool
• astrepr: inDebug(): bool

index:

• sourcemap: index[T](elements: seq[T]; element: T): int

Indexable:

• ast_types: Indexable

indexLike:

• mirtrees: indexLike(_: typedesc[SourceId])

indirectAccess:

• lowerings: indirectAccess(a: PNode; b: ItemId; info: TLineInfo): PNode
• lowerings: indirectAccess(a: PNode; b: PSym; info: TLineInfo): PNode
• lowerings: indirectAccess(a: PNode; b: string; info: TLineInfo; cache: IdentCache): PNode
• lowerings: indirectAccess(a, b: PSym; info: TLineInfo): PNode

inferStaticParam:

• sigmatch: inferStaticParam(c: var TCandidate; lhs: PNode; rhs: BiggestInt): bool

inFile:

• options: inFile(conf: ConfigRef; info: TLineInfo; file: string; lrange: Slice[int] = low(int) .. high(int)): bool
• astrepr: inFile(node: PNode | PSym; file: string; lrange: Slice[int] = low(int) .. high(int)): bool
• astrepr: inFile(conf: ConfigRef; node: PNode | PSym; file: string; lrange: Slice[int] = low(int) .. high(int)): bool

info:

• ast_parsed_types: info(p: ParsedNode): TLineInfo
• checked_ast: info(x: CheckedAst): TLineInfo
• packed_ast: info(tree: PackedTree; n: NodePos): PackedLineInfo
• packed_ast: info(n: NodePos): PackedLineInfo

inheritanceDiff:

• types: inheritanceDiff(a, b: PType): int

inheritDynlib:

• pragmas: inheritDynlib(c: PContext; sym: PSym)

IniExt:

• options: IniExt

inInt128Range:

• int128: inInt128Range(arg: float64): bool

init:

• packed_env: init(enc: var PackedEncoder; types: seq[PVmType])
• vmdef: init(cache: var TypeInfoCache)

initBTree:

• btrees: initBTree[Key, Val](): BTree[Key, Val]

initBuilder:

• mirconstr: initBuilder(id: SourceId; buf: sink MirNodeSeq = @[]): MirBuilder

initCallCandidate:

• sigmatch: initCallCandidate(ctx: PContext; c: var TCandidate; callee: PSym; calleeScope = -1)

initCandidate:

• sigmatch: initCandidate(ctx: PContext; c: var TCandidate; callee: PType)

initChangeset:

• mirchangesets: initChangeset(body: MirBody): Changeset

initCodeGen:

• vmgen: initCodeGen(g: ModuleGraph): CodeGenCtx

initCtx:

• vmdef: initCtx(module: PSym; cache: IdentCache; g: ModuleGraph; idgen: IdGenerator; tracer: TraceHandler = defaultTracer): TCtx

initDefines:

• condsyms: initDefines(symbols: StringTableRef)

initDefinesProg:

• cmdlinehelper: initDefinesProg(self: NimProg; conf: ConfigRef; name: string)

initEncoder:

• ic: initEncoder(c: var PackedEncoder; m: var PackedModule; moduleSym: PSym; config: ConfigRef; pc: PackedConfig)
• modulegraphs: initEncoder(g: ModuleGraph; module: PSym)

initForMappingChildren:

• checked_ast: initForMappingChildren(x: var CheckedAst; n: PNode)

initFromExpr:

• vmserialize: initFromExpr(dest: LocHandle; tree: MirTree; env: MirEnv; c: var TCtx)

initIdentIter:

• astalgo: initIdentIter(ti: var TIdentIter; tab: TStrTable; s: PIdent): PSym

initIdNodeTable:

• ast: initIdNodeTable(x: var TIdNodeTable)

initIdTable:

• ast: initIdTable(x: var TIdTable)

initIiTable:

• astalgo: initIiTable(x: var TIITable)

initJit:

• vmjit: initJit(graph: ModuleGraph): JitState

initLayeredTypeMap:

• semtypinst: initLayeredTypeMap(pt: TIdTable): LayeredIdTable

initLib:

• semdata: initLib(kind: TLibKind): TLib

initLocReg:

• vm: initLocReg(r: var TFullReg; typ: PVmType; mm: var VmMemoryManager)

initMirEnv:

• mirenv: initMirEnv(g: ModuleGraph): MirEnv

initModuleIter:

• modulegraphs: initModuleIter(mi: var ModuleIter; g: ModuleGraph; m: PSym; name: PIdent): PSym

initMsgConfig:

• options: initMsgConfig(): MsgConfig

initNodeTable:

• ast: initNodeTable(x: var TNodeTable)

initObjectSet:

• ast: initObjectSet(x: var TObjectSet)

initOverloadIter:

• lookups: initOverloadIter(o: var TOverloadIter; c: PContext; n: PNode): PSym
• lookups: initOverloadIter(o: var TOverloadIter; c: PContext; scope: PScope; n: PNode): PSym

initPackedDecoder:

• ic: initPackedDecoder(config: ConfigRef; cache: IdentCache): PackedDecoder

initProcEntry:

• vmaux: initProcEntry(keys: Patterns; config: ConfigRef; tc: var TypeInfoCache; prc: PSym): FuncTableEntry
• vmaux: initProcEntry(c: var TCtx; prc: PSym): FuncTableEntry

initRodIter:

• ic: initRodIter(it: var RodIter; config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: FileIndex; name: PIdent; importHidden: bool): PSym

initRodIterAllSyms:

• ic: initRodIterAllSyms(it: var RodIter; config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: FileIndex; importHidden: bool): PSym

initRootRef:

• vmtypegen: initRootRef(c: var TypeInfoCache; config: ConfigRef; root: PType)

initStrTable:

• ast: initStrTable(x: var TStrTable)

initStrTables:

• modulegraphs: initStrTables(g: ModuleGraph; m: PSym)

initTabIter:

• astalgo: initTabIter(ti: var TTabIter; tab: TStrTable): PSym

initToken:

• lexer: initToken(L: var Token)

initTokRender:

• renderer: initTokRender(r: var TSrcGen; n: PNode; renderFlags: TRenderFlags = {})

initTypeEnv:

• mirtypes: initTypeEnv(graph: ModuleGraph): TypeEnv

initTypeVars:

• semtypinst: initTypeVars(p: PContext; typeMap: LayeredIdTable; info: TLineInfo; owner: PSym): TReplTypeVars

initVars:

• extccomp: initVars(conf: ConfigRef)

initVmThread:

• vm: initVmThread(c: var TCtx; pc: PrgCtr; numRegisters: int; sym: PSym): VmThread

initWith:

• checked_ast: initWith(x: var CheckedAst; n: sink PNode)
• checked_ast: initWith(x: var ElaborateAst; n: PNode)

injectDestructorCalls:

• injectdestructors: injectDestructorCalls(tree: MirTree; g: ModuleGraph; env: var MirEnv; changes: var Changeset)

injectHooks:

• injecthooks: injectHooks(body: var MirBody; graph: ModuleGraph; env: var MirEnv; owner: PSym)
• injecthooks: injectHooks(body: MirBody; graph: ModuleGraph; env: var MirEnv; owner: PSym; changes: var Changeset)

inline:

• mirconstr: inline(bu: var MirBuilder; tree: MirTree; fr: NodePosition): Value

inLines:

• astrepr: inLines(node: PNode; lrange: Slice[int]): bool

insert:

• mirchangesets: insert(c: var Changeset; tree: MirTree; at, source: NodePosition; name: untyped; body: untyped)
• mirchangesets: insert(c: var Changeset; at: NodePosition; n: MirNode)
• treechangesets: insert(c: var Changeset; at: NodePosition; n: sink MirNode)
• treechangesets: insert(c: var Changeset; at: NodePosition; name: untyped; body: untyped)

inSet:

• nimsets: inSet(s: PNode; elem: PNode): bool

instantiateTypesInBody:

• semtypinst: instantiateTypesInBody(p: PContext; pt: TIdTable; n: PNode; owner: PSym): PNode

InstantiationInfo:

• lineinfos: InstantiationInfo

instCopyType:

• semtypinst: instCopyType(cl: var TReplTypeVars; t: PType): PType

instGenericConvertersArg:

• sem: instGenericConvertersArg(c: PContext; a: PNode; x: TCandidate)

instGenericConvertersSons:

• sem: instGenericConvertersSons(c: PContext; n: PNode; x: TCandidate)

instLoc:

• lineinfos: instLoc(depth: int = -2): InstantiationInfo

InstrPos:

• mirexec: InstrPos

instructions:

• mirexec: instructions(dfg: DataFlowGraph): (InstrPos, Opcode, OpValue)

instTypeBoundOp:

• sigmatch: instTypeBoundOp(c: PContext; dc: PSym; t: PType; info: TLineInfo; op: TTypeAttachedOp; col: int): PSym

Int128:

• int128: Int128

Int16Type:

• mirtypes: Int16Type

Int32Type:

• mirtypes: Int32Type

Int64Type:

• mirtypes: Int64Type

Int8Type:

• mirtypes: Int8Type

IntegralTypes:

• ast_query: IntegralTypes

interestingCaseExpr:

• guards: interestingCaseExpr(m: PNode): bool

interfaceSymbol:

• ic: interfaceSymbol(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: FileIndex; name: PIdent; importHidden: bool): PSym

interfaceSymbols:

• ic: interfaceSymbols(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: FileIndex; name: PIdent; importHidden: bool): PSym

internalAssert:

• msgs: internalAssert(conf: ConfigRef; condition: bool; failMsg = "")
• msgs: internalAssert(conf: ConfigRef; condition: bool; info: TLineInfo; failMsg: string = "")

internalError:

• msgs: internalError(conf: ConfigRef; fail: string): untyped
• msgs: internalError(conf: ConfigRef; info: TLineInfo; fail: string): untyped

InternalReport:

• reports_internal: InternalReport

InternalReportKind:

• report_enums: InternalReportKind

interp:

• nimpaths: interp(path: string; nimr: string): string

intersectSets:

• nimsets: intersectSets(conf: ConfigRef; a, b: PNode): PNode

IntLike:

• OrdinalType.IntLike

InvalidFileIdx:

• lineinfos: InvalidFileIdx

invalidGenericInst:

• types: invalidGenericInst(f: PType): bool

InvalidKey:

• astalgo: InvalidKey

invalidNodeId:

• ast_types: invalidNodeId

invalidPragma:

• pragmas: invalidPragma(c: PContext; n: PNode): PNode

ioFailure:

• RodFileError.ioFailure

ioReadOps:

• vmops: ioReadOps(): Override

ioWriteOps:

• vmops: ioWriteOps(): Override

irCgir:

• IrName.irCgir

irMirIn:

• IrName.irMirIn

irMirOut:

• IrName.irMirOut

IrName:

• options: IrName

irTransf:

• IrName.irTransf

irVm:

• IrName.irVm

isActive:

• ic: isActive(e: PackedEncoder): bool

isAddrNode:

• astalgo: isAddrNode(n: PNode): bool

isAlive:

• dce: isAlive(a: AliveSyms; module: int; item: int32): bool
• analysis: isAlive(tree: MirTree; cfg: DataFlowGraph; span: Subgraph; loc: Path; start: InstrPos): bool

isAnon:

• mirtrees: isAnon(id: ConstId): bool

isAPartOfB:

• aliasanalysis: isAPartOfB(r: CmpLocsResult): Ternary

isAssignable:

• parampatterns: isAssignable(owner: PSym; n: PNode; isUnsafeAddr = false): TAssignableResult

isAtom:

• ast_query: isAtom(n: PNode): bool
• packed_ast: isAtom(tree: PackedTree; pos: int): bool

isAvailable:

• vmjit: isAvailable(jit: JitState; c: TCtx; prc: PSym): bool

isBothMetaConvertible:

• TTypeRelation.isBothMetaConvertible

isBPartOfA:

• aliasanalysis: isBPartOfA(r: CmpLocsResult): Ternary

isCallExpr:

• ast_query: isCallExpr(n: PNode): bool

isCaseObj:

• trees: isCaseObj(n: PNode): bool

isCharArrayPtr:

• types: isCharArrayPtr(t: PType; allowPointerToChar: bool): bool

isClosure:

• ast_query: isClosure(typ: PType): bool

isClosureIterator:

• ast_query: isClosureIterator(typ: PType): bool

isCodeError:

• options: isCodeError(conf: ConfigRef; report: Report): bool

isCompilerDebug:

• debugutils: isCompilerDebug(conf: ConfigRef): bool

isCompilerTraceDebug:

• debugutils: isCompilerTraceDebug(conf: ConfigRef): bool

isCompileTimeOnly:

• types: isCompileTimeOnly(t: PType): bool

isCompileTimeProc:

• ast_query: isCompileTimeProc(s: PSym): bool

isConstExpr:

• trees: isConstExpr(n: PNode): bool

isConvertible:

• TTypeRelation.isConvertible

isCyclePossible:

• types: isCyclePossible(typ: PType; g: ModuleGraph): bool

isDebugEnabled:

• options: isDebugEnabled(c: ConfigRef; ir: IrName; name: string): bool

isDeepConstExpr:

• trees: isDeepConstExpr(n: PNode; preventInheritance = false): bool
• compat: isDeepConstExpr(n: CgNode): bool

isDefectException:

• types: isDefectException(t: PType): bool

isDefined:

• options: isDefined(conf: ConfigRef; symbol: string): bool
• options: isDefined(conf: CurrentConf; symbol: string): bool

isDirty:

• modulegraphs: isDirty(g: ModuleGraph; m: PSym): bool

isDiscriminantField:

• astalgo: isDiscriminantField(n: PNode): bool
• compat: isDiscriminantField(n: CgNode): bool

isDynlibOverride:

• options: isDynlibOverride(conf: ConfigRef; lib: string): bool

isEmbedded:

• mirtypes: isEmbedded(env: TypeEnv; typ: TypeId): bool

isEmpty:

• backends: isEmpty(f: MirBody): bool
• backends: isEmpty(tree: MirTree): bool
• pathutils: isEmpty(x: AnyPath): bool

isEmptyContainer:

• types: isEmptyContainer(t: PType): bool

isEmptyType:

• ast_query: isEmptyType(t: PType): bool

isEnabled:

• options: isEnabled(conf: ConfigRef; report: Report): bool
• options: isEnabled(conf: ConfigRef; report: ReportKind): bool

isEqual:

• TTypeRelation.isEqual

isError:

• ast_query: isError(n: PNode): bool
• ast_query: isError(s: PSym): bool
• ast_query: isError(t: PType): bool

isErrorLike:

• ast_query: isErrorLike(n: PNode): bool
• ast_query: isErrorLike(s: PSym): bool
• ast_query: isErrorLike(t: PType): bool

isException:

• types: isException(t: PType): bool

isFilled:

• cgendata: isFilled(x: ProcLoc): bool
• cgendata: isFilled(x: TLoc): bool
• modulelowering: isFilled(m: Module): bool

isFinal:

• types: isFinal(t: PType): bool

isfirstTopLevelStmt:

• semdata: isfirstTopLevelStmt(c: PContext): bool

isFloatLit:

• types: isFloatLit(t: PType): bool

isFromIntLit:

• TTypeRelation.isFromIntLit

isGCedMem:

• ast: isGCedMem(t: PType): bool

isGeneric:

• TTypeRelation.isGeneric

isGenericAlias:

• types: isGenericAlias(t: PType): bool

isGenericParams:

• ast_query: isGenericParams(n: PNode): bool

isGenericRoutine:

• ast_query: isGenericRoutine(n: PNode): bool
• ast_query: isGenericRoutine(s: PSym): bool

isGenericRoutineStrict:

• ast_query: isGenericRoutineStrict(s: PSym): bool

isHeaderFile:

• CodegenFlag.isHeaderFile

isImportedException:

• types: isImportedException(t: PType; conf: ConfigRef): bool

isInferred:

• TTypeRelation.isInferred

isInferredConvertible:

• TTypeRelation.isInferredConvertible

isInfixAs:

• ast_query: isInfixAs(n: PNode): bool

isInlineIterator:

• ast_query: isInlineIterator(typ: PType): bool

isIntConv:

• TTypeRelation.isIntConv

isIntLit:

• types: isIntLit(t: PType): bool

isIterator:

• lambdalifting: isIterator(owner: PSym): bool

isKeyword:

• lexer: isKeyword(i: PIdent): bool
• lexer: isKeyword(kind: TokType): bool

isKnown:

• lineinfos: isKnown(info: TLineInfo): bool

isLastRead:

• analysis: isLastRead(tree: MirTree; cfg: DataFlowGraph; span: Subgraph; loc: Path; start: InstrPos): bool

isLastWrite:

• analysis: isLastWrite(tree: MirTree; cfg: DataFlowGraph; span: Subgraph; loc: Path; start: InstrPos): bool

isLValue:

• parampatterns: isLValue(n: PNode): bool

isMetaType:

• ast_query: isMetaType(t: PType): bool

isNamed:

• mirtypes: isNamed(f: RecField): bool

isNil:

• ast_types: isNil(id: LibId): bool
• vmdef: isNil(p: VmMemPointer | CellPtr): bool
• vmdef: isNil(h: HeapSlotHandle): bool
• vmdef: isNil(x: VmFunctionPtr): bool

isNimIdentifier:

• lexer: isNimIdentifier(s: string): bool

isNoAlias:

• mirtypes: isNoAlias(f: RecField): bool

isNoMangle:

• mirtypes: isNoMangle(f: RecField): bool

isNone:

• TTypeRelation.isNone

isNoSideEffectPragma:

• trees: isNoSideEffectPragma(n: PNode): bool

isNotFound:

• idents: isNotFound(ic: IdentCache; i: PIdent): bool

isNotNil:

• vmdef: isNotNil(h: HeapSlotHandle): bool

isObjLackingTypeField:

• types: isObjLackingTypeField(typ: PType): bool

isOfBranch:

• compat: isOfBranch(n: CgNode): bool

isons:

• packed_ast: isons(dest: var PackedTree; tree: PackedTree; n: NodePos): (int, NodePos)

isOrdinalType:

• types: isOrdinalType(t: PType; allowEnumWithHoles: bool = false): bool

isOwnedBy:

• ast_query: isOwnedBy(a, b: PSym): bool

isPacked:

• mirtypes: isPacked(desc: TypeHeader; env: TypeEnv): bool

isPartOf:

• aliasanalysis: isPartOf(tree: MirTree; a, b: Path): Ternary
• aliases: isPartOf(a, b: PNode): TAnalysisResult
• aliases: isPartOf(a, b: PType): TAnalysisResult

isPassByRef:

• types: isPassByRef(conf: ConfigRef; s: PSym; retType: PType): bool

isPureObject:

• types: isPureObject(typ: PType): bool

isRange:

• trees: isRange(n: PNode): bool

isResolvedUserTypeClass:

• types: isResolvedUserTypeClass(t: PType): bool

isRoutine:

• ast_query: isRoutine(s: PSym): bool

isRunnableExamples:

• ast_query: isRunnableExamples(n: PNode): bool

isSame:

• aliasanalysis: isSame(r: CmpLocsResult): bool

isShadowScope:

• lookups: isShadowScope(s: PScope): bool

isSinkParam:

• ast_query: isSinkParam(s: PSym): bool

isSinkType:

• ast_query: isSinkType(t: PType): bool

isSinkTypeForParam:

• types: isSinkTypeForParam(t: PType): bool

isSubrange:

• TTypeRelation.isSubrange

isSubtype:

• TTypeRelation.isSubtype

isTopLevel:

• semdata: isTopLevel(c: PContext): bool

isTopLevelInsideDeclaration:

• semdata: isTopLevelInsideDeclaration(c: PContext; sym: PSym): bool

isTracked:

• suggest: isTracked(current, trackPos: TLineInfo; tokenLen: int): bool

isTrue:

• trees: isTrue(n: PNode): bool

isTupleRecursive:

• types: isTupleRecursive(t: PType): bool

isUnresolvedStatic:

• ast_query: isUnresolvedStatic(t: PType): bool

isUnresolvedSym:

• ast_query: isUnresolvedSym(s: PSym): bool

isUnsigned:

• types: isUnsigned(t: PType): bool

isValid:

• reports: isValid(point: ReportLineInfo): bool
• vmdef: isValid(handle: LocHandle): bool
• vmdef: isValid(t: PVmType): bool
• vmmemory: isValid(heap: VmHeap; slot: HeapSlotHandle): bool

isVSCompatible:

• extccomp: isVSCompatible(conf: ConfigRef): bool

ItemId:

• ast_types: ItemId

items:

• astalgo: items(tab: TStrTable): PSym
• ast_parsed_types: items(node: ParsedNode): ParsedNode
• ast_query: items(n: PNode): PNode
• cgir: items(n: CgNode): CgNode
• mirenv: items[I, T](tab: SymbolTable[I, T]): (I, lent T)
• containers: items[I, T](x: Store[I, T]): lent T
• idioms: items[T](s: HOslice[T]): T

iteratorPragmas:

• pragmas: iteratorPragmas

iterOverType:

• types: iterOverType(t: PType; iter: TTypeIter; closure: RootRef): bool

iterToProcImpl:

• itersgen: iterToProcImpl(c: PContext; n: PNode): PNode

ithSon:

• packed_ast: ithSon(tree: PackedTree; n: NodePos; i: int): NodePos

JitState:

• vmjit: JitState

jmpDiff:

• vmdef: jmpDiff(x: TInstr): int

join:

• mirconstr: join(bu: var MirBuilder; label: LabelId)
• containers: join[I; T](s: var Store[I, T]; other: sink PartialStore[I, T])

joinAnyOf:

• msgs: joinAnyOf[T](values: seq[T]; quote: bool = false): string

jsonBuildInstructionsFile:

• extccomp: jsonBuildInstructionsFile(conf: ConfigRef): AbsoluteFile

JsonExt:

• options: JsonExt

kAlreadyGiven:

• MismatchKind.kAlreadyGiven

kDontCare:

• Keep.kDontCare

Keep:

• proto_mir: Keep

kExtraArg:

• MismatchKind.kExtraArg

kGenericTypeMismatch:

• MismatchKind.kGenericTypeMismatch

kind:

• checked_ast: kind(x: CheckedAst): TNodeKind
• reports: kind(report: Report): ReportKind
• packed_ast: kind(tree: PackedTree; n: NodePos): TNodeKind
• packed_ast: kind(n: NodePos): TNodeKind

kLvalue:

• Keep.kLvalue

kMissingParam:

• MismatchKind.kMissingParam

kMutLvalue:

• Keep.kMutLvalue

kNotGeneric:

• MismatchKind.kNotGeneric

kPositionalAlreadyGiven:

• MismatchKind.kPositionalAlreadyGiven

kTypeMismatch:

• MismatchKind.kTypeMismatch

kUnknown:

• MismatchKind.kUnknown

kUnknownNamedParam:

• MismatchKind.kUnknownNamedParam

kVarNeeded:

• MismatchKind.kVarNeeded

LabelId:

• mirtrees: LabelId

labelNode:

• mirgen_blocks: labelNode(label: LabelId): MirNode

LabelNodes:

• mirtrees: LabelNodes

lacksMTypeField:

• types: lacksMTypeField(typ: PType): bool

lambdaPragmas:

• pragmas: lambdaPragmas

largeInstrs:

• vm_enums: largeInstrs

last:

• mirtrees: last(tree: MirTree; n: NodePosition): NodePosition

LastCallConv:

• pragmas: LastCallConv

lastFloat:

• types: lastFloat(t: PType): BiggestFloat

lastOptionEntry:

• semdata: lastOptionEntry(c: PContext): POptionEntry

lastOrd:

• types: lastOrd(conf: ConfigRef; t: PType): Int128

lastOverloadScope:

• lookups: lastOverloadScope(o: TOverloadIter): int

lastSon:

• ast_query: lastSon(n: Indexable): Indexable
• compat: lastSon(n: CgNode): CgNode
• packed_ast: lastSon(tree: PackedTree; n: NodePos): NodePos

LayeredIdTable:

• semtypinst: LayeredIdTable

LazyInstantiation:

• modulegraphs: LazyInstantiation

lazyPaths:

• options: lazyPaths(conf`gensym60: ConfigRef): seq[AbsoluteDir]

lazyPaths=:

• options: lazyPaths=(conf`gensym60: ConfigRef; val`gensym60: seq[AbsoluteDir])

lazyPathsAdd:

• options: lazyPathsAdd(conf`gensym59: ConfigRef; item`gensym59: AbsoluteDir | seq[AbsoluteDir])

LazySym:

• modulegraphs: LazySym

LazyType:

• modulegraphs: LazyType

leave:

• vmprofiler: leave(prof: var Profiler; frames: openArray[TStackFrame])

legacyConsiderQuotedIdent:

• lookups: legacyConsiderQuotedIdent(c: PContext; n, origin: PNode): PIdent

legacyReportBridge:

• cli_reporter: legacyReportBridge(conf: ConfigRef; diag: PAstDiag): Report

legacyReportsVmTracer:

• vmlegacy: legacyReportsVmTracer(c: TCtx; t: VmExecTrace)

len:

• ast_parsed_types: len(node: ParsedNode): int
• ast_types: len(n: Indexable): int
• checked_ast: len(x: CheckedAst): int
• cgir: len(n: CgNode): int
• bitabs: len[T](t: BiTable[T]): int
• packed_ast: len(tree: PackedTree): int
• datatables: len(t: DataTable): int
• mirconstr: len(f: Fragment): int
• mirconstr: len(b: MirBuffer): int
• mirenv: len[I, T](tab: SymbolTable[I, T]): int
• mirtrees: len(tree: MirTree; n: NodePosition): int
• btrees: len[Key, Val](b: BTree[Key, Val]): int
• containers: len[I; T](x: OrdinalSeq[I, T]): int
• cursors: len[T: seq](s: Cursor[T]): int
• idioms: len[T](x: HOslice[T]): int
• vmdef: len(s: VmString): int

lengthOrd:

• types: lengthOrd(conf: ConfigRef; t: PType): Int128

letPragmas:

• pragmas: letPragmas

Letters:

• linter: Letters

leValue:

• astalgo: leValue(a, b: PNode): bool

leValueConv:

• semfold: leValueConv(a, b: PNode): bool

Level:

• mirtypes: Level

lexDiagDeprecatedOctalPrefix:

• LexerDiagKind.lexDiagDeprecatedOctalPrefix

lexDiagExpectedHex:

• LexerDiagKind.lexDiagExpectedHex

lexDiagInvalidCharLiteral:

• LexerDiagKind.lexDiagInvalidCharLiteral

lexDiagInvalidCharLiteralConstant:

• LexerDiagKind.lexDiagInvalidCharLiteralConstant

lexDiagInvalidCharLiteralPlatformNewline:

• LexerDiagKind.lexDiagInvalidCharLiteralPlatformNewline

lexDiagInvalidCharLiteralUnicodeCodepoint:

• LexerDiagKind.lexDiagInvalidCharLiteralUnicodeCodepoint

lexDiagInvalidIntegerLiteral:

• LexerDiagKind.lexDiagInvalidIntegerLiteral

lexDiagInvalidIntegerLiteralOctalPrefix:

• LexerDiagKind.lexDiagInvalidIntegerLiteralOctalPrefix

lexDiagInvalidIntegerSuffix:

• LexerDiagKind.lexDiagInvalidIntegerSuffix

lexDiagInvalidNumericLiteral:

• LexerDiagKind.lexDiagInvalidNumericLiteral

lexDiagInvalidToken:

• LexerDiagKind.lexDiagInvalidToken

lexDiagInvalidTokenSpaceBetweenNumAndIdent:

• LexerDiagKind.lexDiagInvalidTokenSpaceBetweenNumAndIdent

lexDiagInvalidUnicodeCodepointEmpty:

• LexerDiagKind.lexDiagInvalidUnicodeCodepointEmpty

lexDiagInvalidUnicodeCodepointGreaterThan0x10FFFF:

• LexerDiagKind.lexDiagInvalidUnicodeCodepointGreaterThan0x10FFFF

lexDiagLineTooLong:

• LexerDiagKind.lexDiagLineTooLong

lexDiagMalformedIdentUnderscores:

• LexerDiagKind.lexDiagMalformedIdentUnderscores

lexDiagMalformedNumUnderscores:

• LexerDiagKind.lexDiagMalformedNumUnderscores

lexDiagMalformedTrailingUnderscre:

• LexerDiagKind.lexDiagMalformedTrailingUnderscre

lexDiagMissingClosingApostrophe:

• LexerDiagKind.lexDiagMissingClosingApostrophe

lexDiagNameXShouldBeY:

• LexerDiagKind.lexDiagNameXShouldBeY

lexDiagNoTabs:

• LexerDiagKind.lexDiagNoTabs

lexDiagNumberNotInRange:

• LexerDiagKind.lexDiagNumberNotInRange

LexDiagsError:

• lexer: LexDiagsError

LexDiagsHint:

• lexer: LexDiagsHint

LexDiagsWarning:

• lexer: LexDiagsWarning

lexDiagToLegacyReportKind:

• msgs: lexDiagToLegacyReportKind(diag: LexerDiagKind): ReportKind

lexDiagUnclosedComment:

• LexerDiagKind.lexDiagUnclosedComment

lexDiagUnclosedSingleString:

• LexerDiagKind.lexDiagUnclosedSingleString

lexDiagUnclosedTripleString:

• LexerDiagKind.lexDiagUnclosedTripleString

Lexer:

• lexer: Lexer

LexerDiag:

• lexer: LexerDiag

LexerDiagKind:

• lexer: LexerDiagKind

lexerDiagToLegacyReport:

• msgs: lexerDiagToLegacyReport(diag: LexerDiag): Report

LexerReport:

• reports_lexer: LexerReport

LexerReportKind:

• report_enums: LexerReportKind

LF:

• nimlexbase: LF

lfEnforceDeref:

• LocFlag.lfEnforceDeref

lfIndirect:

• LocFlag.lfIndirect

lfSingleUse:

• LocFlag.lfSingleUse

lfWantLvalue:

• LocFlag.lfWantLvalue

libDynamic:

• TLibKind.libDynamic

libHeader:

• TLibKind.libHeader

LibId:

• ast_types: LibId

libpath:

• options: libpath(conf`gensym25: ConfigRef): AbsoluteDir

libpath=:

• options: libpath=(conf`gensym25: ConfigRef; val`gensym25: AbsoluteDir)

libs:

• semdata: libs(c: PContext): (LibId, var TLib)

libsSection:

• RodSection.libsSection

liftForLoop:

• lambdalifting: liftForLoop(g: ModuleGraph; body: PNode; idgen: IdGenerator; owner, breakLabel: PSym): PNode

liftIterSym:

• lambdalifting: liftIterSym(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner, currEnv: PSym): PNode

liftIterToProc:

• lambdalifting: liftIterToProc(g: ModuleGraph; fn: PSym; body: PNode; ptrType: PType; idgen: IdGenerator): PNode

liftLambdas:

• lambdalifting: liftLambdas(g: ModuleGraph; fn: PSym; body: PNode; idgen: IdGenerator): tuple[ body: PNode, env: PSym]

liftLambdasForTopLevel:

• lambdalifting: liftLambdasForTopLevel(module: PSym; body: PNode): PNode

liftTypeBoundOps:

• liftdestructors: liftTypeBoundOps(c: PContext; typ: PType; info: TLineInfo)

LineColPair:

• lineinfos: LineColPair

LinkIndex:

• vmdef: LinkIndex

linkOptionsCmd:

• options: linkOptionsCmd(conf`gensym52: ConfigRef): seq[string]

linkOptionsCmd=:

• options: linkOptionsCmd=(conf`gensym52: ConfigRef; val`gensym52: seq[string])

linkOptionsCmdAdd:

• options: linkOptionsCmdAdd(conf`gensym51: ConfigRef; item`gensym51: string | seq[string])

linkTo:

• ast: linkTo(s: PSym; t: PType): PSym
• ast: linkTo(t: PType; s: PSym): PType

listCCnames:

• extccomp: listCCnames(): seq[string]

listCPUnames:

• platform: listCPUnames(): seq[string]

listHints:

• msgs: listHints(conf: ConfigRef)

listOSnames:

• platform: listOSnames(): seq[string]

listSymbolNames:

• astalgo: listSymbolNames(symbols: openArray[PSym]): string

listWarnings:

• msgs: listWarnings(conf: ConfigRef)

literal:

• mirconstr: literal(ast: AstId; typ: TypeId): Value
• mirconstr: literal(kind: range[mnkIntLit .. mnkFloatLit]; n: NumberId; typ: TypeId): Value
• mirconstr: literal(str: StringId; typ: TypeId): Value

Literal:

• ExprKind.Literal

LiteralDataNodes:

• mirtrees: LiteralDataNodes

LitId:

• bitabs: LitId

litId:

• packed_ast: litId(tree: PackedTree; n: NodePos): LitId
• packed_ast: litId(n: NodePos): LitId

llsFile:

• TLLStreamKind.llsFile

llsNone:

• TLLStreamKind.llsNone

llsStdIn:

• TLLStreamKind.llsStdIn

llsString:

• TLLStreamKind.llsString

llStreamClose:

• llstream: llStreamClose(s: PLLStream)

llStreamOpen:

• llstream: llStreamOpen(): PLLStream
• llstream: llStreamOpen(filename: AbsoluteFile; mode: FileMode): PLLStream
• llstream: llStreamOpen(f: File): PLLStream
• llstream: llStreamOpen(data: string): PLLStream

llStreamOpenStdIn:

• llstream: llStreamOpenStdIn(r: TLLRepl = llReadFromStdin; onPrompt: OnPrompt = nil): PLLStream

llStreamRead:

• llstream: llStreamRead(s: PLLStream; buf: pointer; bufLen: int): int

llStreamReadAll:

• llstream: llStreamReadAll(s: PLLStream): string

llStreamReadLine:

• llstream: llStreamReadLine(s: PLLStream; line: var string): bool

llStreamWrite:

• llstream: llStreamWrite(s: PLLStream; data: char)
• llstream: llStreamWrite(s: PLLStream; buf: pointer; buflen: int)
• llstream: llStreamWrite(s: PLLStream; data: string)

llStreamWriteln:

• llstream: llStreamWriteln(s: PLLStream; data: string)

load:

• bitabs: load[T](f: var RodFile; t: var BiTable[T])

loadCompilerProc:

• modulegraphs: loadCompilerProc(g: ModuleGraph; name: string): PSym

loadConfigs:

• cmdlinehelper: loadConfigs(cfg: RelativeFile; cache: IdentCache; conf: ConfigRef; stopOnError = true): bool
• nimconf: loadConfigs(cfg: RelativeFile; cache: IdentCache; conf: ConfigRef; evtHandler: NimConfEvtWriter; stopOnError: bool = true): bool

loadConfigsAndProcessCmdLine:

• cmdlinehelper: loadConfigsAndProcessCmdLine(self: NimProg; cache: IdentCache; conf: ConfigRef; graph: ModuleGraph; argv: openArray[string]): bool

loadConfigsAndRunMainCommand:

• cmdlinehelper: loadConfigsAndRunMainCommand(self: NimProg; cache: IdentCache; conf: ConfigRef; graph: ModuleGraph; argv: openArray[string]): bool

loaded:

• ModuleStatus.loaded

LoadedModule:

• ic: LoadedModule

loadEmptyReg:

• vm: loadEmptyReg(r: var TFullReg; typ: PVmType; info: TLineInfo; mm: var VmMemoryManager): bool

loadEnv:

• packed_env: loadEnv(dst: var TCtx; src: PackedEnv)

loadFullSlice:

• vmmemory: loadFullSlice(a: VmAllocator; cp: CellPtr; typ: PVmType): VmSlice

loadHeader:

• rodfiles: loadHeader(f: var RodFile)

loading:

• ModuleStatus.loading

loadLibs:

• ic: loadLibs(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: int): seq[TLib]

loadNodes:

• ic: loadNodes(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int; tree: PackedTree; n: NodePos): PNode

loadPackedSym:

• modulegraphs: loadPackedSym(g: ModuleGraph; s: var LazySym)

loadPrim:

• rodfiles: loadPrim(f: var RodFile; s: var string)
• rodfiles: loadPrim[T](f: var RodFile; x: var T)

loadProc:

• vmjit: loadProc(jit: var JitState; c: var TCtx; sym: PSym): VmGenResult

loadProcBody:

• ic: loadProcBody(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; s: PSym): PNode

loadRodFile:

• ic: loadRodFile(filename: AbsoluteFile; m: var PackedModule; config: ConfigRef; ignoreConfig = false): RodFileError

loadSection:

• rodfiles: loadSection(f: var RodFile; expected: RodSection)

loadSeq:

• rodfiles: loadSeq[T](f: var RodFile; s: var seq[T])

loadSliceList:

• packed_env: loadSliceList[T: SliceListType](p: PackedEnv; id: uint32): seq[Slice[T]]

loadSymFromId:

• ic: loadSymFromId(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: int; id: PackedItemId): PSym

loadTypeFromId:

• ic: loadTypeFromId(config: ConfigRef; cache: IdentCache; g: var PackedModuleGraph; module: int; id: PackedItemId): PType

loadTypeInfos:

• packed_env: loadTypeInfos(p: PackedEnv; types: seq[PVmType]): seq[VmTypeInfo]

Local:

• mirbodies: Local

LocalId:

• mirtrees: LocalId

localOptions:

• options: localOptions(conf`gensym62: ConfigRef): TOptions

localOptions=:

• options: localOptions=(conf`gensym62: ConfigRef; val`gensym62: TOptions)

localReport:

• errorreporting: localReport(conf: ConfigRef; node: PNode)
• msgs: localReport(conf: ConfigRef; node: PNode; report: SemReport)
• msgs: localReport(conf: ConfigRef; report: Report)
• msgs: localReport(conf: ConfigRef; report: ReportTypes)
• msgs: localReport(conf: ConfigRef; info: TLineInfo; report: ReportTypes)
• msgs: localReport(conf: ConfigRef; info: TLineInfo; report: ReportTypes)

Locals:

• mirbodies: Locals

localScopesFrom:

• lookups: localScopesFrom(c: PContext; scope: PScope): PScope

localSearchInScope:

• lookups: localSearchInScope(c: PContext; s: PIdent): PSym

location:

• reports: location(report: Report): Option[TLineInfo]

locCall:

• TLocKind.locCall

locData:

• TLocKind.locData

locExpr:

• TLocKind.locExpr

LocFlag:

• cgendata: LocFlag

locGlobalVar:

• TLocKind.locGlobalVar

LocHandle:

• vmdef: LocHandle

locLocalVar:

• TLocKind.locLocalVar

locNone:

• TLocKind.locNone

locOther:

• TLocKind.locOther

locParam:

• TLocKind.locParam

locTemp:

• TLocKind.locTemp

logError:

• commands: logError(conf: ConfigRef; evt: CliEvent)
• commands: logError(conf: ConfigRef; msg: string; srcLoc = instLoc())

logExecStart:

• commands: logExecStart(conf: ConfigRef; cmd: string; srcLoc = instLoc())

logGcStats:

• commands: logGcStats(conf: ConfigRef; stats: string; srcLoc = instLoc())

lookUp:

• lookups: lookUp(c: PContext; n: PNode): PSym

lookup:

• identpatterns: lookup(patterns: Patterns; s: PSym): int
• vmtypegen: lookup(c: TypeInfoCache; conf: ConfigRef; typ: PType): Option[PVmType]

lookupField:

• mirtypes: lookupField(env: TypeEnv; typ: TypeId; pos: int32): FieldId

lookupFieldAgain:

• types: lookupFieldAgain(ty: PType; field: PSym): PSym

lookupInRecord:

• astalgo: lookupInRecord(n: PNode; pos: int): PSym
• astalgo: lookupInRecord(n: PNode; field: PIdent): PSym

lookupInType:

• types: lookupInType(ty: PType; position: int): PSym

low:

• int128: low(t: typedesc[Int128]): Int128

lowBound:

• guards: lowBound(conf: ConfigRef; x: PNode): PNode

lowerBranchSwitch:

• injectdestructors: lowerBranchSwitch(tree: MirTree; g: ModuleGraph; idgen: IdGenerator; env: var MirEnv; changes: var Changeset)

lowerChecks:

• rtchecks: lowerChecks(body; graph; env; changes: var Changeset)

Lowered:

• Level.Lowered

lowerTupleUnpacking:

• lowerings: lowerTupleUnpacking(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PNode

lowerTupleUnpackingForAsgn:

• lowerings: lowerTupleUnpackingForAsgn(g: ModuleGraph; n: PNode; idgen: IdGenerator; owner: PSym): PNode

lpairs:

• mirtrees: lpairs[T](x: seq[T]): (int, lent T)

Lrz:

• nimlexbase: Lrz

Lvalue:

• ExprKind.Lvalue

LvalueExprKinds:

• mirtrees: LvalueExprKinds

mAbsI:

• TMagic.mAbsI

mAccessEnv:

• TMagic.mAccessEnv

mAccessTypeField:

• TMagic.mAccessTypeField

macroOps:

• vmops: macroOps(): Override

macroPragmas:

• pragmas: macroPragmas

macrosToExpand:

• options: macrosToExpand(conf`gensym74: ConfigRef): StringTableRef

macrosToExpand=:

• options: macrosToExpand=(conf`gensym74: ConfigRef; val`gensym74: StringTableRef)

macrosToExpandDel:

• options: macrosToExpandDel(conf`gensym73: ConfigRef; key`gensym73: string)

macrosToExpandGet:

• options: macrosToExpandGet(conf`gensym73: ConfigRef; key`gensym73: string): string

macrosToExpandSet:

• options: macrosToExpandSet(conf`gensym73: ConfigRef; key`gensym73: string; value`gensym73: string)

macroUsagesSection:

• RodSection.macroUsagesSection

mAddF64:

• TMagic.mAddF64

mAddI:

• TMagic.mAddI

mAddr:

• TMagic.mAddr

mAddU:

• TMagic.mAddU

magicsThatCanRaise:

• ast_query: magicsThatCanRaise

MagicsToKeep:

• vmgen: MagicsToKeep

mainCommand:

• main: mainCommand(graph: ModuleGraph)

mainCommandArg:

• options: mainCommandArg(conf: ConfigRef): string

mainModule:

• modulelowering: mainModule(modules: ModuleList): lent Module

mainPackageNotes:

• options: mainPackageNotes(conf: ConfigRef): ReportKinds

mainPackageNotes=:

• options: mainPackageNotes=(conf: ConfigRef; nset: ReportKinds)

makeClosure:

• lambdalifting: makeClosure(g: ModuleGraph; idgen: IdGenerator; prc: PSym; env: PNode; info: TLineInfo): PNode

makeCString:

• options: makeCString(s: string): string

makeInstPair:

• semdata: makeInstPair(s: PSym; inst: PInstantiation): TInstantiationPair

makeLocHandle:

• vmmemory: makeLocHandle(a: VmAllocator; cp: CellPtr; offset: Natural; typ: PVmType): LocHandle
• vmmemory: makeLocHandle(a: VmAllocator; p: pointer; typ: PVmType): LocHandle

makeModule:

• modules: makeModule(graph: ModuleGraph; filename: AbsoluteFile): PSym
• modules: makeModule(graph: ModuleGraph; filename: string): PSym

makePass:

• passes: makePass(open: TPassOpen = nil; process: TPassProcess = nil; close: TPassClose = nil; isFrontend = false): TPass

makePtrType:

• semdata: makePtrType(c: PContext; baseType: PType): PType
• semdata: makePtrType(owner: PSym; baseType: PType; idgen: IdGenerator): PType

makeRangeType:

• semdata: makeRangeType(c: PContext; first, last: BiggestInt; info: TLineInfo; intType: PType = nil): PType

makeRangeWithStaticExpr:

• semdata: makeRangeWithStaticExpr(c: PContext; n: PNode): PType

makeRefType:

• semdata: makeRefType(conf: ConfigRef; typ: PType; idgen: IdGenerator): PType

makeSignatureId:

• vmtypegen: makeSignatureId(c: var TypeInfoCache; typ: PType): RoutineSigId

makeSingleLineCString:

• ccgutils: makeSingleLineCString(s: string): string

makeStaticExpr:

• semdata: makeStaticExpr(c: PContext; n: PNode): PNode

makeStdinModule:

• modules: makeStdinModule(graph: ModuleGraph): PSym

makeStmtList:

• ast: makeStmtList(n: PNode): PNode

makeTreeEquivalenceProc:

• trees: makeTreeEquivalenceProc(name, relaxedKindCheck, symCheck, floatCheck, typeCheck, commentCheck)

makeTypeDesc:

• semdata: makeTypeDesc(c: PContext; typ: PType): PType

makeTypeFromExpr:

• semdata: makeTypeFromExpr(c: PContext; n: PNode): PType

makeTypeSymNode:

• semdata: makeTypeSymNode(c: PContext; typ: PType; info: TLineInfo): PNode

makeTypeWithModifier:

• semdata: makeTypeWithModifier(c: PContext; modifier: TTypeKind; baseType: PType): PType

makeVarType:

• semdata: makeVarType(c: PContext; baseType: PType; kind = tyVar): PType
• semdata: makeVarType(owner: PSym; baseType: PType; idgen: IdGenerator; kind = tyVar): PType

mAlignOf:

• TMagic.mAlignOf

mAnd:

• TMagic.mAnd

mangle:

• ccgutils: mangle(name: string): string

mapList:

• packed_env: mapList[D, S](d: seq[D]; s: openArray[S]; it: untyped; code)

mAppendSeqElem:

• TMagic.mAppendSeqElem

mAppendStrCh:

• TMagic.mAppendStrCh

mAppendStrStr:

• TMagic.mAppendStrStr

Mapping:

• sourcemap: Mapping

mapPointerToCell:

• vmmemory: mapPointerToCell(a: VmAllocator; p: CellPtr): CellId

mAppType:

• TMagic.mAppType

mapToCell:

• vmmemory: mapToCell(a: VmAllocator; p: CellPtr): lent VmCell

markClientsDirty:

• modulegraphs: markClientsDirty(g: ModuleGraph; fileIdx: FileIndex)

markDirty:

• modulegraphs: markDirty(g: ModuleGraph; fileIdx: FileIndex)

markIndirect:

• semdata: markIndirect(c: PContext; s: PSym)

markOwnerModuleAsUsed:

• semdata: markOwnerModuleAsUsed(c: PContext; s: PSym)

markUsed:

• semdata: markUsed(c: PContext; info: TLineInfo; s: PSym)

mArray:

• TMagic.mArray

mArrGet:

• TMagic.mArrGet

mArrPut:

• TMagic.mArrPut

mArrToSeq:

• TMagic.mArrToSeq

mAsgn:

• TMagic.mAsgn

mAsgnDynlibVar:

• TMagic.mAsgnDynlibVar

mAshrI:

• TMagic.mAshrI

maskBytes:

• int128: maskBytes(arg: Int128; numbytes: int): Int128

maskUInt16:

• int128: maskUInt16(arg: Int128): Int128

maskUInt32:

• int128: maskUInt32(arg: Int128): Int128

maskUInt64:

• int128: maskUInt64(arg: Int128): Int128

maskUInt8:

• int128: maskUInt8(arg: Int128): Int128

mAstToStr:

• TMagic.mAstToStr

matches:

• sigmatch: matches(c: PContext; n, nOrig: PNode; m: var TCandidate)

matchesGenericParams:

• sigmatch: matchesGenericParams(c: PContext; args: PNode; m: var TCandidate)

matchNodeKinds:

• parampatterns: matchNodeKinds(p, n: PNode): bool

matchType:

• types: matchType(a: PType; pattern: openArray[tuple[k: TTypeKind, i: int]]; last: TTypeKind): bool

matchUserTypeClass:

• sigmatch: matchUserTypeClass(m: var TCandidate; ff, a: PType): PType

materialize:

• mirconstr: materialize(bu: var MirBuilder; loc: Value): Value

materializeMove:

• mirconstr: materializeMove(bu: var MirBuilder; loc: Value): Value

Max:

• int128: Max

maxInstantiation:

• ast_types: maxInstantiation

MaxLineLength:

• lexer: MaxLineLength

MaxLockLevel:

• ast_query: MaxLockLevel

MaxSetElements:

• nversion: MaxSetElements

MaxStackSize:

• parampatterns: MaxStackSize

maybe:

• Ternary.maybe

MaybeNil:

• Nilability.MaybeNil

maybeResemArgs:

• sem: maybeResemArgs(c: PContext; n: PNode; startIdx: int = 1): seq[PNode]

mBitandI:

• TMagic.mBitandI

mBitnotI:

• TMagic.mBitnotI

mBitorI:

• TMagic.mBitorI

mbitSet:

• vmobjects: mbitSet(handle: LocHandle): untyped

mBitxorI:

• TMagic.mBitxorI

mBool:

• TMagic.mBool

mBoolDefine:

• TMagic.mBoolDefine

mBoolToStr:

• TMagic.mBoolToStr

mBuildCPU:

• TMagic.mBuildCPU

mBuildOS:

• TMagic.mBuildOS

mBuiltinType:

• TMagic.mBuiltinType

mCard:

• TMagic.mCard

mChar:

• TMagic.mChar

mCharToStr:

• TMagic.mCharToStr

mChckBounds:

• TMagic.mChckBounds

mChckField:

• TMagic.mChckField

mChckIndex:

• TMagic.mChckIndex

mChckNaN:

• TMagic.mChckNaN

mChckObj:

• TMagic.mChckObj

mChckRange:

• TMagic.mChckRange

mChr:

• TMagic.mChr

mCompileDate:

• TMagic.mCompileDate

mCompileOption:

• TMagic.mCompileOption

mCompileOptionArg:

• TMagic.mCompileOptionArg

mCompiles:

• TMagic.mCompiles

mCompileTime:

• TMagic.mCompileTime

mConStrStr:

• TMagic.mConStrStr

mCopyInternal:

• TMagic.mCopyInternal

mCpuEndian:

• TMagic.mCpuEndian

mCstring:

• TMagic.mCstring

mCStrToStr:

• TMagic.mCStrToStr

mDec:

• TMagic.mDec

mDeclared:

• TMagic.mDeclared

mDeclaredInScope:

• TMagic.mDeclaredInScope

mDeepCopy:

• TMagic.mDeepCopy

mDefault:

• TMagic.mDefault

mDefined:

• TMagic.mDefined

mDestroy:

• TMagic.mDestroy

mDistinct:

• TMagic.mDistinct

mDivF64:

• TMagic.mDivF64

mDivI:

• TMagic.mDivI

mDivU:

• TMagic.mDivU

mDotDot:

• TMagic.mDotDot

mEcho:

• TMagic.mEcho

mEnumToStr:

• TMagic.mEnumToStr

mEqB:

• TMagic.mEqB

mEqCh:

• TMagic.mEqCh

mEqCString:

• TMagic.mEqCString

mEqEnum:

• TMagic.mEqEnum

mEqF64:

• TMagic.mEqF64

mEqI:

• TMagic.mEqI

mEqIdent:

• TMagic.mEqIdent

mEqNimrodNode:

• TMagic.mEqNimrodNode

mEqProc:

• TMagic.mEqProc

mEqRef:

• TMagic.mEqRef

mEqSet:

• TMagic.mEqSet

mEqStr:

• TMagic.mEqStr

merge:

• cgir: merge(dest: var Body; source: Body): CgNode
• sourcemaps: merge(dst: var SourceMap; tree: var MirTree; src: sink SourceMap)
• containers: merge[I; T](dst: var Store[I, T]; src: sink Store[I, T]): Option[I]

mergeShadowScope:

• lookups: mergeShadowScope(c: PContext)

methodCall:

• cgmeth: methodCall(n: PNode; conf: ConfigRef): PNode

methodDef:

• cgmeth: methodDef(g: ModuleGraph; idgen: IdGenerator; s: PSym)

methodPragmas:

• pragmas: methodPragmas

methodsForGeneric:

• modulegraphs: methodsForGeneric(g: ModuleGraph; t: PType): (int, PSym)

methodsPerTypeSection:

• RodSection.methodsPerTypeSection

methodsSection:

• RodSection.methodsSection

mEvalToAst:

• TMagic.mEvalToAst

mException:

• TMagic.mException

mExcl:

• TMagic.mExcl

mExit:

• TMagic.mExit

mExpandToAst:

• TMagic.mExpandToAst

mExpr:

• TMagic.mExpr

mFieldPairs:

• TMagic.mFieldPairs

mFields:

• TMagic.mFields

mFinished:

• TMagic.mFinished

mFloat:

• TMagic.mFloat

mFloat32:

• TMagic.mFloat32

mFloat64:

• TMagic.mFloat64

mFloatToStr:

• TMagic.mFloatToStr

mGCref:

• TMagic.mGCref

mGCunref:

• TMagic.mGCunref

mGetImpl:

• TMagic.mGetImpl

mGetImplTransf:

• TMagic.mGetImplTransf

mgetOrPut:

• typemaps: mgetOrPut[T](t: var TypeTable; key: PType; val: T): var T

mGetTypeInfo:

• TMagic.mGetTypeInfo

mGetTypeInfoV2:

• TMagic.mGetTypeInfoV2

mHigh:

• TMagic.mHigh

mHostCPU:

• TMagic.mHostCPU

mHostOS:

• TMagic.mHostOS

Min:

• int128: Min

mInc:

• TMagic.mInc

mIncl:

• TMagic.mIncl

mInSet:

• TMagic.mInSet

mInstantiationInfo:

• TMagic.mInstantiationInfo

mInt:

• TMagic.mInt

mInt16:

• TMagic.mInt16

mInt32:

• TMagic.mInt32

mInt64:

• TMagic.mInt64

mInt64ToStr:

• TMagic.mInt64ToStr

mInt8:

• TMagic.mInt8

mIntDefine:

• TMagic.mIntDefine

mIntToStr:

• TMagic.mIntToStr

MirBody:

• mirbodies: MirBody

MirBuilder:

• mirconstr: MirBuilder

MirEnv:

• mirenv: MirEnv

MirNode:

• mirtrees: MirNode

MirNodeKind:

• mirtrees: MirNodeKind

MirNodeSeq:

• mirtrees: MirNodeSeq

MirTree:

• mirtrees: MirTree

mIs:

• TMagic.mIs

miscPos:

• ast_query: miscPos

mIsMainModule:

• TMagic.mIsMainModule

MismatchInfo:

• ast_types: MismatchInfo

MismatchKind:

• ast_types: MismatchKind

mIsNil:

• TMagic.mIsNil

mIsolate:

• TMagic.mIsolate

mIsPartOf:

• TMagic.mIsPartOf

mitems:

• containers: mitems[I; T](x: var Store[I, T]): var T

mLeB:

• TMagic.mLeB

mLeCh:

• TMagic.mLeCh

mLeEnum:

• TMagic.mLeEnum

mLeF64:

• TMagic.mLeF64

mLeI:

• TMagic.mLeI

mLengthArray:

• TMagic.mLengthArray

mLengthOpenArray:

• TMagic.mLengthOpenArray

mLengthSeq:

• TMagic.mLengthSeq

mLengthStr:

• TMagic.mLengthStr

mLePtr:

• TMagic.mLePtr

mLeSet:

• TMagic.mLeSet

mLeStr:

• TMagic.mLeStr

mLeU:

• TMagic.mLeU

mLow:

• TMagic.mLow

mLtB:

• TMagic.mLtB

mLtCh:

• TMagic.mLtCh

mLtEnum:

• TMagic.mLtEnum

mLtF64:

• TMagic.mLtF64

mLtI:

• TMagic.mLtI

mLtPtr:

• TMagic.mLtPtr

mLtSet:

• TMagic.mLtSet

mLtStr:

• TMagic.mLtStr

mLtU:

• TMagic.mLtU

mMaxI:

• TMagic.mMaxI

mMinI:

• TMagic.mMinI

mMinusSet:

• TMagic.mMinusSet

mModI:

• TMagic.mModI

mModU:

• TMagic.mModU

mMove:

• TMagic.mMove

mMulF64:

• TMagic.mMulF64

mMulI:

• TMagic.mMulI

mMulSet:

• TMagic.mMulSet

mMulU:

• TMagic.mMulU

mNAdd:

• TMagic.mNAdd

mNAddMultiple:

• TMagic.mNAddMultiple

mNBindSym:

• TMagic.mNBindSym

mNCallSite:

• TMagic.mNCallSite

mNccInc:

• TMagic.mNccInc

mNccValue:

• TMagic.mNccValue

mNChild:

• TMagic.mNChild

mNCopyNimNode:

• TMagic.mNCopyNimNode

mNCopyNimTree:

• TMagic.mNCopyNimTree

mNcsAdd:

• TMagic.mNcsAdd

mNcsAt:

• TMagic.mNcsAt

mNcsIncl:

• TMagic.mNcsIncl

mNcsLen:

• TMagic.mNcsLen

mNctGet:

• TMagic.mNctGet

mNctHasNext:

• TMagic.mNctHasNext

mNctLen:

• TMagic.mNctLen

mNctNext:

• TMagic.mNctNext

mNctPut:

• TMagic.mNctPut

mNDel:

• TMagic.mNDel

mNError:

• TMagic.mNError

mNew:

• TMagic.mNew

mNewSeq:

• TMagic.mNewSeq

mNewSeqOfCap:

• TMagic.mNewSeqOfCap

mNewString:

• TMagic.mNewString

mNewStringOfCap:

• TMagic.mNewStringOfCap

mNFloatVal:

• TMagic.mNFloatVal

mNGenSym:

• TMagic.mNGenSym

mNGetType:

• TMagic.mNGetType

mNHint:

• TMagic.mNHint

mNil:

• TMagic.mNil

mNimvm:

• TMagic.mNimvm

mNIntVal:

• TMagic.mNIntVal

mnkAdd:

• MirNodeKind.mnkAdd

mnkAddr:

• MirNodeKind.mnkAddr

mnkAlias:

• MirNodeKind.mnkAlias

mnkArg:

• MirNodeKind.mnkArg

mnkArrayConstr:

• MirNodeKind.mnkArrayConstr

mnkAsgn:

• MirNodeKind.mnkAsgn

mnkAsm:

• MirNodeKind.mnkAsm

mnkAstLit:

• MirNodeKind.mnkAstLit

mnkBind:

• MirNodeKind.mnkBind

mnkBinding:

• MirNodeKind.mnkBinding

mnkBindMut:

• MirNodeKind.mnkBindMut

mnkBranch:

• MirNodeKind.mnkBranch

mnkCall:

• MirNodeKind.mnkCall

mnkCase:

• MirNodeKind.mnkCase

mnkCast:

• MirNodeKind.mnkCast

mnkCheckedCall:

• MirNodeKind.mnkCheckedCall

mnkClosureConstr:

• MirNodeKind.mnkClosureConstr

mnkConst:

• MirNodeKind.mnkConst

mnkConsume:

• MirNodeKind.mnkConsume

mnkContinue:

• MirNodeKind.mnkContinue

mnkConv:

• MirNodeKind.mnkConv

mnkCopy:

• MirNodeKind.mnkCopy

mnkDef:

• MirNodeKind.mnkDef

mnkDefCursor:

• MirNodeKind.mnkDefCursor

mnkDeref:

• MirNodeKind.mnkDeref

mnkDerefView:

• MirNodeKind.mnkDerefView

mnkDestroy:

• MirNodeKind.mnkDestroy

mnkDiv:

• MirNodeKind.mnkDiv

mnkEmit:

• MirNodeKind.mnkEmit

mnkEndScope:

• MirNodeKind.mnkEndScope

mnkEndStruct:

• MirNodeKind.mnkEndStruct

mnkExcept:

• MirNodeKind.mnkExcept

mnkField:

• MirNodeKind.mnkField

mnkFinally:

• MirNodeKind.mnkFinally

mnkFloatLit:

• MirNodeKind.mnkFloatLit

mnkGlobal:

• MirNodeKind.mnkGlobal

mnkGoto:

• MirNodeKind.mnkGoto

mnkIf:

• MirNodeKind.mnkIf

mnkImmediate:

• MirNodeKind.mnkImmediate

mNKind:

• TMagic.mNKind

mnkInit:

• MirNodeKind.mnkInit

mnkIntLit:

• MirNodeKind.mnkIntLit

mnkJoin:

• MirNodeKind.mnkJoin

mnkLabel:

• MirNodeKind.mnkLabel

mnkLeave:

• MirNodeKind.mnkLeave

mnkLocal:

• MirNodeKind.mnkLocal

mnkLoop:

• MirNodeKind.mnkLoop

mnkLoopJoin:

• MirNodeKind.mnkLoopJoin

mnkMagic:

• MirNodeKind.mnkMagic

mnkModI:

• MirNodeKind.mnkModI

mnkMove:

• MirNodeKind.mnkMove

mnkMul:

• MirNodeKind.mnkMul

mnkMutView:

• MirNodeKind.mnkMutView

mnkName:

• MirNodeKind.mnkName

mnkNeg:

• MirNodeKind.mnkNeg

mnkNilLit:

• MirNodeKind.mnkNilLit

mnkNone:

• MirNodeKind.mnkNone

mnkObjConstr:

• MirNodeKind.mnkObjConstr

mnkParam:

• MirNodeKind.mnkParam

mnkPathArray:

• MirNodeKind.mnkPathArray

mnkPathConv:

• MirNodeKind.mnkPathConv

mnkPathNamed:

• MirNodeKind.mnkPathNamed

mnkPathPos:

• MirNodeKind.mnkPathPos

mnkPathVariant:

• MirNodeKind.mnkPathVariant

mnkProc:

• MirNodeKind.mnkProc

mnkProcVal:

• MirNodeKind.mnkProcVal

mnkRaise:

• MirNodeKind.mnkRaise

mnkRange:

• MirNodeKind.mnkRange

mnkRefConstr:

• MirNodeKind.mnkRefConstr

mnkResume:

• MirNodeKind.mnkResume

mnkScope:

• MirNodeKind.mnkScope

mnkSeqConstr:

• MirNodeKind.mnkSeqConstr

mnkSetConstr:

• MirNodeKind.mnkSetConstr

mnkSink:

• MirNodeKind.mnkSink

mnkStdConv:

• MirNodeKind.mnkStdConv

mnkStrLit:

• MirNodeKind.mnkStrLit

mnkSub:

• MirNodeKind.mnkSub

mnkSwitch:

• MirNodeKind.mnkSwitch

mnkTargetList:

• MirNodeKind.mnkTargetList

mnkTemp:

• MirNodeKind.mnkTemp

mnkToMutSlice:

• MirNodeKind.mnkToMutSlice

mnkToSlice:

• MirNodeKind.mnkToSlice

mnkTupleConstr:

• MirNodeKind.mnkTupleConstr

mnkType:

• MirNodeKind.mnkType

mnkUIntLit:

• MirNodeKind.mnkUIntLit

mnkView:

• MirNodeKind.mnkView

mnkVoid:

• MirNodeKind.mnkVoid

mNLen:

• TMagic.mNLen

mNLineInfo:

• TMagic.mNLineInfo

mNNewNimNode:

• TMagic.mNNewNimNode

mNodeId:

• TMagic.mNodeId

mNone:

• TMagic.mNone

mNot:

• TMagic.mNot

mNSetChild:

• TMagic.mNSetChild

mNSetFloatVal:

• TMagic.mNSetFloatVal

mNSetIntVal:

• TMagic.mNSetIntVal

mNSetStrVal:

• TMagic.mNSetStrVal

mNSigHash:

• TMagic.mNSigHash

mNSizeOf:

• TMagic.mNSizeOf

mNStrVal:

• TMagic.mNStrVal

mNSymKind:

• TMagic.mNSymKind

mNWarning:

• TMagic.mNWarning

modifiedyNotes:

• options: modifiedyNotes(conf: ConfigRef): ReportKinds

modifiedyNotes=:

• options: modifiedyNotes=(conf: ConfigRef; nset: ReportKinds)

ModifierNodes:

• mirtrees: ModifierNodes

Module:

• modulelowering: Module

ModuleBackendFlag:

• ic: ModuleBackendFlag

moduleFromRodFile:

• ic: moduleFromRodFile(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache; fileIdx: FileIndex; cachedModules: var seq[FileIndex]): PSym
• modulegraphs: moduleFromRodFile(g: ModuleGraph; fileIdx: FileIndex; cachedModules: var seq[FileIndex]): PSym

ModuleGraph:

• modulegraphs: ModuleGraph

moduleHasChanged:

• passes: moduleHasChanged(graph: ModuleGraph; module: PSym): bool

moduleId:

• backends: moduleId(o: PIdObj): int32

ModuleId:

• packed_ast: ModuleId

moduleIndex:

• ic: moduleIndex(c: var PackedDecoder; g: PackedModuleGraph; thisModule: int; s: PackedItemId): int32

ModuleIter:

• modulegraphs: ModuleIter

ModuleList:

• modulelowering: ModuleList

moduleOpenForCodegen:

• modulegraphs: moduleOpenForCodegen(g: ModuleGraph; m: FileIndex): bool

ModuleStatus:

• ic: ModuleStatus

ModuleStructs:

• modulelowering: ModuleStructs

mOf:

• TMagic.mOf

mOffsetOf:

• TMagic.mOffsetOf

mOpenArray:

• TMagic.mOpenArray

mOr:

• TMagic.mOr

mOrd:

• TMagic.mOrd

mOrdinal:

• TMagic.mOrdinal

move:

• mirconstr: move(bu: var MirBuilder; val: Value)

mpairs:

• containers: mpairs[K, V](m: var SeqMap[K, V]): (K, var V)

mParseBiggestFloat:

• TMagic.mParseBiggestFloat

mParseExprToAst:

• TMagic.mParseExprToAst

mParseStmtToAst:

• TMagic.mParseStmtToAst

mPlugin:

• TMagic.mPlugin

mPlusSet:

• TMagic.mPlusSet

mPNimrodNode:

• TMagic.mPNimrodNode

mPointer:

• TMagic.mPointer

mPred:

• TMagic.mPred

mPrivateAccess:

• TMagic.mPrivateAccess

mProcCall:

• TMagic.mProcCall

mPtr:

• TMagic.mPtr

mQuoteAst:

• TMagic.mQuoteAst

mRange:

• TMagic.mRange

mRef:

• TMagic.mRef

mRepr:

• TMagic.mRepr

mReset:

• TMagic.mReset

mRunnableExamples:

• TMagic.mRunnableExamples

mSameNodeType:

• TMagic.mSameNodeType

mSamePayload:

• TMagic.mSamePayload

mSeq:

• TMagic.mSeq

mSet:

• TMagic.mSet

mSetLengthSeq:

• TMagic.mSetLengthSeq

mSetLengthStr:

• TMagic.mSetLengthStr

MsgConfig:

• options: MsgConfig

MsgFlag:

• options: MsgFlag

MsgFlags:

• options: MsgFlags

MsgFormatKind:

• in_options: MsgFormatKind

msgFormatSexp:

• MsgFormatKind.msgFormatSexp

msgFormatText:

• MsgFormatKind.msgFormatText

msgNoUnitSep:

• MsgFlag.msgNoUnitSep

msgQuit:

• msgs: msgQuit(x: int8)
• msgs: msgQuit(x: string)

msgStdout:

• MsgFlag.msgStdout

msgWrite:

• msgs: msgWrite(conf: ConfigRef; s: string; flags: MsgFlags = {})

mShallowCopy:

• TMagic.mShallowCopy

mShlI:

• TMagic.mShlI

mShrI:

• TMagic.mShrI

mSizeOf:

• TMagic.mSizeOf

mSlice:

• TMagic.mSlice

mStatic:

• TMagic.mStatic

mStmt:

• TMagic.mStmt

mStrDefine:

• TMagic.mStrDefine

mString:

• TMagic.mString

mStrToCStr:

• TMagic.mStrToCStr

mStrToIdent:

• TMagic.mStrToIdent

mStrToStr:

• TMagic.mStrToStr

mSubF64:

• TMagic.mSubF64

mSubI:

• TMagic.mSubI

mSubU:

• TMagic.mSubU

mSucc:

• TMagic.mSucc

mSwap:

• TMagic.mSwap

mSymIsInstantiationOf:

• TMagic.mSymIsInstantiationOf

mSymOwner:

• TMagic.mSymOwner

mTrace:

• TMagic.mTrace

mTuple:

• TMagic.mTuple

mType:

• TMagic.mType

mTypeDesc:

• TMagic.mTypeDesc

mTypeOf:

• TMagic.mTypeOf

mTypeTrait:

• TMagic.mTypeTrait

mUInt:

• TMagic.mUInt

mUInt16:

• TMagic.mUInt16

mUInt32:

• TMagic.mUInt32

mUInt64:

• TMagic.mUInt64

mUInt8:

• TMagic.mUInt8

mUnaryMinusF64:

• TMagic.mUnaryMinusF64

mUnaryMinusI:

• TMagic.mUnaryMinusI

mUnaryMinusI64:

• TMagic.mUnaryMinusI64

mUnaryPlusF64:

• TMagic.mUnaryPlusF64

mUnaryPlusI:

• TMagic.mUnaryPlusI

mUncheckedArray:

• TMagic.mUncheckedArray

mustRehash:

• astalgo: mustRehash(length, counter: int): bool

mutableSkipConv:

• types: mutableSkipConv(n: var PNode): var PNode

mutableView:

• ViewTypeKind.mutableView

mutatesGlobal:

• mirtrees: mutatesGlobal(tree: MirTree; n: NodePosition): bool

mutateType:

• types: mutateType(t: PType; iter: TTypeMutator; closure: RootRef): PType

MutationInfo:

• varpartitions: MutationInfo

mVar:

• TMagic.mVar

mVarargs:

• TMagic.mVarargs

mVoid:

• TMagic.mVoid

mVoidType:

• TMagic.mVoidType

mWasMoved:

• TMagic.mWasMoved

mXor:

• TMagic.mXor

name:

• mirtypes: name(env: TypeEnv; f: RecField): lent string

namePos:

• ast_query: namePos

names:

• ast_query: names(node: PNode): PNode

nameToCC:

• extccomp: nameToCC(name: string): TSystemCC

nameToCPU:

• platform: nameToCPU(name: string): TSystemCPU

nameToOS:

• platform: nameToOS(name: string): TSystemOS

nckFToF:

• NumericConvKind.nckFToF

nckFToI:

• NumericConvKind.nckFToI

nckFToU:

• NumericConvKind.nckFToU

nckIToF:

• NumericConvKind.nckIToF

nckToB:

• NumericConvKind.nckToB

nckUToF:

• NumericConvKind.nckUToF

NdiFile:

• ndi: NdiFile

needsBoundCheck:

• ast_analysis: needsBoundCheck(arr, lo, hi: PNode): bool

needsIndexCheck:

• ast_analysis: needsIndexCheck(config: ConfigRef; arr, idx: PNode): bool

NegOne:

• int128: NegOne

newAsgnStmt:

• lowerings: newAsgnStmt(le, ri: PNode): PNode

newBreakStmt:

• lowerings: newBreakStmt(info: TLineInfo; label: PSym): PNode

newCallCandidate:

• sigmatch: newCallCandidate(ctx: PContext; callee: PSym; calleeScope = -1): TCandidate

newCandidate:

• sigmatch: newCandidate(ctx: PContext; callee: PType): TCandidate

newConfigRef:

• options: newConfigRef(hook: ReportHook): ConfigRef

newContext:

• semdata: newContext(graph: ModuleGraph; module: PSym): PContext

newDeref:

• lowerings: newDeref(n: PNode): PNode

newDocumentor:

• docgen: newDocumentor(filename: AbsoluteFile; cache: IdentCache; conf: ConfigRef; outExt: string = HtmlExt; module: PSym = nil; isPureRst = false): PDoc

newDotExpr:

• lowerings: newDotExpr(obj, b: PSym): PNode

newEmptyParsedNode:

• ast_parsed_types: newEmptyParsedNode(fileIndex: FileIndex; line = unknownLineInfo.line; col = unknownLineInfo.col): ParsedNode

newError:

• errorhandling: newError(conf: ConfigRef; wrongNode: PNode; diag: PAstDiag; inst: InstantiationInfo; posInfo: TLineInfo = unknownLineInfo): PNode
• errorhandling: newError(conf: ConfigRef; wrongNode: PNode; diag: PAstDiag; posInfo: TLineInfo = unknownLineInfo): untyped

newExpr:

• cgir: newExpr(kind: CgNodeKind; info: TLineInfo; typ: PType; kids: varargs[CgNode]): CgNode

newFastAsgnStmt:

• lowerings: newFastAsgnStmt(le, ri: PNode): PNode

newFastMoveStmt:

• lowerings: newFastMoveStmt(g: ModuleGraph; le, ri: PNode): PNode

newFloatNode:

• ast: newFloatNode(kind: TNodeKind; floatVal: BiggestFloat): PNode

newFloatNodeT:

• semfold: newFloatNodeT(floatVal: BiggestFloat; n: PNode; g: ModuleGraph): PNode

newGlobals:

• jsgen: newGlobals(g: ModuleGraph): PGlobals

newIdentCache:

• idents: newIdentCache(): IdentCache

newIdentDefs:

• lowerings: newIdentDefs(v: PNode): PNode
• lowerings: newIdentDefs(v, value: PNode): PNode

newIdentNode:

• ast: newIdentNode(ident: PIdent; info: TLineInfo): PNode

newIdNodeTable:

• ast: newIdNodeTable(): TIdNodeTable

newIdTable:

• ast: newIdTable(): TIdTable

newIntLit:

• lowerings: newIntLit(g: ModuleGraph; info: TLineInfo; value: BiggestInt): PNode

newIntNode:

• ast: newIntNode(kind: TNodeKind; intVal: BiggestInt): PNode
• ast: newIntNode(kind: TNodeKind; intVal: Int128): PNode

newIntNodeT:

• semfold: newIntNodeT(intVal: Int128; n: PNode; idgen: IdGenerator; g: ModuleGraph): PNode

newIntTypeNode:

• ast: newIntTypeNode(intVal: BiggestInt; typ: PType): PNode
• ast: newIntTypeNode(intVal: Int128; typ: PType): PNode

newLineInfo:

• lineinfos: newLineInfo(fileIndex: FileIndex; line, col: int): TLineInfo
• options: newLineInfo(conf: ConfigRef; filename: AbsoluteFile; line, col: int): TLineInfo

NewLines:

• nimlexbase: NewLines

newLocalRef:

• cgir: newLocalRef(id: LocalId; info: TLineInfo; typ: PType): CgNode

newModule:

• cgen: newModule(g: BModuleList; module: PSym; conf: ConfigRef): BModule
• jsgen: newModule(g: ModuleGraph; module: PSym): BModule

newModuleGraph:

• modulegraphs: newModuleGraph(cache: IdentCache; config: ConfigRef): ModuleGraph

newModuleList:

• cgendata: newModuleList(g: ModuleGraph): BModuleList

newNode:

• ast: newNode(kind: TNodeKind): PNode
• cgir: newNode(kind: CgNodeKind; info = unknownLineInfo; typ = PType(nil)): CgNode

newNodeI:

• ast: newNodeI(kind: TNodeKind; info: TLineInfo): PNode
• ast: newNodeI(kind: TNodeKind; info: TLineInfo; children: int): PNode

newNodeIT:

• ast: newNodeIT(kind: TNodeKind; info: TLineInfo; typ: PType): PNode
• ast: newNodeIT(kind: TNodeKind; info: TLineInfo; typ: PType; children: int): PNode

newOp:

• cgir: newOp(kind: CgNodeKind; info: TLineInfo; typ: PType; opr: sink CgNode): CgNode

newOptionEntry:

• semdata: newOptionEntry(conf: ConfigRef): POptionEntry

newPackageCache:

• options: newPackageCache(): untyped

newParsedLitNode:

• ast_parsed_types: newParsedLitNode(kind: ParsedKindLiteral; fileIndex: FileIndex; token: ParsedToken): ParsedNode

newParsedNode:

• ast_parsed_types: newParsedNode(kind: ParsedKindWithSons; fileIndex: FileIndex; token: ParsedToken; sons: seq[ParsedNode] = @[]): ParsedNode

newParsedNodeIdent:

• ast_parsed_types: newParsedNodeIdent(fileIndex: FileIndex; token: ParsedToken): ParsedNode

newPartialConfigRef:

• options: newPartialConfigRef(): ConfigRef

newProc:

• cgendata: newProc(prc: PSym; module: BModule): BProc

newProcNode:

• ast: newProcNode(kind: TNodeKind; info: TLineInfo; body: PNode; params, name, pattern, genericParams, pragmas, exceptions: PNode): PNode
• ast_parsed_types: newProcNode(kind: ParsedNodeKind; fileIndex: FileIndex; token: ParsedToken; body, params, name, pattern, genericParams, pragmas, exceptions: ParsedNode): ParsedNode

newProcType:

• ast: newProcType(info: TLineInfo; id: ItemId; owner: PSym): PType

newSeq:

• containers: newSeq[I; T](x: var OrdinalSeq[I, T]; len: int)

newSons:

• ast: newSons(father: Indexable; length: int)

newStmt:

• cgir: newStmt(kind: CgNodeKind; info: TLineInfo; kids: varargs[CgNode]): CgNode

newStrNode:

• ast: newStrNode(strVal: sink string; typ: PType; info = unknownLineInfo): PNode
• ast: newStrNode(strVal: string; info: TLineInfo): PNode
• ast: newStrNode(kind: TNodeKind; strVal: string): PNode

newStrNodeT:

• semfold: newStrNodeT(strVal: string; n: PNode; g: ModuleGraph): PNode

newStrTable:

• ast: newStrTable(): TStrTable

newSym:

• ast: newSym(symKind: TSymKind; name: PIdent; id: ItemId; owner: PSym; info: TLineInfo; typ: PType; options: TOptions = {}): PSym
• ast: newSym(symKind: TSymKind; name: PIdent; id: ItemId; owner: PSym; info: TLineInfo; options: TOptions = {}): PSym

newSymGNode:

• sem: newSymGNode(kind: TSymKind; n: PNode; c: PContext): PNode

newSymNode:

• ast: newSymNode(sym: PSym): PNode
• ast: newSymNode(sym: PSym; info: TLineInfo): PNode
• compat: newSymNode(env: MirEnv; s: PSym): CgNode

newSymNodeIT:

• ast: newSymNodeIT(sym: PSym; info: TLineInfo; typ: PType): PNode

newSymNodeTypeDesc:

• semfold: newSymNodeTypeDesc(s: PSym; idgen: IdGenerator; info: TLineInfo): PNode

newTree:

• ast: newTree(kind: TNodeKind; children: varargs[PNode]): PNode

newTreeFrom:

• packed_ast: newTreeFrom(old: PackedTree): PackedTree

newTreeI:

• ast: newTreeI(kind: TNodeKind; info: TLineInfo; children: varargs[PNode]): PNode

newTreeIT:

• ast: newTreeIT(kind: TNodeKind; info: TLineInfo; typ: PType; children: varargs[PNode]): PNode

newTryFinally:

• lowerings: newTryFinally(body, final: PNode): PNode

newTupleAccess:

• lowerings: newTupleAccess(g: ModuleGraph; tup: PNode; i: int): PNode

newTupleAccessRaw:

• lowerings: newTupleAccessRaw(tup: PNode; i: int): PNode

newType:

• ast: newType(kind: TTypeKind; id: ItemId; owner: PSym): PType
• mirtypes: newType(env: var TypeEnv; desc: HeaderId): TypeId

newTypeError:

• ast: newTypeError(prev: PType; id: ItemId; owner: PSym = if isNil(prev): nil else: prev.owner; err: PNode): PType

newTypeMapLayer:

• semtypinst: newTypeMapLayer(cl: var TReplTypeVars): LayeredIdTable

newTypeS:

• semdata: newTypeS(kind: TTypeKind; c: PContext): PType

newTypeWithSons:

• semdata: newTypeWithSons(c: PContext; kind: TTypeKind; sons: seq[PType]): PType
• semdata: newTypeWithSons(owner: PSym; kind: TTypeKind; sons: seq[PType]; idgen: IdGenerator): PType

newVersion:

• nimblecmd: newVersion(ver: string): Version

newVmSeq:

• vmobjects: newVmSeq(s: var VmSeq; typ: PVmType; numItems: Natural; mm: var VmMemoryManager)

newVmString:

• vmdef: newVmString(data: CellPtr; len: Natural): VmString
• vmobjects: newVmString(s: var VmString; numElements: Natural; a: var VmAllocator)
• vmobjects: newVmString(s: var VmString; src: openArray[char]; a: var VmAllocator)

next:

• btrees: next[Key, Val](b: BTree[Key, Val]; index: int): (Key, Val, int)
• vmobjects: next(ctx: var VariantFieldIterCtx; src: VmMemoryRegion; typ: PVmType)

nextId:

• containers: nextId[I; T](x: Store[I, T]): I

nextIdentExcluding:

• astalgo: nextIdentExcluding(ti: var TIdentIter; tab: TStrTable; excluding: IntSet): PSym

nextIdentIter:

• astalgo: nextIdentIter(ti: var TIdentIter; tab: TStrTable): PSym

nextIter:

• astalgo: nextIter(ti: var TTabIter; tab: TStrTable): PSym

nextModuleIter:

• modulegraphs: nextModuleIter(mi: var ModuleIter; g: ModuleGraph): PSym

nextOverloadIter:

• lookups: nextOverloadIter(o: var TOverloadIter; c: PContext; n: PNode): PSym

nextRodIter:

• ic: nextRodIter(it: var RodIter; g: var PackedModuleGraph): PSym

nextSymId:

• ast_idgen: nextSymId(x: IdGenerator): ItemId

nextTry:

• astalgo: nextTry(h, maxHash: Hash): Hash

nextTypeId:

• ast_idgen: nextTypeId(x: IdGenerator): ItemId

nfAllConst:

• TNodeFlag.nfAllConst

nfDefaultParam:

• TNodeFlag.nfDefaultParam

nfDefaultRefsParam:

• TNodeFlag.nfDefaultRefsParam

nfDotField:

• TNodeFlag.nfDotField

nfDotSetter:

• TNodeFlag.nfDotSetter

nfExplicitCall:

• TNodeFlag.nfExplicitCall

nfFromTemplate:

• TNodeFlag.nfFromTemplate

nfHasComment:

• TNodeFlag.nfHasComment

nfLL:

• TNodeFlag.nfLL

nfNoRewrite:

• TNodeFlag.nfNoRewrite

nfSem:

• TNodeFlag.nfSem

nfTransf:

• TNodeFlag.nfTransf

nfWasGensym:

• TNodeFlag.nfWasGensym

Nil:

• Nilability.Nil

Nilability:

• nilcheck_enums: Nilability

NilableTypes:

• ast_query: NilableTypes

nilItemId:

• packed_ast: nilItemId

nilOrSysInt:

• magicsys: nilOrSysInt(g: ModuleGraph): PType

NilTransition:

• nilcheck_enums: NilTransition

nimblePath:

• nimblecmd: nimblePath(conf: ConfigRef; path: AbsoluteDir): NimblePathResult

NimblePathResult:

• nimblecmd: NimblePathResult

nimblePaths:

• options: nimblePaths(conf`gensym56: ConfigRef): seq[AbsoluteDir]

nimblePaths=:

• options: nimblePaths=(conf`gensym56: ConfigRef; val`gensym56: seq[AbsoluteDir])

nimblePathsAdd:

• options: nimblePathsAdd(conf`gensym55: ConfigRef; item`gensym55: AbsoluteDir | seq[AbsoluteDir])

nimblePkgAdded:

• NimblePkgAddResult.nimblePkgAdded

NimblePkgAddResult:

• nimblecmd: NimblePkgAddResult

nimblePkgInvalid:

• NimblePkgAddResult.nimblePkgInvalid

nimblePkgOlder:

• NimblePkgAddResult.nimblePkgOlder

nimblePkgUpdated:

• NimblePkgAddResult.nimblePkgUpdated

nimbleSubs:

• options: nimbleSubs(conf: ConfigRef; p: string): string

nimcacheDir:

• options: nimcacheDir(conf`gensym26: ConfigRef): AbsoluteDir

nimcacheDir=:

• options: nimcacheDir=(conf`gensym26: ConfigRef; val`gensym26: AbsoluteDir)

NimCompilerApiVersion:

• nversion: NimCompilerApiVersion

NimConfEvtWriter:

• nimconf: NimConfEvtWriter

nimdocOutCss:

• nimpaths: nimdocOutCss

nimEnableCovariance:

• options: nimEnableCovariance

nimErrorFlagAccessed:

• TCProcFlag.nimErrorFlagAccessed

nimErrorFlagDeclared:

• TCProcFlag.nimErrorFlagDeclared

nimErrorFlagDisabled:

• TCProcFlag.nimErrorFlagDisabled

NimExt:

• options: NimExt

nimKeywordsHigh:

• wordrecg: nimKeywordsHigh

nimKeywordsLow:

• wordrecg: nimKeywordsLow

nimNodeFlag:

• vmdef: nimNodeFlag

NimProg:

• cmdlinehelper: NimProg

NimVer:

• options: NimVer

nkAccQuoted:

• TNodeKind.nkAccQuoted

nkAddr:

• TNodeKind.nkAddr

nkAllNodeKinds:

• ast_query: nkAllNodeKinds

nkArgList:

• TNodeKind.nkArgList

nkAsgn:

• TNodeKind.nkAsgn

nkAsmStmt:

• TNodeKind.nkAsmStmt

nkBind:

• TNodeKind.nkBind

nkBindStmt:

• TNodeKind.nkBindStmt

nkBlockExpr:

• TNodeKind.nkBlockExpr

nkBlockStmt:

• TNodeKind.nkBlockStmt

nkBracket:

• TNodeKind.nkBracket

nkBracketExpr:

• TNodeKind.nkBracketExpr

nkBreakStmt:

• TNodeKind.nkBreakStmt

nkCall:

• TNodeKind.nkCall

nkCallKinds:

• ast_query: nkCallKinds

nkCallStrLit:

• TNodeKind.nkCallStrLit

nkCaseStmt:

• TNodeKind.nkCaseStmt

nkCast:

• TNodeKind.nkCast

nkCharLit:

• TNodeKind.nkCharLit

nkChckRange:

• TNodeKind.nkChckRange

nkChckRange64:

• TNodeKind.nkChckRange64

nkChckRangeF:

• TNodeKind.nkChckRangeF

nkCheckedFieldExpr:

• TNodeKind.nkCheckedFieldExpr

nkClosedSymChoice:

• TNodeKind.nkClosedSymChoice

nkClosure:

• TNodeKind.nkClosure

nkCommand:

• TNodeKind.nkCommand

nkCommentStmt:

• TNodeKind.nkCommentStmt

nkConstDef:

• TNodeKind.nkConstDef

nkConstSection:

• TNodeKind.nkConstSection

nkConstTy:

• TNodeKind.nkConstTy

nkContinueStmt:

• TNodeKind.nkContinueStmt

nkConv:

• TNodeKind.nkConv

nkConverterDef:

• TNodeKind.nkConverterDef

nkCStringToString:

• TNodeKind.nkCStringToString

nkCurly:

• TNodeKind.nkCurly

nkCurlyExpr:

• TNodeKind.nkCurlyExpr

nkDefer:

• TNodeKind.nkDefer

nkDerefExpr:

• TNodeKind.nkDerefExpr

nkDiscardStmt:

• TNodeKind.nkDiscardStmt

nkDistinctTy:

• TNodeKind.nkDistinctTy

nkDo:

• TNodeKind.nkDo

nkDotCall:

• TNodeKind.nkDotCall

nkDotExpr:

• TNodeKind.nkDotExpr

nkEffectList:

• ast_types: nkEffectList

nkElifBranch:

• TNodeKind.nkElifBranch

nkElifExpr:

• TNodeKind.nkElifExpr

nkElse:

• TNodeKind.nkElse

nkElseExpr:

• TNodeKind.nkElseExpr

nkEmpty:

• TNodeKind.nkEmpty

nkEnumFieldDef:

• TNodeKind.nkEnumFieldDef

nkEnumTy:

• TNodeKind.nkEnumTy

nkError:

• TNodeKind.nkError

nkExceptBranch:

• TNodeKind.nkExceptBranch

nkExportExceptStmt:

• TNodeKind.nkExportExceptStmt

nkExportStmt:

• TNodeKind.nkExportStmt

nkExprColonExpr:

• TNodeKind.nkExprColonExpr

nkExprEqExpr:

• TNodeKind.nkExprEqExpr

nkFastAsgn:

• TNodeKind.nkFastAsgn

nkFinally:

• TNodeKind.nkFinally

nkFloat32Lit:

• TNodeKind.nkFloat32Lit

nkFloat64Lit:

• TNodeKind.nkFloat64Lit

nkFloatKinds:

• ast_query: nkFloatKinds

nkFloatLit:

• TNodeKind.nkFloatLit

nkFloatLiterals:

• ast_types: nkFloatLiterals

nkFormalParams:

• TNodeKind.nkFormalParams

nkForStmt:

• TNodeKind.nkForStmt

nkFromStmt:

• TNodeKind.nkFromStmt

nkFuncDef:

• TNodeKind.nkFuncDef

nkGenericParams:

• TNodeKind.nkGenericParams

nkGotoState:

• TNodeKind.nkGotoState

nkHiddenAddr:

• TNodeKind.nkHiddenAddr

nkHiddenCallConv:

• TNodeKind.nkHiddenCallConv

nkHiddenDeref:

• TNodeKind.nkHiddenDeref

nkHiddenStdConv:

• TNodeKind.nkHiddenStdConv

nkHiddenSubConv:

• TNodeKind.nkHiddenSubConv

nkHiddenTryStmt:

• TNodeKind.nkHiddenTryStmt

nkIdent:

• TNodeKind.nkIdent

nkIdentDefs:

• TNodeKind.nkIdentDefs

nkIdentKinds:

• ast_query: nkIdentKinds

nkIfExpr:

• TNodeKind.nkIfExpr

nkIfStmt:

• TNodeKind.nkIfStmt

nkImportAs:

• TNodeKind.nkImportAs

nkImportExceptStmt:

• TNodeKind.nkImportExceptStmt

nkImportStmt:

• TNodeKind.nkImportStmt

nkIncludeStmt:

• TNodeKind.nkIncludeStmt

nkInfix:

• TNodeKind.nkInfix

nkInt16Lit:

• TNodeKind.nkInt16Lit

nkInt32Lit:

• TNodeKind.nkInt32Lit

nkInt64Lit:

• TNodeKind.nkInt64Lit

nkInt8Lit:

• TNodeKind.nkInt8Lit

nkIntKinds:

• ast_query: nkIntKinds

nkIntLit:

• TNodeKind.nkIntLit

nkIntLiterals:

• ast_types: nkIntLiterals

nkIteratorDef:

• TNodeKind.nkIteratorDef

nkIteratorTy:

• TNodeKind.nkIteratorTy

nkLambda:

• TNodeKind.nkLambda

nkLambdaKinds:

• ast_query: nkLambdaKinds

nkLastBlockStmts:

• ast_types: nkLastBlockStmts

nkLetSection:

• TNodeKind.nkLetSection

nkLiterals:

• ast_types: nkLiterals

nkMacroDef:

• TNodeKind.nkMacroDef

nkMethodDef:

• TNodeKind.nkMethodDef

nkMixinStmt:

• TNodeKind.nkMixinStmt

nkModuleRef:

• TNodeKind.nkModuleRef

nkMutableTy:

• TNodeKind.nkMutableTy

nkNilLit:

• TNodeKind.nkNilLit

nkNilRodNode:

• TNodeKind.nkNilRodNode

nkNimNodeLit:

• TNodeKind.nkNimNodeLit

nkObjConstr:

• TNodeKind.nkObjConstr

nkObjDownConv:

• TNodeKind.nkObjDownConv

nkObjectTy:

• TNodeKind.nkObjectTy

nkObjUpConv:

• TNodeKind.nkObjUpConv

nkOfBranch:

• TNodeKind.nkOfBranch

nkOfInherit:

• TNodeKind.nkOfInherit

nkOpenSymChoice:

• TNodeKind.nkOpenSymChoice

nkPar:

• TNodeKind.nkPar

nkPattern:

• TNodeKind.nkPattern

nkPostfix:

• TNodeKind.nkPostfix

nkPragma:

• TNodeKind.nkPragma

nkPragmaBlock:

• TNodeKind.nkPragmaBlock

nkPragmaCallKinds:

• ast_query: nkPragmaCallKinds

nkPragmaExpr:

• TNodeKind.nkPragmaExpr

nkPrefix:

• TNodeKind.nkPrefix

nkProcDef:

• TNodeKind.nkProcDef

nkProcTy:

• TNodeKind.nkProcTy

nkPtrTy:

• TNodeKind.nkPtrTy

nkRaiseStmt:

• TNodeKind.nkRaiseStmt

nkRange:

• TNodeKind.nkRange

nkRecCase:

• TNodeKind.nkRecCase

nkRecList:

• TNodeKind.nkRecList

nkRecWhen:

• TNodeKind.nkRecWhen

nkRefTy:

• TNodeKind.nkRefTy

nkReplayAction:

• TNodeKind.nkReplayAction

nkReturnStmt:

• TNodeKind.nkReturnStmt

nkRStrLit:

• TNodeKind.nkRStrLit

nkSharedTy:

• TNodeKind.nkSharedTy

nkSIntLiterals:

• ast_types: nkSIntLiterals

nkStaticExpr:

• TNodeKind.nkStaticExpr

nkStaticStmt:

• TNodeKind.nkStaticStmt

nkStaticTy:

• TNodeKind.nkStaticTy

nkStmtList:

• TNodeKind.nkStmtList

nkStmtListExpr:

• TNodeKind.nkStmtListExpr

nkStringToCString:

• TNodeKind.nkStringToCString

nkStrKinds:

• ast_query: nkStrKinds

nkStrLit:

• TNodeKind.nkStrLit

nkStrLiterals:

• ast_types: nkStrLiterals

nkSym:

• TNodeKind.nkSym

nkSymChoices:

• ast_query: nkSymChoices

nkTableConstr:

• TNodeKind.nkTableConstr

nkTemplateDef:

• TNodeKind.nkTemplateDef

nkTripleStrLit:

• TNodeKind.nkTripleStrLit

nkTryStmt:

• TNodeKind.nkTryStmt

nkTupleClassTy:

• TNodeKind.nkTupleClassTy

nkTupleConstr:

• TNodeKind.nkTupleConstr

nkTupleTy:

• TNodeKind.nkTupleTy

nkType:

• TNodeKind.nkType

nkTypeClassTy:

• TNodeKind.nkTypeClassTy

nkTypeDef:

• TNodeKind.nkTypeDef

nkTypeExprs:

• ast_query: nkTypeExprs

nkTypeOfExpr:

• TNodeKind.nkTypeOfExpr

nkTypeSection:

• TNodeKind.nkTypeSection

nkUInt16Lit:

• TNodeKind.nkUInt16Lit

nkUInt32Lit:

• TNodeKind.nkUInt32Lit

nkUInt64Lit:

• TNodeKind.nkUInt64Lit

nkUInt8Lit:

• TNodeKind.nkUInt8Lit

nkUIntLit:

• TNodeKind.nkUIntLit

nkUIntLiterals:

• ast_types: nkUIntLiterals

nkUsingStmt:

• TNodeKind.nkUsingStmt

nkVariableSections:

• ast_types: nkVariableSections

nkVarSection:

• TNodeKind.nkVarSection

nkVarTuple:

• TNodeKind.nkVarTuple

nkVarTy:

• TNodeKind.nkVarTy

nkWhen:

• ast_types: nkWhen

nkWhenExpr:

• ast_types: nkWhenExpr

nkWhenStmt:

• TNodeKind.nkWhenStmt

nkWhileStmt:

• TNodeKind.nkWhileStmt

nkWith:

• TNodeKind.nkWith

nkWithout:

• TNodeKind.nkWithout

nkWithoutSons:

• ast_types: nkWithoutSons

nkWithSons:

• ast_types: nkWithSons

nkYieldStmt:

• TNodeKind.nkYieldStmt

no:

• Ternary.no

NodeId:

• ast_types: NodeId

NodeIndex:

• mirtrees: NodeIndex

nodeKindsProducedByParse:

• ast_types: nodeKindsProducedByParse

NodePos:

• packed_ast: NodePos

NodePosition:

• mirtrees: NodePosition

NodePosName:

• ast_query: NodePosName

NodeSliceName:

• ast_query: NodeSliceName

nodeTableGet:

• treetab: nodeTableGet(t: TNodeTable; key: PNode): int

nodeTablePut:

• treetab: nodeTablePut(t: var TNodeTable; key: PNode; val: int)

nodeTableTestOrSet:

• treetab: nodeTableTestOrSet(t: var TNodeTable; key: PNode; val: int): int

NoneLike:

• OrdinalType.NoneLike

noneType:

• vmdef: noneType

NonMagics:

• cgen: NonMagics
• jsgen: NonMagics

notes:

• options: notes(conf: ConfigRef): ReportKinds

notes=:

• options: notes=(conf: ConfigRef; nset: ReportKinds)

NotesVerbosity:

• options: NotesVerbosity

notnil:

• Feature.notnil

noView:

• ViewTypeKind.noView

numArgs:

• compat: numArgs(n: CgNode): int
• mirtrees: numArgs(tree: MirTree; n: NodePosition): int
• vmhooks: numArgs(a: VmArgs): int

NumberId:

• mirtrees: NumberId

numberOfProcessors:

• options: numberOfProcessors(conf`gensym34: ConfigRef): int

numberOfProcessors=:

• options: numberOfProcessors=(conf`gensym34: ConfigRef; val`gensym34: int)

numbersSection:

• RodSection.numbersSection

numChars:

• lexer: numChars

NumericalBase:

• numericbase: NumericalBase

NumericConvKind:

• vmdef: NumericConvKind

numFields:

• mirtypes: numFields(desc: TypeHeader): int

numLines:

• msgs: numLines(conf: ConfigRef; fileIdx: FileIndex): int

numParams:

• mirtypes: numParams(desc: TypeHeader): int

objectSetContains:

• astalgo: objectSetContains(t: TObjectSet; obj: RootRef): bool

objectSetContainsOrIncl:

• astalgo: objectSetContainsOrIncl(t: var TObjectSet; obj: RootRef): bool

objectSetIncl:

• astalgo: objectSetIncl(t: var TObjectSet; obj: RootRef)

objTypeRel:

• vmtypes: objTypeRel(a, b: PVmType; swapped: bool): VmTypeRel

oimDone:

• TOverloadIterMode.oimDone

oimNoQualifier:

• TOverloadIterMode.oimNoQualifier

oimOtherModule:

• TOverloadIterMode.oimOtherModule

oimSelfModule:

• TOverloadIterMode.oimSelfModule

oimSymChoice:

• TOverloadIterMode.oimSymChoice

oimSymChoiceLocalLookup:

• TOverloadIterMode.oimSymChoiceLocalLookup

ok:

• RodFileError.ok

oldExperimentalFeatures:

• options: oldExperimentalFeatures

One:

• int128: One

OnHeap:

• TStorageLoc.OnHeap

onlyStructureTReprConf:

• astrepr: onlyStructureTReprConf

onProcessing:

• modulegraphs: onProcessing(graph: ModuleGraph; fileIdx: FileIndex; moduleStatus: string; fromModule: PSym)

OnPrompt:

• llstream: OnPrompt

OnStack:

• TStorageLoc.OnStack

OnStatic:

• TStorageLoc.OnStatic

OnUnknown:

• TStorageLoc.OnUnknown

opAbort:

• COpcode.opAbort

opBackup:

• COpcode.opBackup

opcAddFloat:

• TOpcode.opcAddFloat

opcAddImmInt:

• TOpcode.opcAddImmInt

opcAddInt:

• TOpcode.opcAddInt

opcAddr:

• TOpcode.opcAddr

opcAddSeqElem:

• TOpcode.opcAddSeqElem

opcAddStrCh:

• TOpcode.opcAddStrCh

opcAddStrStr:

• TOpcode.opcAddStrStr

opcAddu:

• TOpcode.opcAddu

opcArrCopy:

• TOpcode.opcArrCopy

opcAsgnComplex:

• TOpcode.opcAsgnComplex

opcAsgnFloat:

• TOpcode.opcAsgnFloat

opcAsgnInt:

• TOpcode.opcAsgnInt

opcAshrInt:

• TOpcode.opcAshrInt

opcBitandInt:

• TOpcode.opcBitandInt

opcBitnotInt:

• TOpcode.opcBitnotInt

opcBitorInt:

• TOpcode.opcBitorInt

opcBitxorInt:

• TOpcode.opcBitxorInt

opcBranch:

• TOpcode.opcBranch

opcCallSite:

• TOpcode.opcCallSite

opcCard:

• TOpcode.opcCard

opcCast:

• TOpcode.opcCast

opcCastFloatToInt32:

• TOpcode.opcCastFloatToInt32

opcCastFloatToInt64:

• TOpcode.opcCastFloatToInt64

opcCastIntToFloat32:

• TOpcode.opcCastIntToFloat32

opcCastIntToFloat64:

• TOpcode.opcCastIntToFloat64

opcCastIntToPtr:

• TOpcode.opcCastIntToPtr

opcCastPtrToInt:

• TOpcode.opcCastPtrToInt

opcConcatStr:

• TOpcode.opcConcatStr

opcContainsSet:

• TOpcode.opcContainsSet

opcConv:

• TOpcode.opcConv

opcDataToAst:

• TOpcode.opcDataToAst

opcDivFloat:

• TOpcode.opcDivFloat

opcDivInt:

• TOpcode.opcDivInt

opcDivu:

• TOpcode.opcDivu

opcEcho:

• TOpcode.opcEcho

opcEnter:

• TOpcode.opcEnter

opcEof:

• TOpcode.opcEof

opcEqFloat:

• TOpcode.opcEqFloat

opcEqIdent:

• TOpcode.opcEqIdent

opcEqInt:

• TOpcode.opcEqInt

opcEqNimNode:

• TOpcode.opcEqNimNode

opcEqRef:

• TOpcode.opcEqRef

opcEqSet:

• TOpcode.opcEqSet

opcEqStr:

• TOpcode.opcEqStr

opcExcl:

• TOpcode.opcExcl

opcExpandToAst:

• TOpcode.opcExpandToAst

opcFastAsgnComplex:

• TOpcode.opcFastAsgnComplex

opcFinally:

• TOpcode.opcFinally

opcFinallyEnd:

• TOpcode.opcFinallyEnd

opcFJmp:

• TOpcode.opcFJmp

opcGenSym:

• TOpcode.opcGenSym

opcGetImpl:

• TOpcode.opcGetImpl

opcGetImplTransf:

• TOpcode.opcGetImplTransf

OpChars:

• lexer: OpChars

opcIncl:

• TOpcode.opcIncl

opcInclRange:

• TOpcode.opcInclRange

opcIndCall:

• TOpcode.opcIndCall

opcIndCallAsgn:

• TOpcode.opcIndCallAsgn

opcIndexChck:

• TOpcode.opcIndexChck

opcInitDisc:

• TOpcode.opcInitDisc

opcInvalidField:

• TOpcode.opcInvalidField

opcIsNil:

• TOpcode.opcIsNil

opcJmp:

• TOpcode.opcJmp

opcJmpBack:

• TOpcode.opcJmpBack

opcLdArr:

• TOpcode.opcLdArr

opcLdArrAddr:

• TOpcode.opcLdArrAddr

opcLdCmplxConst:

• TOpcode.opcLdCmplxConst

opcLdConst:

• TOpcode.opcLdConst

opcLdDeref:

• TOpcode.opcLdDeref

opcLdGlobal:

• TOpcode.opcLdGlobal

opcLdImmInt:

• TOpcode.opcLdImmInt

opcLdNull:

• TOpcode.opcLdNull

opcLdNullReg:

• TOpcode.opcLdNullReg

opcLdObj:

• TOpcode.opcLdObj

opcLdObjAddr:

• TOpcode.opcLdObjAddr

opcLdStrIdx:

• TOpcode.opcLdStrIdx

opcLeave:

• TOpcode.opcLeave

opcLeFloat:

• TOpcode.opcLeFloat

opcLeInt:

• TOpcode.opcLeInt

opcLenCstring:

• TOpcode.opcLenCstring

opcLenSeq:

• TOpcode.opcLenSeq

opcLenStr:

• TOpcode.opcLenStr

opcLeSet:

• TOpcode.opcLeSet

opcLeStr:

• TOpcode.opcLeStr

opcLeu:

• TOpcode.opcLeu

opcLtFloat:

• TOpcode.opcLtFloat

opcLtInt:

• TOpcode.opcLtInt

opcLtSet:

• TOpcode.opcLtSet

opcLtStr:

• TOpcode.opcLtStr

opcLtu:

• TOpcode.opcLtu

opcMinusSet:

• TOpcode.opcMinusSet

opcModInt:

• TOpcode.opcModInt

opcModu:

• TOpcode.opcModu

opcMulFloat:

• TOpcode.opcMulFloat

opcMulInt:

• TOpcode.opcMulInt

opcMulSet:

• TOpcode.opcMulSet

opcMulu:

• TOpcode.opcMulu

opcNAdd:

• TOpcode.opcNAdd

opcNAddMultiple:

• TOpcode.opcNAddMultiple

opcNarrowS:

• TOpcode.opcNarrowS

opcNarrowU:

• TOpcode.opcNarrowU

opcNccInc:

• TOpcode.opcNccInc

opcNccValue:

• TOpcode.opcNccValue

opcNChild:

• TOpcode.opcNChild

opcNCopyNimNode:

• TOpcode.opcNCopyNimNode

opcNCopyNimTree:

• TOpcode.opcNCopyNimTree

opcNcsAdd:

• TOpcode.opcNcsAdd

opcNcsAt:

• TOpcode.opcNcsAt

opcNcsIncl:

• TOpcode.opcNcsIncl

opcNcsLen:

• TOpcode.opcNcsLen

opcNctGet:

• TOpcode.opcNctGet

opcNctHasNext:

• TOpcode.opcNctHasNext

opcNctLen:

• TOpcode.opcNctLen

opcNctNext:

• TOpcode.opcNctNext

opcNctPut:

• TOpcode.opcNctPut

opcNDel:

• TOpcode.opcNDel

opcNew:

• TOpcode.opcNew

opcNewSeq:

• TOpcode.opcNewSeq

opcNewStr:

• TOpcode.opcNewStr

opcNFloatVal:

• TOpcode.opcNFloatVal

opcNGetLineInfo:

• TOpcode.opcNGetLineInfo

opcNGetSize:

• TOpcode.opcNGetSize

opcNGetType:

• TOpcode.opcNGetType

opcNIntVal:

• TOpcode.opcNIntVal

opcNKind:

• TOpcode.opcNKind

opcNNewNimNode:

• TOpcode.opcNNewNimNode

opcNodeId:

• TOpcode.opcNodeId

opcNodeToReg:

• TOpcode.opcNodeToReg

opcNot:

• TOpcode.opcNot

opcNSetChild:

• TOpcode.opcNSetChild

opcNSetFloatVal:

• TOpcode.opcNSetFloatVal

opcNSetIntVal:

• TOpcode.opcNSetIntVal

opcNSetLineInfo:

• TOpcode.opcNSetLineInfo

opcNSetStrVal:

• TOpcode.opcNSetStrVal

opcNSetType:

• TOpcode.opcNSetType

opcNSigHash:

• TOpcode.opcNSigHash

opcNStrVal:

• TOpcode.opcNStrVal

opcNSymKind:

• TOpcode.opcNSymKind

opcNumConv:

• TOpcode.opcNumConv

opcObjChck:

• TOpcode.opcObjChck

opcObjConv:

• TOpcode.opcObjConv

Opcode:

• mirexec: Opcode

opcode:

• vmdef: opcode(x: TInstr): TOpcode

opcOf:

• TOpcode.opcOf

opConsume:

• Opcode.opConsume

opcParseExprToAst:

• TOpcode.opcParseExprToAst

opcParseFloat:

• TOpcode.opcParseFloat

opcParseStmtToAst:

• TOpcode.opcParseStmtToAst

opcPlusSet:

• TOpcode.opcPlusSet

opcQuit:

• TOpcode.opcQuit

opcRaise:

• TOpcode.opcRaise

opcRangeChck:

• TOpcode.opcRangeChck

opcRepr:

• TOpcode.opcRepr

opcReset:

• TOpcode.opcReset

opcRet:

• TOpcode.opcRet

opcSameNodeType:

• TOpcode.opcSameNodeType

opcSetDisc:

• TOpcode.opcSetDisc

opcSetEh:

• TOpcode.opcSetEh

opcSetLenSeq:

• TOpcode.opcSetLenSeq

opcSetLenStr:

• TOpcode.opcSetLenStr

opcSetType:

• TOpcode.opcSetType

opcShlInt:

• TOpcode.opcShlInt

opcShrInt:

• TOpcode.opcShrInt

opcSignExtend:

• TOpcode.opcSignExtend

opcStrToIdent:

• TOpcode.opcStrToIdent

opcSubFloat:

• TOpcode.opcSubFloat

opcSubImmInt:

• TOpcode.opcSubImmInt

opcSubInt:

• TOpcode.opcSubInt

opcSubu:

• TOpcode.opcSubu

opcSymIsInstantiationOf:

• TOpcode.opcSymIsInstantiationOf

opcSymOwner:

• TOpcode.opcSymOwner

opcTJmp:

• TOpcode.opcTJmp

opcTypeTrait:

• TOpcode.opcTypeTrait

opcUnaryMinusFloat:

• TOpcode.opcUnaryMinusFloat

opcUnaryMinusInt:

• TOpcode.opcUnaryMinusInt

opcWrArr:

• TOpcode.opcWrArr

opcWrDeref:

• TOpcode.opcWrDeref

opcWrLoc:

• TOpcode.opcWrLoc

opcWrObj:

• TOpcode.opcWrObj

opcWrProc:

• TOpcode.opcWrProc

opcWrStrIdx:

• TOpcode.opcWrStrIdx

opcXor:

• TOpcode.opcXor

opcYldVal:

• TOpcode.opcYldVal

opcYldYoid:

• TOpcode.opcYldYoid

opDef:

• Opcode.opDef

opDestroy:

• Opcode.opDestroy

opDispatcher:

• COpcode.opDispatcher

opDispJump:

• COpcode.opDispJump

open:

• ndi: open(f: var NdiFile; filename: AbsoluteFile; conf: ConfigRef)
• rodfiles: open(filename: string): RodFile

openBaseLexer:

• nimlexbase: openBaseLexer(L: var TBaseLexer; inputstream: PLLStream; bufLen: int = 8192)

openLexer:

• lexer: openLexer(lex: var Lexer; filename: AbsoluteFile; inputstream: PLLStream; cache: IdentCache; config: ConfigRef)
• lexer: openLexer(lex: var Lexer; fileIdx: FileIndex; inputstream: PLLStream; cache: IdentCache; config: ConfigRef)

openParser:

• parser: openParser(p: var Parser; filename: AbsoluteFile; inputStream: PLLStream; cache: IdentCache; config: ConfigRef)
• parser: openParser(p: var Parser; fileIdx: FileIndex; inputStream: PLLStream; cache: IdentCache; config: ConfigRef)
• syntaxes: openParser(p: var Parser; fileIdx: FileIndex; inputstream: PLLStream; cache: IdentCache; config: ConfigRef)

openScope:

• lookups: openScope(c: PContext): PScope

openShadowScope:

• lookups: openShadowScope(c: PContext)

operand:

• packed_ast: operand(n: NodePos): int32
• mirtrees: operand(tree: MirTree; op: OpValue | NodePosition): OpValue
• mirtrees: operand(tree: MirTree; n: NodePosition; i: Natural): OpValue

Operators:

• modulegraphs: Operators

opErrJump:

• COpcode.opErrJump

opFork:

• Opcode.opFork

opGorge:

• gorgeimpl: opGorge(cmd, input, cache: string; info: TLineInfo; conf: ConfigRef): (string, int)

opGoto:

• Opcode.opGoto

opInvalidate:

• Opcode.opInvalidate

opJoin:

• Opcode.opJoin

opJump:

• COpcode.opJump

opKill:

• Opcode.opKill

opLabel:

• COpcode.opLabel

opLoop:

• Opcode.opLoop

opMapTypeImplToAst:

• vmdeps: opMapTypeImplToAst(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGenerator): PNode

opMapTypeInstToAst:

• vmdeps: opMapTypeInstToAst(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGenerator): PNode

opMapTypeToAst:

• vmdeps: opMapTypeToAst(cache: IdentCache; t: PType; info: TLineInfo; idgen: IdGenerator): PNode

opMutate:

• Opcode.opMutate

opMutateGlobal:

• Opcode.opMutateGlobal

opNone:

• Opcode.opNone

opPopHandler:

• COpcode.opPopHandler

opRestore:

• COpcode.opRestore

oprHigh:

• wordrecg: oprHigh

oprLow:

• wordrecg: oprLow

opSetTarget:

• COpcode.opSetTarget

opSlurp:

• vmdeps: opSlurp(file: string; info: TLineInfo; module: PSym; conf: ConfigRef): string

opStmt:

• COpcode.opStmt

opStmts:

• COpcode.opStmts

optAssert:

• TOption.optAssert

optBenchmarkVM:

• TGlobalOption.optBenchmarkVM

optBoundsCheck:

• TOption.optBoundsCheck

optByRef:

• TOption.optByRef

optCDebug:

• TGlobalOption.optCDebug

optCmdExitGcStats:

• TGlobalOption.optCmdExitGcStats

optCompileOnly:

• TGlobalOption.optCompileOnly

optCursorInference:

• TOption.optCursorInference

optDeclaredLocs:

• TGlobalOption.optDeclaredLocs

optDocInternal:

• TGlobalOption.optDocInternal

optDynlibOverrideAll:

• TGlobalOption.optDynlibOverrideAll

optEmbedOrigSrc:

• TGlobalOption.optEmbedOrigSrc

optEnableDeepCopy:

• TGlobalOption.optEnableDeepCopy

optExcessiveStackTrace:

• TGlobalOption.optExcessiveStackTrace

optFieldCheck:

• TOption.optFieldCheck

optForceFullMake:

• TGlobalOption.optForceFullMake

optGenDynLib:

• TGlobalOption.optGenDynLib

optGenGuiApp:

• TGlobalOption.optGenGuiApp

optGenIndex:

• TGlobalOption.optGenIndex

optGenMapping:

• TGlobalOption.optGenMapping

optGenScript:

• TGlobalOption.optGenScript

optGenStaticLib:

• TGlobalOption.optGenStaticLib

optHints:

• TOption.optHints

optIdeDebug:

• TGlobalOption.optIdeDebug

optImplicitStatic:

• TOption.optImplicitStatic

optImportHidden:

• TOption.optImportHidden

optInfCheck:

• TOption.optInfCheck

options:

• options: options(conf: ConfigRef): TOptions

options=:

• options: options=(conf: ConfigRef; opts: TOptions)

optLineDir:

• TOption.optLineDir

optLineTrace:

• TOption.optLineTrace

optListCmd:

• TGlobalOption.optListCmd

optMemTracker:

• TOption.optMemTracker

optMultiMethods:

• TGlobalOption.optMultiMethods

optNaNCheck:

• TOption.optNaNCheck

optNoLinking:

• TGlobalOption.optNoLinking

optNoMain:

• TGlobalOption.optNoMain

optNone:

• TOption.optNone

optNoNimblePath:

• TGlobalOption.optNoNimblePath

optObjCheck:

• TOption.optObjCheck

optOptimizeSize:

• TOption.optOptimizeSize

optOptimizeSpeed:

• TOption.optOptimizeSpeed

optOverflowCheck:

• TOption.optOverflowCheck

optPanics:

• TGlobalOption.optPanics

optPreserveOrigSource:

• options: optPreserveOrigSource(conf: ConfigRef): untyped

optProduceAsm:

• TGlobalOption.optProduceAsm

optProfiler:

• TOption.optProfiler

optProfileVM:

• TGlobalOption.optProfileVM

optRangeCheck:

• TOption.optRangeCheck

optRun:

• TGlobalOption.optRun

optSeqDestructors:

• TGlobalOption.optSeqDestructors

optShowAllMismatches:

• TGlobalOption.optShowAllMismatches

optSinkInference:

• TOption.optSinkInference

optSkipParentConfigFiles:

• TGlobalOption.optSkipParentConfigFiles

optSkipProjConfigFile:

• TGlobalOption.optSkipProjConfigFile

optSkipSystemConfigFile:

• TGlobalOption.optSkipSystemConfigFile

optSkipUserConfigFile:

• TGlobalOption.optSkipUserConfigFile

optSourcemap:

• TGlobalOption.optSourcemap

optStackTrace:

• TOption.optStackTrace

optStackTraceMsgs:

• TOption.optStackTraceMsgs

optStaticBoundsCheck:

• TOption.optStaticBoundsCheck

optStdout:

• TGlobalOption.optStdout

optStyleCheck:

• TOption.optStyleCheck

optStyleError:

• TGlobalOption.optStyleError

optStyleHint:

• TGlobalOption.optStyleHint

optThreadAnalysis:

• TGlobalOption.optThreadAnalysis

optThreads:

• TGlobalOption.optThreads

optTlsEmulation:

• TGlobalOption.optTlsEmulation

optTrMacros:

• TOption.optTrMacros

optUseColors:

• TGlobalOption.optUseColors

optUseNimcache:

• TGlobalOption.optUseNimcache

optWarns:

• TOption.optWarns

optWasNimscript:

• TGlobalOption.optWasNimscript

optWholeProject:

• TGlobalOption.optWholeProject

opUse:

• Opcode.opUse

OpValue:

• mirtrees: OpValue

OrdinalSeq:

• containers: OrdinalSeq

OrdinalType:

• types: OrdinalType

Original:

• Level.Original

originatingModule:

• ast_query: originatingModule(s: PSym): PSym

OS:

• platform: OS

os2Ops:

• vmops: os2Ops(): Override

osAix:

• TSystemOS.osAix

osAmiga:

• TSystemOS.osAmiga

osAndroid:

• TSystemOS.osAndroid

osAny:

• TSystemOS.osAny

osAtari:

• TSystemOS.osAtari

osCrossos:

• TSystemOS.osCrossos

osDos:

• TSystemOS.osDos

osDragonfly:

• TSystemOS.osDragonfly

osFreebsd:

• TSystemOS.osFreebsd

osFreeRTOS:

• TSystemOS.osFreeRTOS

osGenode:

• TSystemOS.osGenode

osHaiku:

• TSystemOS.osHaiku

osIos:

• TSystemOS.osIos

osIrix:

• TSystemOS.osIrix

osJS:

• TSystemOS.osJS

osLinux:

• TSystemOS.osLinux

osMacos:

• TSystemOS.osMacos

osMacosx:

• TSystemOS.osMacosx

osMorphos:

• TSystemOS.osMorphos

osNetbsd:

• TSystemOS.osNetbsd

osNetware:

• TSystemOS.osNetware

osNimVM:

• TSystemOS.osNimVM

osNintendoSwitch:

• TSystemOS.osNintendoSwitch

osNone:

• TSystemOS.osNone

osOpenbsd:

• TSystemOS.osOpenbsd

osOps:

• vmops: osOps(): Override

osOs2:

• TSystemOS.osOs2

osPalmos:

• TSystemOS.osPalmos

ospCaseInsensitive:

• TInfoOSProp.ospCaseInsensitive

ospLacksThreadVars:

• TInfoOSProp.ospLacksThreadVars

ospNeedsPIC:

• TInfoOSProp.ospNeedsPIC

ospPosix:

• TInfoOSProp.ospPosix

osQnx:

• TSystemOS.osQnx

osSkyos:

• TSystemOS.osSkyos

osSolaris:

• TSystemOS.osSolaris

osStandalone:

• TSystemOS.osStandalone

osVxWorks:

• TSystemOS.osVxWorks

osWindows:

• TSystemOS.osWindows

outdated:

• ModuleStatus.outdated

outDir:

• options: outDir(conf`gensym36: ConfigRef): AbsoluteDir

outDir=:

• options: outDir=(conf`gensym36: ConfigRef; val`gensym36: AbsoluteDir)

outFile:

• options: outFile(conf`gensym35: ConfigRef): RelativeFile

outFile=:

• options: outFile=(conf`gensym35: ConfigRef; val`gensym35: RelativeFile)

outputTrace:

• debugutils: outputTrace(conf: ConfigRef; t: CompilerTrace)

overlap:

• nimsets: overlap(a, b: PNode): bool
• vmdef: overlap(a, b: int; aLen, bLen: Natural): bool
• vmdef: overlap(a, b: pointer; aLen, bLen: Natural): bool

overlaps:

• aliasanalysis: overlaps(tree: MirTree; a, b: Path): Ternary
• aliasanalysis: overlaps(r: CmpLocsResult): Ternary

overloadableEnums:

• Feature.overloadableEnums

OverloadableSyms:

• ast_query: OverloadableSyms

OwnedRvalue:

• ExprKind.OwnedRvalue

PackageModuleId:

• ast_idgen: PackageModuleId

packDiscr:

• vmobjects: packDiscr(value, index, numBits: Natural): int

PackedConfig:

• ic: PackedConfig

packedConvDesc:

• vmdef: packedConvDesc(op: NumericConvKind; dstbytes, srcbytes: range[1 .. 8]): uint16

PackedDataKind:

• packed_env: PackedDataKind

PackedDataNode:

• packed_env: PackedDataNode

PackedDecoder:

• ic: PackedDecoder

PackedEncoder:

• ic: PackedEncoder
• packed_env: PackedEncoder

PackedEnv:

• packed_env: PackedEnv

PackedInstantiation:

• packed_ast: PackedInstantiation

PackedItemId:

• packed_ast: PackedItemId

PackedLib:

• packed_ast: PackedLib

PackedLineInfo:

• packed_ast: PackedLineInfo

PackedModule:

• ic: PackedModule

PackedModuleGraph:

• ic: PackedModuleGraph

PackedNode:

• packed_ast: PackedNode

packedRepr:

• semdata: packedRepr(c): untyped

PackedSym:

• packed_ast: PackedSym

PackedTree:

• packed_ast: PackedTree

PackedType:

• packed_ast: PackedType

PackedVmType:

• packed_env: PackedVmType

pairs:

• astalgo: pairs(t: TIdNodeTable): tuple[key: PIdObj, val: PNode]
• astalgo: pairs(t: TIdTable): tuple[key: int, value: RootRef]
• ast_parsed_types: pairs(node: ParsedNode): (int, ParsedNode)
• ast_query: pairs(n: PNode): tuple[i: int, n: PNode]
• cgir: pairs(n: CgNode): (int, CgNode)
• datatables: pairs(t: DataTable): (DataId, lent ConstrTree)
• mirtrees: pairs(tree: MirTree): (NodePosition, lent MirNode)
• btrees: pairs[Key, Val](b: BTree[Key, Val]): (Key, Val)
• containers: pairs[I; T](x: OrdinalSeq[I, T]): (I, lent T)
• containers: pairs[K, V](m: SeqMap[K, V]): (K, lent V)
• containers: pairs[I, T](x: Store[I, T]): (I, lent T)

ParamFlag:

• mirtypes: ParamFlag

paramName:

• lambdalifting: paramName

paramPragmas:

• pragmas: paramPragmas

params:

• cgendata: params(p: BProc): seq[TLoc]
• mirtypes: params(env: TypeEnv; desc: TypeHeader): tuple[i: int, typ: TypeId, flags: set[ParamFlag]]

paramsEqual:

• TParamsEquality.paramsEqual

paramsIncompatible:

• TParamsEquality.paramsIncompatible

paramsNotEqual:

• TParamsEquality.paramsNotEqual

paramsPos:

• ast_query: paramsPos

paramTypesMatch:

• sigmatch: paramTypesMatch(candidate: var TCandidate; formal, passed: PType; arg: PNode): PNode

parent:

• packed_ast: parent(n: NodePos): NodePos
• mirtrees: parent(tree: MirTree; n: NodePosition): NodePosition

Parent:

• Nilability.Parent

parentModule:

• modulegraphs: parentModule(g: ModuleGraph; fileIdx: FileIndex): FileIndex

parse:

• sourcemap: parse(source: string; path: string): SourceNode
• nversion: parse(s: string): Version

parseAll:

• parser: parseAll(p: var Parser): ParsedNode

parseCode:

• vmdeps: parseCode(code: string; cache: IdentCache; config: ConfigRef; filename: string; line: int): Result[PNode, Report]
• vmdeps: parseCode(code: string; cache: IdentCache; config: ConfigRef; info: TLineInfo): Result[ PNode, Report]

parseDecimalInt128:

• int128: parseDecimalInt128(arg: string; pos: int = 0): Int128

ParseDiag:

• ast_parsed_types: ParseDiag

ParseDiagKind:

• ast_parsed_types: ParseDiagKind

ParsedKindBracket:

• ast_parsed_types: ParsedKindBracket

ParsedKindLiteral:

• ast_parsed_types: ParsedKindLiteral

ParsedKindWithSons:

• ast_parsed_types: ParsedKindWithSons

ParsedNode:

• ast_parsed_types: ParsedNode

ParsedNodeData:

• ast_parsed_types: ParsedNodeData

ParsedNodeKind:

• ast_parsed_types: ParsedNodeKind

ParsedToken:

• ast_parsed_types: ParsedToken

parseFile:

• syntaxes: parseFile(fileIdx: FileIndex; cache: IdentCache; config: ConfigRef): ParsedNode

parseIdeCmd:

• options: parseIdeCmd(s: string): IdeCmd

parseNimVersion:

• options: parseNimVersion(a: string): NimVer

Parser:

• parser: Parser

ParserError:

• parser: ParserError

ParserReport:

• reports_parser: ParserReport

ParserReportKind:

• report_enums: ParserReportKind

parseString:

• parser: parseString(s: string; cache: IdentCache; config: ConfigRef; filename: string = ""; line: int = 0): ParsedNode

parseTopLevelStmt:

• parser: parseTopLevelStmt(p: var Parser): ParsedNode

partialMatch:

• sigmatch: partialMatch(c: PContext; n, nOrig: PNode; m: var TCandidate)

PartialStore:

• containers: PartialStore

Partitions:

• varpartitions: Partitions

passCmd1:

• TCmdLinePass.passCmd1

passCmd2:

• TCmdLinePass.passCmd2

passPP:

• TCmdLinePass.passPP

PAstDiag:

• ast_types: PAstDiag

patch:

• packed_ast: patch(tree: var PackedTree; pos: PatchPos)

Path:

• aliasanalysis: Path

pathNamed:

• mirconstr: pathNamed(bu: var MirBuilder; t: TypeId; f: int32; body: untyped)

pathPos:

• mirconstr: pathPos(bu: var MirBuilder; t: TypeId; p: uint32; body: untyped)

pathSubs:

• options: pathSubs(conf: ConfigRef; p, config: string): string

pathVariant:

• mirconstr: pathVariant(bu: var MirBuilder; t: TypeId; f: int32; body: untyped)

patternPos:

• ast_query: patternPos

Patterns:

• identpatterns: Patterns

pcmDifferentCallConv:

• ProcConvMismatch.pcmDifferentCallConv

pcmLockDifference:

• ProcConvMismatch.pcmLockDifference

pcmNoSideEffect:

• ProcConvMismatch.pcmNoSideEffect

pcmNotGcSafe:

• ProcConvMismatch.pcmNotGcSafe

pcmNotIterator:

• ProcConvMismatch.pcmNotIterator

PContext:

• semdata: PContext

pdkArray:

• PackedDataKind.pdkArray

pdkAsmStmtExpectsStrLit:

• ParseDiagKind.pdkAsmStmtExpectsStrLit

pdkConceptNotInType:

• ParseDiagKind.pdkConceptNotInType

pdkEnablePreviewDotOps:

• ParseDiagKind.pdkEnablePreviewDotOps

pdkExprExpected:

• ParseDiagKind.pdkExprExpected

pdkField:

• PackedDataKind.pdkField

pdkFloat:

• PackedDataKind.pdkFloat

pdkFuncNotAllowed:

• ParseDiagKind.pdkFuncNotAllowed

pdkIdentExpected:

• ParseDiagKind.pdkIdentExpected

pdkIdentExpectedEmptyAccQuote:

• ParseDiagKind.pdkIdentExpectedEmptyAccQuote

pdkInconsistentSpacing:

• ParseDiagKind.pdkInconsistentSpacing

pdkInt:

• PackedDataKind.pdkInt

pdkIntLit:

• PackedDataKind.pdkIntLit

pdkInvalidIndentation:

• ParseDiagKind.pdkInvalidIndentation

pdkInvalidIndentationWithForgotEqualSignHint:

• ParseDiagKind.pdkInvalidIndentationWithForgotEqualSignHint

pdkMisplacedExport:

• ParseDiagKind.pdkMisplacedExport

pdkMisplacedParameterVar:

• ParseDiagKind.pdkMisplacedParameterVar

pdkMissingToken:

• ParseDiagKind.pdkMissingToken

pdkNestableRequiresIndentation:

• ParseDiagKind.pdkNestableRequiresIndentation

pdkObj:

• PackedDataKind.pdkObj

pdkPragmaBeforeGenericParameters:

• ParseDiagKind.pdkPragmaBeforeGenericParameters

pdkPragmaDoesNotFollowTypeName:

• ParseDiagKind.pdkPragmaDoesNotFollowTypeName

pdkPtr:

• PackedDataKind.pdkPtr

pdkSet:

• PackedDataKind.pdkSet

pdkString:

• PackedDataKind.pdkString

pdkTupleTypeWithPar:

• ParseDiagKind.pdkTupleTypeWithPar

pdkUnexpectedToken:

• ParseDiagKind.pdkUnexpectedToken

pdkWithExtraData:

• ast_parsed_types: pdkWithExtraData

pdkWithoutExtraData:

• ast_parsed_types: pdkWithoutExtraData

PDoc:

• docgen: PDoc

PersistentNodeFlags:

• ast_query: PersistentNodeFlags

PEvalContext:

• compilerbridge: PEvalContext

pfByRef:

• ParamFlag.pfByRef

PGlobals:

• jsgen: PGlobals

pick:

• compat: pick[T](n: CgNode; forInt, forFloat: T): T

pickSym:

• lookups: pickSym(c: PContext; n: PNode; kinds: set[TSymKind]; flags: TSymFlags = {}): PSym

PickyCAliases:

• TTypeCmpFlag.PickyCAliases

PIdent:

• idents: PIdent

PIdentResult:

• lookups: PIdentResult

PIdObj:

• ast_types: PIdObj

pimCmd:

• ProjectInputMode.pimCmd

pimFile:

• ProjectInputMode.pimFile

pimStdin:

• ProjectInputMode.pimStdin

PInstantiation:

• ast_types: PInstantiation

pirAddr:

• ProtoItemKind.pirAddr

pirArrayAccess:

• ProtoItemKind.pirArrayAccess

pirArrayConstr:

• ProtoItemKind.pirArrayConstr

pirCall:

• ProtoItemKind.pirCall

pirCast:

• ProtoItemKind.pirCast

pirChckRange:

• ProtoItemKind.pirChckRange

pirCheckedArrayAccess:

• ProtoItemKind.pirCheckedArrayAccess

pirCheckedObjConv:

• ProtoItemKind.pirCheckedObjConv

pirCheckedSeqAccess:

• ProtoItemKind.pirCheckedSeqAccess

pirCheckedVariantAccess:

• ProtoItemKind.pirCheckedVariantAccess

pirClosureConstr:

• ProtoItemKind.pirClosureConstr

pirComplex:

• ProtoItemKind.pirComplex

pirConst:

• ProtoItemKind.pirConst

pirConstExpr:

• ProtoItemKind.pirConstExpr

pirConv:

• ProtoItemKind.pirConv

pirCopy:

• ProtoItemKind.pirCopy

pirCStringToString:

• ProtoItemKind.pirCStringToString

pirDeref:

• ProtoItemKind.pirDeref

pirDestructiveMove:

• ProtoItemKind.pirDestructiveMove

pirFieldAccess:

• ProtoItemKind.pirFieldAccess

pirGlobal:

• ProtoItemKind.pirGlobal

pirLiteral:

• ProtoItemKind.pirLiteral

pirLocal:

• ProtoItemKind.pirLocal

pirLvalueConv:

• ProtoItemKind.pirLvalueConv

pirMat:

• ProtoItemKind.pirMat

pirMatCursor:

• ProtoItemKind.pirMatCursor

pirMatLvalue:

• ProtoItemKind.pirMatLvalue

pirMove:

• ProtoItemKind.pirMove

pirObjConstr:

• ProtoItemKind.pirObjConstr

pirParam:

• ProtoItemKind.pirParam

pirProc:

• ProtoItemKind.pirProc

pirRefConstr:

• ProtoItemKind.pirRefConstr

pirSeqAccess:

• ProtoItemKind.pirSeqAccess

pirSeqConstr:

• ProtoItemKind.pirSeqConstr

pirSetConstr:

• ProtoItemKind.pirSetConstr

pirSink:

• ProtoItemKind.pirSink

pirStdConv:

• ProtoItemKind.pirStdConv

pirStmtList:

• ProtoItemKind.pirStmtList

pirStringToCString:

• ProtoItemKind.pirStringToCString

pirToSlice:

• ProtoItemKind.pirToSlice

pirToSubSlice:

• ProtoItemKind.pirToSubSlice

pirTupleAccess:

• ProtoItemKind.pirTupleAccess

pirTupleConstr:

• ProtoItemKind.pirTupleConstr

pirVariantAccess:

• ProtoItemKind.pirVariantAccess

pirView:

• ProtoItemKind.pirView

pirViewDeref:

• ProtoItemKind.pirViewDeref

PkgDesc:

• options: PkgDesc

PLLStream:

• llstream: PLLStream

Plugin:

• pluginsupport: Plugin

pluginMatches:

• pluginsupport: pluginMatches(ic: IdentCache; p: Plugin; s: PSym): bool

pnkAccQuoted:

• ParsedNodeKind.pnkAccQuoted

pnkArgList:

• ParsedNodeKind.pnkArgList

pnkAsgn:

• ParsedNodeKind.pnkAsgn

pnkAsmStmt:

• ParsedNodeKind.pnkAsmStmt

pnkBind:

• ParsedNodeKind.pnkBind

pnkBindStmt:

• ParsedNodeKind.pnkBindStmt

pnkBlockExpr:

• ParsedNodeKind.pnkBlockExpr

pnkBlockStmt:

• ParsedNodeKind.pnkBlockStmt

pnkBreakStmt:

• ParsedNodeKind.pnkBreakStmt

pnkCall:

• ParsedNodeKind.pnkCall

pnkCallKinds:

• ast_parsed_types: pnkCallKinds

pnkCallStrLit:

• ParsedNodeKind.pnkCallStrLit

pnkCaseStmt:

• ParsedNodeKind.pnkCaseStmt

pnkCast:

• ParsedNodeKind.pnkCast

pnkCharLit:

• ParsedNodeKind.pnkCharLit

pnkCommand:

• ParsedNodeKind.pnkCommand

pnkCommentStmt:

• ParsedNodeKind.pnkCommentStmt

pnkConstDef:

• ParsedNodeKind.pnkConstDef

pnkConstSection:

• ParsedNodeKind.pnkConstSection

pnkContinueStmt:

• ParsedNodeKind.pnkContinueStmt

pnkConverterDef:

• ParsedNodeKind.pnkConverterDef

pnkCurly:

• ParsedNodeKind.pnkCurly

pnkCurlyExpr:

• ParsedNodeKind.pnkCurlyExpr

pnkCustomLit:

• ParsedNodeKind.pnkCustomLit

pnkDeclarativeDefs:

• ast_parsed_types: pnkDeclarativeDefs

pnkDefer:

• ParsedNodeKind.pnkDefer

pnkDiscardStmt:

• ParsedNodeKind.pnkDiscardStmt

pnkDistinctTy:

• ParsedNodeKind.pnkDistinctTy

pnkDo:

• ParsedNodeKind.pnkDo

pnkDotExpr:

• ParsedNodeKind.pnkDotExpr

pnkElifBranch:

• ParsedNodeKind.pnkElifBranch

pnkElifExpr:

• ParsedNodeKind.pnkElifExpr

pnkElse:

• ParsedNodeKind.pnkElse

pnkElseExpr:

• ParsedNodeKind.pnkElseExpr

pnkEmpty:

• ParsedNodeKind.pnkEmpty

pnkEnumFieldDef:

• ParsedNodeKind.pnkEnumFieldDef

pnkEnumTy:

• ParsedNodeKind.pnkEnumTy

pnkError:

• ParsedNodeKind.pnkError

pnkExceptBranch:

• ParsedNodeKind.pnkExceptBranch

pnkExportExceptStmt:

• ParsedNodeKind.pnkExportExceptStmt

pnkExportStmt:

• ParsedNodeKind.pnkExportStmt

pnkExprColonExpr:

• ParsedNodeKind.pnkExprColonExpr

pnkExprEqExpr:

• ParsedNodeKind.pnkExprEqExpr

pnkFinally:

• ParsedNodeKind.pnkFinally

pnkFloat32Lit:

• ParsedNodeKind.pnkFloat32Lit

pnkFloat64Lit:

• ParsedNodeKind.pnkFloat64Lit

pnkFloatKinds:

• ast_parsed_types: pnkFloatKinds

pnkFloatLit:

• ParsedNodeKind.pnkFloatLit

pnkFormalParams:

• ParsedNodeKind.pnkFormalParams

pnkForStmt:

• ParsedNodeKind.pnkForStmt

pnkFromStmt:

• ParsedNodeKind.pnkFromStmt

pnkFuncDef:

• ParsedNodeKind.pnkFuncDef

pnkGenericParams:

• ParsedNodeKind.pnkGenericParams

pnkIdent:

• ParsedNodeKind.pnkIdent

pnkIdentDefs:

• ParsedNodeKind.pnkIdentDefs

pnkIfExpr:

• ParsedNodeKind.pnkIfExpr

pnkIfStmt:

• ParsedNodeKind.pnkIfStmt

pnkImportExceptStmt:

• ParsedNodeKind.pnkImportExceptStmt

pnkImportStmt:

• ParsedNodeKind.pnkImportStmt

pnkIncludeStmt:

• ParsedNodeKind.pnkIncludeStmt

pnkInfix:

• ParsedNodeKind.pnkInfix

pnkInt16Lit:

• ParsedNodeKind.pnkInt16Lit

pnkInt32Lit:

• ParsedNodeKind.pnkInt32Lit

pnkInt64Lit:

• ParsedNodeKind.pnkInt64Lit

pnkInt8Lit:

• ParsedNodeKind.pnkInt8Lit

pnkIntKinds:

• ast_parsed_types: pnkIntKinds

pnkIntLit:

• ParsedNodeKind.pnkIntLit

pnkIteratorDef:

• ParsedNodeKind.pnkIteratorDef

pnkIteratorTy:

• ParsedNodeKind.pnkIteratorTy

pnkLambda:

• ParsedNodeKind.pnkLambda

pnkLetSection:

• ParsedNodeKind.pnkLetSection

pnkMacroDef:

• ParsedNodeKind.pnkMacroDef

pnkMethodDef:

• ParsedNodeKind.pnkMethodDef

pnkMixinStmt:

• ParsedNodeKind.pnkMixinStmt

pnkMutableTy:

• ParsedNodeKind.pnkMutableTy

pnkNilLit:

• ParsedNodeKind.pnkNilLit

pnkObjConstr:

• ParsedNodeKind.pnkObjConstr

pnkObjectTy:

• ParsedNodeKind.pnkObjectTy

pnkOfBranch:

• ParsedNodeKind.pnkOfBranch

pnkOfInherit:

• ParsedNodeKind.pnkOfInherit

pnkPar:

• ParsedNodeKind.pnkPar

pnkParsedKindsWithSons:

• ast_parsed_types: pnkParsedKindsWithSons

pnkPostfix:

• ParsedNodeKind.pnkPostfix

pnkPragma:

• ParsedNodeKind.pnkPragma

pnkPragmaBlock:

• ParsedNodeKind.pnkPragmaBlock

pnkPragmaExpr:

• ParsedNodeKind.pnkPragmaExpr

pnkPrefix:

• ParsedNodeKind.pnkPrefix

pnkProcDef:

• ParsedNodeKind.pnkProcDef

pnkProcTy:

• ParsedNodeKind.pnkProcTy

pnkPtrTy:

• ParsedNodeKind.pnkPtrTy

pnkRaiseStmt:

• ParsedNodeKind.pnkRaiseStmt

pnkRecCase:

• ParsedNodeKind.pnkRecCase

pnkRecList:

• ParsedNodeKind.pnkRecList

pnkRecWhen:

• ParsedNodeKind.pnkRecWhen

pnkRefTy:

• ParsedNodeKind.pnkRefTy

pnkReturnStmt:

• ParsedNodeKind.pnkReturnStmt

pnkRoutineDefs:

• ast_parsed_types: pnkRoutineDefs

pnkRStrLit:

• ParsedNodeKind.pnkRStrLit

pnkSqrBracket:

• ParsedNodeKind.pnkSqrBracket

pnkSqrBracketExpr:

• ParsedNodeKind.pnkSqrBracketExpr

pnkStaticStmt:

• ParsedNodeKind.pnkStaticStmt

pnkStaticTy:

• ParsedNodeKind.pnkStaticTy

pnkStmtList:

• ParsedNodeKind.pnkStmtList

pnkStmtListExpr:

• ParsedNodeKind.pnkStmtListExpr

pnkStrKinds:

• ast_parsed_types: pnkStrKinds

pnkStrLit:

• ParsedNodeKind.pnkStrLit

pnkTableConstr:

• ParsedNodeKind.pnkTableConstr

pnkTemplateDef:

• ParsedNodeKind.pnkTemplateDef

pnkTripleStrLit:

• ParsedNodeKind.pnkTripleStrLit

pnkTryStmt:

• ParsedNodeKind.pnkTryStmt

pnkTupleClassTy:

• ParsedNodeKind.pnkTupleClassTy

pnkTupleConstr:

• ParsedNodeKind.pnkTupleConstr

pnkTupleTy:

• ParsedNodeKind.pnkTupleTy

pnkTypeClassTy:

• ParsedNodeKind.pnkTypeClassTy

pnkTypeDef:

• ParsedNodeKind.pnkTypeDef

pnkTypeOfExpr:

• ParsedNodeKind.pnkTypeOfExpr

pnkTypeSection:

• ParsedNodeKind.pnkTypeSection

pnkUInt16Lit:

• ParsedNodeKind.pnkUInt16Lit

pnkUInt32Lit:

• ParsedNodeKind.pnkUInt32Lit

pnkUInt64Lit:

• ParsedNodeKind.pnkUInt64Lit

pnkUInt8Lit:

• ParsedNodeKind.pnkUInt8Lit

pnkUIntLit:

• ParsedNodeKind.pnkUIntLit

pnkUsingStmt:

• ParsedNodeKind.pnkUsingStmt

pnkVarSection:

• ParsedNodeKind.pnkVarSection

pnkVarTuple:

• ParsedNodeKind.pnkVarTuple

pnkVarTy:

• ParsedNodeKind.pnkVarTy

pnkWhenExpr:

• ParsedNodeKind.pnkWhenExpr

pnkWhenStmt:

• ParsedNodeKind.pnkWhenStmt

pnkWhileStmt:

• ParsedNodeKind.pnkWhileStmt

pnkWith:

• ParsedNodeKind.pnkWith

pnkWithout:

• ParsedNodeKind.pnkWithout

pnkYieldStmt:

• ParsedNodeKind.pnkYieldStmt

PNode:

• ast_types: PNode

PointerType:

• mirtypes: PointerType

pop:

• mirconstr: pop(bu: var MirBuilder; f: Fragment)
• mirgen_blocks: pop(c: var BlockCtx): Block

popCaseContext:

• semdata: popCaseContext(c: PContext)

popExecCon:

• semdata: popExecCon(c: PContext)

popInfoContext:

• msgs: popInfoContext(conf: ConfigRef)

popOptionEntry:

• semdata: popOptionEntry(c: PContext)

popOwner:

• semdata: popOwner(c: PContext)

popProcCon:

• semdata: popProcCon(c: PContext)

popSingle:

• mirconstr: popSingle(bu: var MirBuilder; f: Fragment): Value

POptionEntry:

• semdata: POptionEntry

pos:

• mirconstr: pos(f: Fragment): NodePosition

PosBody:

• NodePosName.PosBody

PosInit:

• NodePosName.PosInit

PosLastIdent:

• NodePosName.PosLastIdent

PosName:

• NodePosName.PosName

PosPragma:

• NodePosName.PosPragma

PosProcArgs:

• NodePosName.PosProcArgs

PosProcBody:

• NodePosName.PosProcBody

PosProcReturn:

• NodePosName.PosProcReturn

PosType:

• NodePosName.PosType

PosTypeBody:

• NodePosName.PosTypeBody

PPassContext:

• modulegraphs: PPassContext

PProc:

• jsgen: PProc

PProcCon:

• semdata: PProcCon

pragmaAsm:

• pragmas: pragmaAsm(c: PContext; n: PNode): tuple[marker: char, err: PNode]

pragmaDecl:

• pragmas: pragmaDecl(c: PContext; sym: PSym; n: PNode; validPragmas: TSpecialWords): PNode

pragmaDeclNoImplicit:

• pragmas: pragmaDeclNoImplicit(c: PContext; sym: PSym; n: PNode; validPragmas: TSpecialWords): PNode

pragmaExpr:

• pragmas: pragmaExpr(c: PContext; n: PNode): PNode

pragmasEffects:

• ast_types: pragmasEffects

pragmasPos:

• ast_query: pragmasPos

pragmaStmt:

• pragmas: pragmaStmt(c: PContext; n: PNode; owner: PSym): PNode

preferDesc:

• TPreferedDesc.preferDesc

preferExported:

• TPreferedDesc.preferExported

preferGenericArg:

• TPreferedDesc.preferGenericArg

preferMixed:

• TPreferedDesc.preferMixed

preferModuleInfo:

• TPreferedDesc.preferModuleInfo

preferName:

• TPreferedDesc.preferName

preferResolved:

• TPreferedDesc.preferResolved

preferTypeName:

• TPreferedDesc.preferTypeName

prefixDir:

• options: prefixDir(conf`gensym24: ConfigRef): AbsoluteDir

prefixDir=:

• options: prefixDir=(conf`gensym24: ConfigRef; val`gensym24: AbsoluteDir)

PrefixMatch:

• prefixmatches: PrefixMatch

prefixMatch:

• prefixmatches: prefixMatch(p, s: string): PrefixMatch

prepare:

• packed_ast: prepare(dest: var PackedTree; source: PackedTree; sourcePos: NodePos): PatchPos
• packed_ast: prepare(tree: var PackedTree; kind: TNodeKind; flags: TNodeFlags; typeId: PackedItemId; info: PackedLineInfo): PatchPos
• treechangesets: prepare(c: sink Changeset): PreparedChangeset

PreparedChangeset:

• treechangesets: PreparedChangeset

prepareNode:

• semtypinst: prepareNode(cl: var TReplTypeVars; n: PNode): PNode

prepareToWriteOutput:

• options: prepareToWriteOutput(conf: ConfigRef): AbsoluteFile

prepend:

• ropes: prepend(a: var Rope; b: string)

prependCurDir:

• cmdlinehelper: prependCurDir(f: AbsoluteFile): AbsoluteFile

preprocess:

• backends: preprocess(queue: var WorkQueue; graph: ModuleGraph; idgen: IdGenerator; env: MirEnv; id: ProcedureId; module: FileIndex)

presentationPath:

• docgen: presentationPath(conf: ConfigRef; file: AbsoluteFile): RelativeFile

presentSpellingCandidates:

• cli_reporter: presentSpellingCandidates(conf: ConfigRef; candidates: seq[SemSpellCandidate]): string

prettyTok:

• lexer: prettyTok(tok: Token): string

preventStackTrace:

• CodegenFlag.preventStackTrace

previous:

• mirtrees: previous(tree: MirTree; n: NodePosition): NodePosition

previouslyInferred:

• ast_query: previouslyInferred(t: PType): PType

PrgCtr:

• vmdef: PrgCtr

printTok:

• lexer: printTok(conf: ConfigRef; tok: Token)

ProcBuilder:

• mirtypes: ProcBuilder

ProcConvMismatch:

• ast_types: ProcConvMismatch

procDefs:

• ast_query: procDefs

ProcedureId:

• mirtrees: ProcedureId

process:

• backends: process(graph: ModuleGraph; modules: var ModuleList; env: var MirEnv; discovery: var DiscoveryData; conf: BackendConfig): BackendEvent

processArgument:

• commands: processArgument(pass: TCmdLinePass; p: OptParser; argsCount: var int; config: ConfigRef): bool

processCmdLine:

• commands: processCmdLine(pass: TCmdLinePass; cmd: openArray[string]; config: ConfigRef)

processCmdLineAndProjectPath:

• cmdlinehelper: processCmdLineAndProjectPath(self: NimProg; conf: ConfigRef; cmd: openArray[string])

processModule:

• passes: processModule(graph: ModuleGraph; module: PSym; idgen: IdGenerator; defaultStream: PLLStream): bool

ProcessNoteResult:

• optionsprocessor: ProcessNoteResult

ProcessNoteResultKind:

• optionsprocessor: ProcessNoteResultKind

processSpecificNote:

• optionsprocessor: processSpecificNote(arg: string; state: TSpecialWord; pass: TCmdLinePass; orig: string; conf: ConfigRef): ProcessNoteResult

processSwitch:

• optionsprocessor: processSwitch(switch, arg: string; pass: TCmdLinePass; conf: ConfigRef): ProcSwitchResult
• optionsprocessor: processSwitch(pass: TCmdLinePass; p: OptParser; config: ConfigRef): ProcSwitchResult

procInstCacheItems:

• modulegraphs: procInstCacheItems(g: ModuleGraph; s: PSym): PInstantiation

procInstCacheSection:

• RodSection.procInstCacheSection

ProcLoc:

• cgendata: ProcLoc

procNode:

• mirconstr: procNode(id: ProcedureId): MirNode

procNoteExpectedOnOrOff:

• ProcessNoteResultKind.procNoteExpectedOnOrOff

procNoteInvalidHint:

• ProcessNoteResultKind.procNoteInvalidHint

procNoteInvalidOption:

• ProcessNoteResultKind.procNoteInvalidOption

procNoteInvalidWarning:

• ProcessNoteResultKind.procNoteInvalidWarning

procNoteOnlyAllOffSupported:

• ProcessNoteResultKind.procNoteOnlyAllOffSupported

procNoteSuccess:

• ProcessNoteResultKind.procNoteSuccess

procPragmas:

• pragmas: procPragmas

procResultToHumanStr:

• optionsprocessor: procResultToHumanStr(procResult: ProcSwitchResult): string

procs:

• cgendata: procs(m: BModule): untyped

procSec:

• cgendata: procSec(p: BProc; s: TCProcSection): var Rope

procSwitchErrArgExpected:

• ProcSwitchResultKind.procSwitchErrArgExpected

procSwitchErrArgExpectedAllOrOff:

• ProcSwitchResultKind.procSwitchErrArgExpectedAllOrOff

procSwitchErrArgExpectedFromList:

• ProcSwitchResultKind.procSwitchErrArgExpectedFromList

procSwitchErrArgExpectedOnOffOrList:

• ProcSwitchResultKind.procSwitchErrArgExpectedOnOffOrList

procSwitchErrArgExpectedOnOrOff:

• ProcSwitchResultKind.procSwitchErrArgExpectedOnOrOff

procSwitchErrArgForbidden:

• ProcSwitchResultKind.procSwitchErrArgForbidden

procSwitchErrArgInvalidHintOrWarning:

• ProcSwitchResultKind.procSwitchErrArgInvalidHintOrWarning

procSwitchErrArgMalformedKeyValPair:

• ProcSwitchResultKind.procSwitchErrArgMalformedKeyValPair

procSwitchErrArgNimblePath:

• ProcSwitchResultKind.procSwitchErrArgNimblePath

procSwitchErrArgNotInValidList:

• ProcSwitchResultKind.procSwitchErrArgNotInValidList

procSwitchErrArgPathInvalid:

• ProcSwitchResultKind.procSwitchErrArgPathInvalid

procSwitchErrArgUnknownCCompiler:

• ProcSwitchResultKind.procSwitchErrArgUnknownCCompiler

procSwitchErrArgUnknownExperimentalFeature:

• ProcSwitchResultKind.procSwitchErrArgUnknownExperimentalFeature

procSwitchErrInvalid:

• ProcSwitchResultKind.procSwitchErrInvalid

ProcSwitchNimblePathResult:

• optionsprocessor: ProcSwitchNimblePathResult

ProcSwitchResult:

• optionsprocessor: ProcSwitchResult

ProcSwitchResultErrorKind:

• optionsprocessor: ProcSwitchResultErrorKind

procSwitchResultErrorKinds:

• optionsprocessor: procSwitchResultErrorKinds

ProcSwitchResultKind:

• optionsprocessor: ProcSwitchResultKind

procSwitchResultToEvents:

• commands: procSwitchResultToEvents(conf: ConfigRef; pass: TCmdLinePass; origParseOptKey, origParseOptVal: string; r: ProcSwitchResult): CliEvent

procSwitchSuccess:

• ProcSwitchResultKind.procSwitchSuccess

procTypePragmas:

• pragmas: procTypePragmas

produceDestructorForDiscriminator:

• liftdestructors: produceDestructorForDiscriminator(g: ModuleGraph; typ: PType; field: PSym; info: TLineInfo; idgen: IdGenerator): PSym

ProfileInfo:

• vmdef: ProfileInfo

Profiler:

• vmdef: Profiler

projectFull:

• options: projectFull(conf`gensym40: ConfigRef): AbsoluteFile

projectFull=:

• options: projectFull=(conf`gensym40: ConfigRef; val`gensym40: AbsoluteFile)

ProjectInputMode:

• options: ProjectInputMode

projectName:

• options: projectName(conf`gensym39: ConfigRef): string

projectName=:

• options: projectName=(conf`gensym39: ConfigRef; val`gensym39: string)

projectPath:

• options: projectPath(conf`gensym38: ConfigRef): AbsoluteDir

projectPath=:

• options: projectPath=(conf`gensym38: ConfigRef; val`gensym38: AbsoluteDir)

propagateToOwner:

• ast: propagateToOwner(owner, elem: PType; propagateHasAsgn = true)

ProtoItem:

• proto_mir: ProtoItem

ProtoItemKind:

• proto_mir: ProtoItemKind

proveLe:

• guards: proveLe(m: TModel; a, b: PNode): TImplication

PScope:

• ast_types: PScope

pseudoAtomKinds:

• vmdef: pseudoAtomKinds

PSym:

• ast_types: PSym

PtrLikeKinds:

• ast_query: PtrLikeKinds

PType:

• ast_types: PType

pureEnumsSection:

• RodSection.pureEnumsSection

push:

• mirconstr: push(bu: var MirBuilder; body: untyped): Fragment

pushCaseContext:

• semdata: pushCaseContext(c: PContext; caseNode: PNode)

pushExecCon:

• semdata: pushExecCon(c: PContext; flags: set[ExecutionConFlag])

pushInfoContext:

• msgs: pushInfoContext(conf: ConfigRef; info: TLineInfo; detail: PSym = nil)

pushOptionEntry:

• semdata: pushOptionEntry(c: PContext): POptionEntry

pushOwner:

• semdata: pushOwner(c: PContext; owner: PSym)

pushProcCon:

• semdata: pushProcCon(c: PContext; owner: PSym)

put:

• semdata: put(p: PProcCon; key, val: PSym)

PVmCtx:

• compilerbridge: PVmCtx

PVmType:

• vmdef: PVmType

qualifiedLookUp:

• lookups: qualifiedLookUp(c: PContext; n: PNode; flags: set[TLookupFlag]): PSym

quitOrRaise:

• options: quitOrRaise(conf: ConfigRef; msg = "")

quotedFilename:

• msgs: quotedFilename(conf: ConfigRef; i: TLineInfo): Rope

quoteExpr:

• astmsgs: quoteExpr(a: string): untyped

quoteShell:

• pathutils: quoteShell(x: AbsoluteDir): string
• pathutils: quoteShell(x: AbsoluteFile): string

raiseExit:

• mirgen_blocks: raiseExit(c; bu)

raiseRecoverableError:

• lineinfos: raiseRecoverableError(msg: string)

raiseVmError:

• vmerrors: raiseVmError(event: sink VmEvent; inst: InstantiationInfo)
• vmerrors: raiseVmError(event: VmEvent)

rangeHasUnresolvedStatic:

• semdata: rangeHasUnresolvedStatic(t: PType): bool

rawAddField:

• lowerings: rawAddField(obj: PType; field: PSym)

rawAddSon:

• ast: rawAddSon(father, son: PType; propagateHasAsgn = true)

rawAddSonNoPropagationOfTypeFlags:

• ast: rawAddSonNoPropagationOfTypeFlags(father, son: PType)

rawBuildCall:

• mirconstr: rawBuildCall(bu: var MirBuilder; k: MirNodeKind; t: TypeId; sideEffects: bool; body: untyped)

rawCloseScope:

• lookups: rawCloseScope(c: PContext)

rawDirectAccess:

• lowerings: rawDirectAccess(obj, field: PSym): PNode

rawGetTok:

• lexer: rawGetTok(L: var Lexer; tok: var Token)

rawIndirectAccess:

• lowerings: rawIndirectAccess(a: PNode; field: PSym; info: TLineInfo): PNode

rawNewModule:

• cgen: rawNewModule(g: BModuleList; module: PSym; filename: AbsoluteFile): BModule

rawPointer:

• vmdef: rawPointer(p: VmMemPointer | CellPtr): untyped
• vmdef: rawPointer(h: LocHandle): untyped

rbackCannotProduceAssembly:

• ReportKind.rbackCannotProduceAssembly

rbackCannotWriteMappingFile:

• ReportKind.rbackCannotWriteMappingFile

rbackCannotWriteScript:

• ReportKind.rbackCannotWriteScript

rbackCompiling:

• ReportKind.rbackCompiling

rbackErrorKinds:

• report_enums: rbackErrorKinds

rbackHintKinds:

• report_enums: rbackHintKinds

rbackJsonScriptMismatch:

• ReportKind.rbackJsonScriptMismatch

rbackJsTooCaseTooLarge:

• ReportKind.rbackJsTooCaseTooLarge

rbackLinking:

• ReportKind.rbackLinking

rbackProducedAssembly:

• ReportKind.rbackProducedAssembly

rbackRstBrokenLink:

• ReportKind.rbackRstBrokenLink

rbackRstCannotOpenFile:

• ReportKind.rbackRstCannotOpenFile

rbackRstExpected:

• ReportKind.rbackRstExpected

rbackRstFootnoteMismatch:

• ReportKind.rbackRstFootnoteMismatch

rbackRstGeneralParseError:

• ReportKind.rbackRstGeneralParseError

rbackRstGridTableNotImplemented:

• ReportKind.rbackRstGridTableNotImplemented

rbackRstInvalidDirective:

• ReportKind.rbackRstInvalidDirective

rbackRstInvalidField:

• ReportKind.rbackRstInvalidField

rbackRstMarkdownIllformedTable:

• ReportKind.rbackRstMarkdownIllformedTable

rbackRstNewSectionExpected:

• ReportKind.rbackRstNewSectionExpected

rbackRstRedefinitionOfLabel:

• ReportKind.rbackRstRedefinitionOfLabel

rbackRstRstStyle:

• ReportKind.rbackRstRstStyle

rbackRstTestUnsupported:

• ReportKind.rbackRstTestUnsupported

rbackRstUnknownSubstitution:

• ReportKind.rbackRstUnknownSubstitution

rbackRstUnsupportedField:

• ReportKind.rbackRstUnsupportedField

rbackRstUnsupportedLanguage:

• ReportKind.rbackRstUnsupportedLanguage

rbackTargetNotSupported:

• ReportKind.rbackTargetNotSupported

rbackVmFileWriteFailed:

• ReportKind.rbackVmFileWriteFailed

rbackWarningKinds:

• report_enums: rbackWarningKinds

rclosed:

• modulelowering: rclosed(modules: ModuleList): lent Module

rcmdCompiling:

• ReportKind.rcmdCompiling

rcmdErrorKinds:

• report_enums: rcmdErrorKinds

rcmdExecuting:

• ReportKind.rcmdExecuting

rcmdFailedExecution:

• ReportKind.rcmdFailedExecution

rcmdHintKinds:

• report_enums: rcmdHintKinds

rcmdLinking:

• ReportKind.rcmdLinking

rcmdRunnableExamplesSuccess:

• ReportKind.rcmdRunnableExamplesSuccess

rcmdWarningKinds:

• report_enums: rcmdWarningKinds

rdbgOptionsPop:

• ReportKind.rdbgOptionsPop

rdbgOptionsPush:

• ReportKind.rdbgOptionsPush

rdbgVmExecTraceFull:

• ReportKind.rdbgVmExecTraceFull

rdbgVmExecTraceMinimal:

• ReportKind.rdbgVmExecTraceMinimal

readAs:

• vmconv: readAs[T](src: LocHandle; t: typedesc[T]): T

readConfigFile:

• nimconf: readConfigFile(filename: AbsoluteFile; cache: IdentCache; conf: ConfigRef; evtHandler: NimConfEvtWriter): bool

readDiscrBranch:

• vmobjects: readDiscrBranch(loc: LocHandle; owner: PVmType; idx: FieldIndex): int

readDiscriminant:

• vmobjects: readDiscriminant(h: LocHandle): BiggestInt
• vmobjects: readDiscriminant(h: VmMemoryRegion; numBits: Natural): BiggestInt

readFloat:

• vmobjects: readFloat(m: VmMemoryRegion): BiggestFloat

readFloat32:

• vmobjects: readFloat32(m: VmMemoryRegion): BiggestFloat

readFloat64:

• vmobjects: readFloat64(m: VmMemoryRegion): BiggestFloat

readFromFile:

• packed_env: readFromFile(p: var PackedEnv; file: AbsoluteFile): RodFileError

readIntBits:

• vmobjects: readIntBits(r: VmMemoryRegion): BiggestInt

readOnlySf:

• SymbolFilesOption.readOnlySf

readUInt:

• vmobjects: readUInt(r: VmMemoryRegion): BiggestInt

realAtomKinds:

• vmdef: realAtomKinds

RecField:

• mirtypes: RecField

recordAdd:

• macrocacheimpl: recordAdd(c: var TCtx; info: TLineInfo; key: string; val: PNode)

recordInc:

• macrocacheimpl: recordInc(c: var TCtx; info: TLineInfo; key: string; by: BiggestInt)

recordIncl:

• macrocacheimpl: recordIncl(c: var TCtx; info: TLineInfo; key: string; val: PNode)

recordPut:

• macrocacheimpl: recordPut(c: var TCtx; info: TLineInfo; key: string; k: string; val: PNode)

reexportsSection:

• RodSection.reexportsSection

reexportSym:

• semdata: reexportSym(c: PContext; s: PSym)

refresh:

• vmdef: refresh(c: var TCtx; module: PSym; idgen: IdGenerator)

regA:

• vmdef: regA(x: TInstr): TRegister

regAMask:

• vmdef: regAMask

regAShift:

• vmdef: regAShift

regB:

• vmdef: regB(x: TInstr): TRegister

regBMask:

• vmdef: regBMask

regBShift:

• vmdef: regBShift

regBx:

• vmdef: regBx(x: TInstr): int

regBxMask:

• vmdef: regBxMask

regBxMax:

• vmdef: regBxMax

regBxMin:

• vmdef: regBxMin

regBxShift:

• vmdef: regBxShift

regC:

• vmdef: regC(x: TInstr): TRegister

regCMask:

• vmdef: regCMask

regCShift:

• vmdef: regCShift

register:

• mirgen_blocks: register(c; loc: Value)

registerAdditionalOps:

• compilerbridge: registerAdditionalOps(c: var TCtx; disallowDangerous: bool)

registerCallback:

• vmjit: registerCallback(c: var TCtx; pattern: string; callback: VmCallback)

registerCompilerProc:

• magicsys: registerCompilerProc(g: ModuleGraph; s: PSym)

registerModule:

• modulegraphs: registerModule(g: ModuleGraph; m: PSym)

registerModuleById:

• modulegraphs: registerModuleById(g: ModuleGraph; m: FileIndex)

registerNimScriptSymbol:

• magicsys: registerNimScriptSymbol(g: ModuleGraph; s: PSym)

registerNimScriptSymbol2:

• magicsys: registerNimScriptSymbol2(g: ModuleGraph; s: PSym): PNode

registerPass:

• passes: registerPass(g: ModuleGraph; p: TPass)

registerProcedure:

• vmjit: registerProcedure(jit: var JitState; c: var TCtx; prc: PSym): FunctionIndex

regOMask:

• vmdef: regOMask

regOShift:

• vmdef: regOShift

regToNode:

• vm: regToNode(c: TCtx; x: TFullReg; typ: PType; info: TLineInfo): PNode

RelativeDir:

• pathutils: RelativeDir

RelativeFile:

• pathutils: RelativeFile

relativeJumps:

• vm_enums: relativeJumps

relativeTo:

• pathutils: relativeTo(fullPath: AbsoluteFile; baseFilename: AbsoluteDir; sep = DirSep): RelativeFile

rememberEmittedTypeInfo:

• modulegraphs: rememberEmittedTypeInfo(g: ModuleGraph; m: FileIndex; ti: string)

rememberExpansion:

• semdata: rememberExpansion(c: PContext; info: TLineInfo; expandedSym: PSym)

rememberFlag:

• modulegraphs: rememberFlag(g: ModuleGraph; m: PSym; flag: ModuleBackendFlag)

rememberStartupConfig:

• ic: rememberStartupConfig(dest: var PackedConfig; config: ConfigRef)

remove:

• mirchangesets: remove(c: var Changeset; tree: MirTree; at: NodePosition)
• treechangesets: remove(c: var Changeset; tree: MirTree; at: NodePosition)

removeFile:

• pathutils: removeFile(x: AbsoluteFile)

removeTrailingDirSep:

• options: removeTrailingDirSep(path: string): string

render:

• utils: render(tree: MirTree; env: ptr MirEnv = nil; body: ptr MirBody = nil): string

renderAsType:

• cli_reporter: renderAsType(vals: IntSet; t: PType): string

renderCodeListing:

• vmutils: renderCodeListing(config: ConfigRef; sym: PSym; entries: seq[DebugVmCodeEntry]): string

renderDefinitionName:

• renderer: renderDefinitionName(s: PSym; noQuotes = false): string

renderDocComments:

• TRenderFlag.renderDocComments

renderIds:

• TRenderFlag.renderIds

renderIr:

• TRenderFlag.renderIr

renderModule:

• renderer: renderModule(n: PNode; outfile: string; renderFlags: TRenderFlags = {}; fid = FileIndex(-1); conf: ConfigRef = nil)

renderNoBody:

• TRenderFlag.renderNoBody

renderNoComments:

• TRenderFlag.renderNoComments

renderNone:

• TRenderFlag.renderNone

renderNoPragmas:

• TRenderFlag.renderNoPragmas

renderNoProcDefs:

• TRenderFlag.renderNoProcDefs

renderParamTypes:

• typesrenderer: renderParamTypes(n: PNode; sep = defaultParamSeparator): string

renderPlainSymbolName:

• typesrenderer: renderPlainSymbolName(n: PNode): string

renderRunnableExamples:

• TRenderFlag.renderRunnableExamples

renderSyms:

• TRenderFlag.renderSyms

renderTree:

• renderer: renderTree(n: PNode; renderFlags: TRenderFlags = {}): string

renderWithoutErrorPrefix:

• TRenderFlag.renderWithoutErrorPrefix

repAllKinds:

• report_enums: repAllKinds

repBackend:

• ReportCategory.repBackend

repBackendKinds:

• report_enums: repBackendKinds

repCmd:

• ReportCategory.repCmd

repCmdKinds:

• report_enums: repCmdKinds

repDataPassKinds:

• report_enums: repDataPassKinds

repDebug:

• ReportCategory.repDebug

repDebugKinds:

• report_enums: repDebugKinds

repErrorKinds:

• report_enums: repErrorKinds

repExternal:

• ReportCategory.repExternal

repExternalKinds:

• report_enums: repExternalKinds

repFatalKinds:

• report_enums: repFatalKinds

repHintGroups:

• report_enums: repHintGroups

repHintKinds:

• report_enums: repHintKinds

repInternal:

• ReportCategory.repInternal

repInternalKinds:

• report_enums: repInternalKinds

replace:

• mirchangesets: replace(c: var Changeset; tree: MirTree; at: NodePosition; with: MirNode)
• treechangesets: replace(c: var Changeset; tree: MirTree; at: NodePosition; with: sink MirNode)

replaceMulti:

• mirchangesets: replaceMulti(c: var Changeset; tree: MirTree; at: NodePosition; name, body: untyped)
• treechangesets: replaceMulti(c: var Changeset; tree: MirTree; at: NodePosition; name, body: untyped)

replaceTypeParamsInType:

• semtypinst: replaceTypeParamsInType(c: PContext; pt: TIdTable; t: PType): PType

replaceTypeVarsInBody:

• semtypinst: replaceTypeVarsInBody(c: PContext; pt: TIdTable; n: PNode): PNode

replaceTypeVarsT:

• semtypinst: replaceTypeVarsT(cl: var TReplTypeVars; t: PType): PType

replayBackendRoutines:

• replayer: replayBackendRoutines(g: ModuleGraph; module: int)

replayGenericCacheInformation:

• replayer: replayGenericCacheInformation(g: ModuleGraph; module: int)

replayLibs:

• replayer: replayLibs(g: ModuleGraph; module: int)

replayStateChanges:

• replayer: replayStateChanges(module: PSym; g: ModuleGraph)

repLexer:

• ReportCategory.repLexer

repLexerKinds:

• report_enums: repLexerKinds

repLinkingHints:

• report_enums: repLinkingHints

repLinterKinds:

• report_enums: repLinterKinds

repNilcheckKinds:

• report_enums: repNilcheckKinds

repNone:

• ReportKind.repNone

Report:

• reports: Report

report:

• msgs: report(conf: ConfigRef; node: PNode): TErrorHandling
• options: report(conf: ConfigRef; inReport: Report): TErrorHandling
• options: report[R: ReportTypes](conf: ConfigRef; inReport: R): TErrorHandling
• options: report[R: ReportTypes](conf: ConfigRef; tinfo: TLineInfo; inReport: R): TErrorHandling

reportAst:

• reports_sem: reportAst(kind: ReportKind; ast: PNode; str: string = ""; typ: PType = nil; sym: PSym = nil): SemReport

ReportBase:

• reports_base: ReportBase

reportBody:

• cli_reporter: reportBody(conf: ConfigRef; r: BackendReport): string
• cli_reporter: reportBody(conf: ConfigRef; r: CmdReport): string
• cli_reporter: reportBody(conf: ConfigRef; r: DebugReport): string
• cli_reporter: reportBody(conf: ConfigRef; r: ExternalReport): string
• cli_reporter: reportBody(conf: ConfigRef; r: InternalReport): string
• cli_reporter: reportBody(conf: ConfigRef; r: LexerReport): string
• cli_reporter: reportBody(conf: ConfigRef; r: ParserReport): string
• cli_reporter: reportBody(conf: ConfigRef; r: Report): string
• cli_reporter: reportBody(conf: ConfigRef; r: SemReport): string
• cli_reporter: reportBody(conf: ConfigRef; r: VMReport): string

ReportCategory:

• report_enums: ReportCategory

ReportContext:

• reports_base_sem: ReportContext

ReportContextKind:

• reports_base_sem: ReportContextKind

reportEmpty:

• reports: reportEmpty

reportFrom:

• reports: reportFrom(report: Report): ReportLineInfo

reportFrom=:

• reports: reportFrom=(report: var Report; loc: ReportLineInfo)

reportFull:

• cli_reporter: reportFull(conf: ConfigRef; r: BackendReport): string
• cli_reporter: reportFull(conf: ConfigRef; r: CmdReport): string
• cli_reporter: reportFull(conf: ConfigRef; r: DebugReport): string
• cli_reporter: reportFull(conf: ConfigRef; r: ExternalReport): string
• cli_reporter: reportFull(conf: ConfigRef; r: InternalReport): string
• cli_reporter: reportFull(conf: ConfigRef; r: LexerReport): string
• cli_reporter: reportFull(conf: ConfigRef; r: ParserReport): string
• cli_reporter: reportFull(conf: ConfigRef; r: Report): string
• cli_reporter: reportFull(conf: ConfigRef; r: SemReport): string
• cli_reporter: reportFull(conf: ConfigRef; r: VMReport): string

reportHere:

• reports: reportHere[R: ReportTypes](report: R): R

reportHook:

• cli_reporter: reportHook(conf: ConfigRef; r: Report): TErrorHandling

ReportHook:

• options: ReportHook

reportHook:

• sexp_reporter: reportHook(conf: ConfigRef; r: Report): TErrorHandling

reportInst:

• reports: reportInst(report: Report): ReportLineInfo

ReportKind:

• report_enums: ReportKind

ReportKinds:

• report_enums: ReportKinds

ReportLineInfo:

• reports_base: ReportLineInfo

reportSem:

• reports_sem: reportSem(kind: ReportKind): SemReport

ReportSet:

• options: ReportSet

ReportSeverity:

• report_enums: ReportSeverity

reportShort:

• cli_reporter: reportShort(conf: ConfigRef; r: BackendReport): string
• cli_reporter: reportShort(conf: ConfigRef; r: CmdReport): string
• cli_reporter: reportShort(conf: ConfigRef; r: DebugReport): string
• cli_reporter: reportShort(conf: ConfigRef; r: ExternalReport): string
• cli_reporter: reportShort(conf: ConfigRef; r: InternalReport): string
• cli_reporter: reportShort(conf: ConfigRef; r: LexerReport): string
• cli_reporter: reportShort(conf: ConfigRef; r: ParserReport): string
• cli_reporter: reportShort(conf: ConfigRef; r: Report): string
• cli_reporter: reportShort(conf: ConfigRef; r: SemReport): string
• cli_reporter: reportShort(conf: ConfigRef; r: VMReport): string

reportStr:

• reports_sem: reportStr(kind: ReportKind; str: string; ast: PNode = nil; typ: PType = nil; sym: PSym = nil): SemReport

reportSym:

• reports_sem: reportSym(kind: ReportKind; sym: PSym; ast: PNode = nil; str: string = ""; typ: PType = nil): SemReport

reportSymbols:

• reports_sem: reportSymbols(kind: ReportKind; symbols: seq[PSym]; typ: PType = nil; ast: PNode = nil): SemReport

reportTyp:

• reports_sem: reportTyp(kind: ReportKind; typ: PType; ast: PNode = nil; sym: PSym = nil; str: string = ""): SemReport

ReportTypes:

• reports: ReportTypes

ReportWritabilityKind:

• options: ReportWritabilityKind

repParser:

• ReportCategory.repParser

repParserKinds:

• report_enums: repParserKinds

repPerformanceHints:

• report_enums: repPerformanceHints

repSem:

• ReportCategory.repSem

repSemKinds:

• report_enums: repSemKinds

repStrictNotNilWarnings:

• report_enums: repStrictNotNilWarnings

repTraceKinds:

• report_enums: repTraceKinds

repVM:

• ReportCategory.repVM

repVMKinds:

• report_enums: repVMKinds

repWarningGroups:

• report_enums: repWarningGroups

repWarningKinds:

• report_enums: repWarningKinds

requiredGenericParams:

• ast_query: requiredGenericParams(s: PSym): int

requiredParams:

• ast_query: requiredParams(s: PSym): int

requiresInit:

• typeallowed: requiresInit(t: PType): bool

resetAllModules:

• modulegraphs: resetAllModules(g: ModuleGraph)

resetBranch:

• vmobjects: resetBranch(mm: var VmMemoryManager; h: LocHandle; idx: FieldIndex; branch: int)

resetCompilationLists:

• extccomp: resetCompilationLists(conf: ConfigRef)

resetForBackend:

• modulegraphs: resetForBackend(g: ModuleGraph)

resetIdentCache:

• idents: resetIdentCache()

resetIdTable:

• ast: resetIdTable(x: var TIdTable)

resetLocation:

• vmobjects: resetLocation(mm: var VmMemoryManager; loc: var VmMemoryRegion; typ: PVmType)

resetNimScriptSymbols:

• magicsys: resetNimScriptSymbols(g: ModuleGraph)

resetSystemArtifacts:

• modules: resetSystemArtifacts(g: ModuleGraph)

resetSysTypes:

• magicsys: resetSysTypes(g: ModuleGraph)

resultId:

• mirbodies: resultId

resultPos:

• ast_query: resultPos

ResumeLabel:

• ccgflow: ResumeLabel

retType:

• mirtypes: retType(desc: TypeHeader; env: TypeEnv): TypeId

rewind:

• datatables: rewind(t: var DataTable; p: Checkpoint)
• mirenv: rewind(env: var MirEnv; to: EnvCheckpoint)
• containers: rewind(s: var Store; p: Checkpoint)

rextCmdRequiresFile:

• ReportKind.rextCmdRequiresFile

rextConf:

• ReportKind.rextConf

rextErrorKinds:

• report_enums: rextErrorKinds

rextHintKinds:

• report_enums: rextHintKinds

rextPath:

• ReportKind.rextPath

rintAssert:

• ReportKind.rintAssert

rintCannotOpenFile:

• ReportKind.rintCannotOpenFile

rintDataPassKinds:

• report_enums: rintDataPassKinds

rintEchoMessage:

• ReportKind.rintEchoMessage

rintErrKind:

• ReportKind.rintErrKind

rintErrorKinds:

• report_enums: rintErrorKinds

rintFatalKinds:

• report_enums: rintFatalKinds

rintHintKinds:

• report_enums: rintHintKinds

rintListHints:

• ReportKind.rintListHints

rintListWarnings:

• ReportKind.rintListWarnings

rintMissingStackTrace:

• ReportKind.rintMissingStackTrace

rintMsgOrigin:

• ReportKind.rintMsgOrigin

rintNotImplemented:

• ReportKind.rintNotImplemented

rintNotUsingNimcore:

• ReportKind.rintNotUsingNimcore

rintQuitCalled:

• ReportKind.rintQuitCalled

rintSource:

• ReportKind.rintSource

rintStackTrace:

• ReportKind.rintStackTrace

rintSuccessX:

• ReportKind.rintSuccessX

rintUnexpected:

• ReportKind.rintUnexpected

rintUnreachable:

• ReportKind.rintUnreachable

rintUsingLeanCompiler:

• ReportKind.rintUsingLeanCompiler

rintWarnCannotOpenFile:

• ReportKind.rintWarnCannotOpenFile

rintWarnFileChanged:

• ReportKind.rintWarnFileChanged

rintWarningKinds:

• report_enums: rintWarningKinds

rkAddress:

• TRegisterKind.rkAddress

rkFloat:

• TRegisterKind.rkFloat

rkHandle:

• TRegisterKind.rkHandle

rkInt:

• TRegisterKind.rkInt

rkLocation:

• TRegisterKind.rkLocation

rkNimNode:

• TRegisterKind.rkNimNode

rkNone:

• TRegisterKind.rkNone

rlexDeprecatedOctalPrefix:

• ReportKind.rlexDeprecatedOctalPrefix

rlexErrorKinds:

• report_enums: rlexErrorKinds

rlexExpectedHex:

• ReportKind.rlexExpectedHex

rlexHintKinds:

• report_enums: rlexHintKinds

rlexInvalidCharLiteral:

• ReportKind.rlexInvalidCharLiteral

rlexInvalidCharLiteralConstant:

• ReportKind.rlexInvalidCharLiteralConstant

rlexInvalidCharLiteralPlatformNewline:

• ReportKind.rlexInvalidCharLiteralPlatformNewline

rlexInvalidCharLiteralUnicodeCodepoint:

• ReportKind.rlexInvalidCharLiteralUnicodeCodepoint

rlexInvalidIntegerLiteral:

• ReportKind.rlexInvalidIntegerLiteral

rlexInvalidIntegerLiteralOctalPrefix:

• ReportKind.rlexInvalidIntegerLiteralOctalPrefix

rlexInvalidIntegerSuffix:

• ReportKind.rlexInvalidIntegerSuffix

rlexInvalidNumericLiteral:

• ReportKind.rlexInvalidNumericLiteral

rlexInvalidToken:

• ReportKind.rlexInvalidToken

rlexInvalidTokenSpaceBetweenNumAndIdent:

• ReportKind.rlexInvalidTokenSpaceBetweenNumAndIdent

rlexInvalidUnicodeCodepointEmpty:

• ReportKind.rlexInvalidUnicodeCodepointEmpty

rlexInvalidUnicodeCodepointGreaterThan0x10FFFF:

• ReportKind.rlexInvalidUnicodeCodepointGreaterThan0x10FFFF

rlexLineTooLong:

• ReportKind.rlexLineTooLong

rlexLinterReport:

• ReportKind.rlexLinterReport

rlexMalformedIdentUnderscores:

• ReportKind.rlexMalformedIdentUnderscores

rlexMalformedNumUnderscores:

• ReportKind.rlexMalformedNumUnderscores

rlexMalformedTrailingUnderscre:

• ReportKind.rlexMalformedTrailingUnderscre

rlexMissingClosingApostrophe:

• ReportKind.rlexMissingClosingApostrophe

rlexNoTabs:

• ReportKind.rlexNoTabs

rlexNumberNotInRange:

• ReportKind.rlexNumberNotInRange

rlexSourceCodeFilterOutput:

• ReportKind.rlexSourceCodeFilterOutput

rlexUnclosedComment:

• ReportKind.rlexUnclosedComment

rlexUnclosedSingleString:

• ReportKind.rlexUnclosedSingleString

rlexUnclosedTripleString:

• ReportKind.rlexUnclosedTripleString

rlexWarningKinds:

• report_enums: rlexWarningKinds

RodExt:

• options: RodExt

RodFile:

• rodfiles: RodFile

RodFileError:

• rodfiles: RodFileError

RodFileVersion:

• nversion: RodFileVersion

RodIter:

• ic: RodIter

RodSection:

• rodfiles: RodSection

rodViewer:

• ic: rodViewer(rodfile: AbsoluteFile; config: ConfigRef; cache: IdentCache)

Rope:

• ropes: Rope

rope:

• ropes: rope(f: BiggestFloat): Rope
• ropes: rope(i: BiggestInt): Rope
• ropes: rope(s: string): Rope

ropeConcat:

• ropes: ropeConcat(a: varargs[Rope]): Rope

routineDefs:

• ast_query: routineDefs

routineKinds:

• ast_types: routineKinds

RoutineSig:

• vmdef: RoutineSig

RoutineSigId:

• vmdef: RoutineSigId

rparAsmStmtExpectsStrLit:

• ReportKind.rparAsmStmtExpectsStrLit

rparConceptNotinType:

• ReportKind.rparConceptNotinType

rparEnablePreviewDotOps:

• ReportKind.rparEnablePreviewDotOps

rparErrorKinds:

• report_enums: rparErrorKinds

rparExprExpected:

• ReportKind.rparExprExpected

rparFuncNotAllowed:

• ReportKind.rparFuncNotAllowed

rparHintKinds:

• report_enums: rparHintKinds

rparIdentExpected:

• ReportKind.rparIdentExpected

rparIdentExpectedEmptyAccQuote:

• ReportKind.rparIdentExpectedEmptyAccQuote

rparInconsistentSpacing:

• ReportKind.rparInconsistentSpacing

rparInvalidFilter:

• ReportKind.rparInvalidFilter

rparInvalidIndentation:

• ReportKind.rparInvalidIndentation

rparInvalidIndentationWithForgotEqualSignHint:

• ReportKind.rparInvalidIndentationWithForgotEqualSignHint

rparMisplacedExport:

• ReportKind.rparMisplacedExport

rparMisplacedParameterVar:

• ReportKind.rparMisplacedParameterVar

rparMissingToken:

• ReportKind.rparMissingToken

rparNestableRequiresIndentation:

• ReportKind.rparNestableRequiresIndentation

rparPragmaBeforeGenericParameters:

• ReportKind.rparPragmaBeforeGenericParameters

rparPragmaNotFollowingTypeName:

• ReportKind.rparPragmaNotFollowingTypeName

rparTemplInvalidExpression:

• ReportKind.rparTemplInvalidExpression

rparTemplMissingEndClose:

• ReportKind.rparTemplMissingEndClose

rparTupleTypeWithPar:

• ReportKind.rparTupleTypeWithPar

rparUnexpectedToken:

• ReportKind.rparUnexpectedToken

rparWarningKinds:

• report_enums: rparWarningKinds

rsemAlignRequiresPowerOfTwo:

• ReportKind.rsemAlignRequiresPowerOfTwo

rsemAmbiguous:

• ReportKind.rsemAmbiguous

rsemAmbiguousCall:

• ReportKind.rsemAmbiguousCall

rsemAmbiguousGetAst:

• ReportKind.rsemAmbiguousGetAst

rsemAmbiguousIdent:

• ReportKind.rsemAmbiguousIdent

rsemAmbiguousIdentWithCandidates:

• ReportKind.rsemAmbiguousIdentWithCandidates

rsemAnyEnumConvert:

• ReportKind.rsemAnyEnumConvert

rsemArrayExpectsPositiveRange:

• ReportKind.rsemArrayExpectsPositiveRange

rsemBindDeprecated:

• ReportKind.rsemBindDeprecated

rsemBitsizeRequires1248:

• ReportKind.rsemBitsizeRequires1248

rsemBitsizeRequiresPositive:

• ReportKind.rsemBitsizeRequiresPositive

rsemBorrowOutlivesSource:

• ReportKind.rsemBorrowOutlivesSource

rsemBorrowPragmaNonDot:

• ReportKind.rsemBorrowPragmaNonDot

rsemBorrowTargetNotFound:

• ReportKind.rsemBorrowTargetNotFound

rsemCallconvExpected:

• ReportKind.rsemCallconvExpected

rsemCallIndirectTypeMismatch:

• ReportKind.rsemCallIndirectTypeMismatch

rsemCallingConventionMismatch:

• ReportKind.rsemCallingConventionMismatch

rsemCallNotAProcOrField:

• ReportKind.rsemCallNotAProcOrField

rsemCallTypeMismatch:

• ReportKind.rsemCallTypeMismatch

rsemCannotAssignTo:

• ReportKind.rsemCannotAssignTo

rsemCannotAssignToDiscriminantWithCustomDestructor:

• ReportKind.rsemCannotAssignToDiscriminantWithCustomDestructor

rsemCannotBeConvertedTo:

• ReportKind.rsemCannotBeConvertedTo

rsemCannotBeOfSubtype:

• ReportKind.rsemCannotBeOfSubtype

rsemCannotBeRaised:

• ReportKind.rsemCannotBeRaised

rsemCannotBorrow:

• ReportKind.rsemCannotBorrow

rsemCannotCastToNonConcrete:

• ReportKind.rsemCannotCastToNonConcrete

rsemCannotCastTypes:

• ReportKind.rsemCannotCastTypes

rsemCannotCodegenCompiletimeProc:

• ReportKind.rsemCannotCodegenCompiletimeProc

rsemCannotConvertToRange:

• ReportKind.rsemCannotConvertToRange

rsemCannotConvertTypes:

• ReportKind.rsemCannotConvertTypes

rsemCannotCreateFlowVarOfType:

• ReportKind.rsemCannotCreateFlowVarOfType

rsemCannotCreateImplicitOpenarray:

• ReportKind.rsemCannotCreateImplicitOpenarray

rsemCannotDeref:

• ReportKind.rsemCannotDeref

rsemCannotDetermineBorrowTarget:

• ReportKind.rsemCannotDetermineBorrowTarget

rsemCannotExceptNativeAndImported:

• ReportKind.rsemCannotExceptNativeAndImported

rsemCannotExport:

• ReportKind.rsemCannotExport

rsemCannotFindPlugin:

• ReportKind.rsemCannotFindPlugin

rsemCannotGenerateGenericDestructor:

• ReportKind.rsemCannotGenerateGenericDestructor

rsemCannotImportItself:

• ReportKind.rsemCannotImportItself

rsemCannotInferParameterType:

• ReportKind.rsemCannotInferParameterType

rsemCannotInferReturnType:

• ReportKind.rsemCannotInferReturnType

rsemCannotInferStaticValue:

• ReportKind.rsemCannotInferStaticValue

rsemCannotInferTypeOfLiteral:

• ReportKind.rsemCannotInferTypeOfLiteral

rsemCannotInferTypeOfParameter:

• ReportKind.rsemCannotInferTypeOfParameter

rsemCannotInstantiate:

• ReportKind.rsemCannotInstantiate

rsemCannotInstantiateForwarded:

• ReportKind.rsemCannotInstantiateForwarded

rsemCannotInstantiateWithParameter:

• ReportKind.rsemCannotInstantiateWithParameter

rsemCannotIsolate:

• ReportKind.rsemCannotIsolate

rsemCannotMakeSink:

• ReportKind.rsemCannotMakeSink

rsemCannotMixTypesAndValuesInTuple:

• ReportKind.rsemCannotMixTypesAndValuesInTuple

rsemCannotOpenFile:

• ReportKind.rsemCannotOpenFile

rsemCannotProveNotNil:

• ReportKind.rsemCannotProveNotNil

rsemCannotPushCast:

• ReportKind.rsemCannotPushCast

rsemCannotRaiseNonException:

• ReportKind.rsemCannotRaiseNonException

rsemCannotReraise:

• ReportKind.rsemCannotReraise

rsemCannotReturnTypeless:

• ReportKind.rsemCannotReturnTypeless

rsemCantComputeOffsetof:

• ReportKind.rsemCantComputeOffsetof

rsemCantConvertLiteralToRange:

• ReportKind.rsemCantConvertLiteralToRange

rsemCantConvertLiteralToType:

• ReportKind.rsemCantConvertLiteralToType

rsemCantPassProcvar:

• ReportKind.rsemCantPassProcvar

rsemCaseInUnion:

• ReportKind.rsemCaseInUnion

rsemCastRequiresStatement:

• ReportKind.rsemCastRequiresStatement

rsemClosureWithoutEnv:

• ReportKind.rsemClosureWithoutEnv

rsemCodegenDeclDeprecated:

• ReportKind.rsemCodegenDeclDeprecated

rsemCompilerOptionArgInvalid:

• ReportKind.rsemCompilerOptionArgInvalid

rsemCompilerOptionInvalid:

• ReportKind.rsemCompilerOptionInvalid

rsemCompilesHasSideEffects:

• ReportKind.rsemCompilesHasSideEffects

rsemCompilesReport:

• ReportKind.rsemCompilesReport

rsemConceptInferenceFailed:

• ReportKind.rsemConceptInferenceFailed

rsemConceptPredicateFailed:

• ReportKind.rsemConceptPredicateFailed

rsemConditionAlwaysFalse:

• ReportKind.rsemConditionAlwaysFalse

rsemConditionAlwaysTrue:

• ReportKind.rsemConditionAlwaysTrue

rsemConflictingDiscriminantInit:

• ReportKind.rsemConflictingDiscriminantInit

rsemConflictingDiscriminantValues:

• ReportKind.rsemConflictingDiscriminantValues

rsemConflictingExportnims:

• ReportKind.rsemConflictingExportnims

rsemConstantOfTypeHasNoValue:

• ReportKind.rsemConstantOfTypeHasNoValue

rsemConstExpressionExpected:

• ReportKind.rsemConstExpressionExpected

rsemConstExprExpected:

• ReportKind.rsemConstExprExpected

rsemContinueCannotHaveLabel:

• ReportKind.rsemContinueCannotHaveLabel

rsemContravariantUsedAsNonCovariant:

• ReportKind.rsemContravariantUsedAsNonCovariant

rsemConverterRequiresToplevel:

• ReportKind.rsemConverterRequiresToplevel

rsemConvFromXtoItselfNotNeeded:

• ReportKind.rsemConvFromXtoItselfNotNeeded

rsemConvToBaseNotNeeded:

• ReportKind.rsemConvToBaseNotNeeded

rsemCopiesToSink:

• ReportKind.rsemCopiesToSink

rsemCovariantUsedAsNonCovariant:

• ReportKind.rsemCovariantUsedAsNonCovariant

rsemCustomError:

• ReportKind.rsemCustomError

rsemCustomGlobalError:

• ReportKind.rsemCustomGlobalError

rsemCustomPrintMsgAndNodeError:

• ReportKind.rsemCustomPrintMsgAndNodeError

rsemCustomUserError:

• ReportKind.rsemCustomUserError

rsemCyclicDependency:

• ReportKind.rsemCyclicDependency

rsemCyclicTree:

• ReportKind.rsemCyclicTree

rsemDeclarationVisibilityMismatch:

• ReportKind.rsemDeclarationVisibilityMismatch

rsemDefaultParamIsIncompatible:

• ReportKind.rsemDefaultParamIsIncompatible

rsemDeprecated:

• ReportKind.rsemDeprecated

rsemDeprecatedCompilerOpt:

• ReportKind.rsemDeprecatedCompilerOpt

rsemDeprecatedCompilerOptArg:

• ReportKind.rsemDeprecatedCompilerOptArg

rsemDiagnostics:

• ReportKind.rsemDiagnostics

rsemDifferentTypeForReintroducedSymbol:

• ReportKind.rsemDifferentTypeForReintroducedSymbol

rsemDisallowedNilDeref:

• ReportKind.rsemDisallowedNilDeref

rsemDisallowedOfForPureObjects:

• ReportKind.rsemDisallowedOfForPureObjects

rsemDisallowedTypedescForTupleField:

• ReportKind.rsemDisallowedTypedescForTupleField

rsemDiscardingProc:

• ReportKind.rsemDiscardingProc

rsemDiscardingVoid:

• ReportKind.rsemDiscardingVoid

rsemDisjointFields:

• ReportKind.rsemDisjointFields

rsemDistinctDoesNotHaveDefaultValue:

• ReportKind.rsemDistinctDoesNotHaveDefaultValue

rsemDotForModuleImport:

• ReportKind.rsemDotForModuleImport

rsemDoubleCompletionOf:

• ReportKind.rsemDoubleCompletionOf

rsemDuplicateCaseLabel:

• ReportKind.rsemDuplicateCaseLabel

rsemDuplicateModuleImport:

• ReportKind.rsemDuplicateModuleImport

rsemDynlibRequiresExportc:

• ReportKind.rsemDynlibRequiresExportc

rsemEachIdentIsTuple:

• ReportKind.rsemEachIdentIsTuple

rsemEffectsListingHint:

• ReportKind.rsemEffectsListingHint

rsemEmptyAsm:

• ReportKind.rsemEmptyAsm

rsemEnableCallOperatorExperimental:

• ReportKind.rsemEnableCallOperatorExperimental

rsemEnableDotOperatorsExperimental:

• ReportKind.rsemEnableDotOperatorsExperimental

rsemEnableNotNilExperimental:

• ReportKind.rsemEnableNotNilExperimental

rsemErrGcUnsafe:

• ReportKind.rsemErrGcUnsafe

rsemErrGcUnsafeListing:

• ReportKind.rsemErrGcUnsafeListing

rsemErrorKinds:

• report_enums: rsemErrorKinds

rsemExceptionAlreadyHandled:

• ReportKind.rsemExceptionAlreadyHandled

rsemExcessiveCompilePragmaArgs:

• ReportKind.rsemExcessiveCompilePragmaArgs

rsemExpandMacro:

• ReportKind.rsemExpandMacro

rsemExpectedCallForGetAst:

• ReportKind.rsemExpectedCallForGetAst

rsemExpectedDestroyOrDeepCopyForOverride:

• ReportKind.rsemExpectedDestroyOrDeepCopyForOverride

rsemExpectedDistinctForBorrow:

• ReportKind.rsemExpectedDistinctForBorrow

rsemExpectedHighCappedDiscriminant:

• ReportKind.rsemExpectedHighCappedDiscriminant

rsemExpectedIdentifier:

• ReportKind.rsemExpectedIdentifier

rsemExpectedIdentifierInExpr:

• ReportKind.rsemExpectedIdentifierInExpr

rsemExpectedIdentifierQuoteLimit:

• ReportKind.rsemExpectedIdentifierQuoteLimit

rsemExpectedIdentifierWithExprContext:

• ReportKind.rsemExpectedIdentifierWithExprContext

rsemExpectedImportedType:

• ReportKind.rsemExpectedImportedType

rsemExpectedInvariantParam:

• ReportKind.rsemExpectedInvariantParam

rsemExpectedLabel:

• ReportKind.rsemExpectedLabel

rsemExpectedLow0Discriminant:

• ReportKind.rsemExpectedLow0Discriminant

rsemExpectedMacroOrTemplate:

• ReportKind.rsemExpectedMacroOrTemplate

rsemExpectedModuleNameForImportExcept:

• ReportKind.rsemExpectedModuleNameForImportExcept

rsemExpectedNimcallProc:

• ReportKind.rsemExpectedNimcallProc

rsemExpectedNonemptyPattern:

• ReportKind.rsemExpectedNonemptyPattern

rsemExpectedObjectForMethod:

• ReportKind.rsemExpectedObjectForMethod

rsemExpectedObjectForOf:

• ReportKind.rsemExpectedObjectForOf

rsemExpectedObjectForRegion:

• ReportKind.rsemExpectedObjectForRegion

rsemExpectedObjectType:

• ReportKind.rsemExpectedObjectType

rsemExpectedOneArgumentForConverter:

• ReportKind.rsemExpectedOneArgumentForConverter

rsemExpectedOrdinal:

• ReportKind.rsemExpectedOrdinal

rsemExpectedOrdinalOrFloat:

• ReportKind.rsemExpectedOrdinalOrFloat

rsemExpectedParameterForJsPattern:

• ReportKind.rsemExpectedParameterForJsPattern

rsemExpectedRange:

• ReportKind.rsemExpectedRange

rsemExpectedReturnTypeForConverter:

• ReportKind.rsemExpectedReturnTypeForConverter

rsemExpectedReturnTypeForIterator:

• ReportKind.rsemExpectedReturnTypeForIterator

rsemExpectedSingleFinally:

• ReportKind.rsemExpectedSingleFinally

rsemExpectedSingleGeneralExcept:

• ReportKind.rsemExpectedSingleGeneralExcept

rsemExpectedTemplateWithNArgs:

• ReportKind.rsemExpectedTemplateWithNArgs

rsemExpectedTypeOrValue:

• ReportKind.rsemExpectedTypeOrValue

rsemExpectedUnholyEnum:

• ReportKind.rsemExpectedUnholyEnum

rsemExpectedValueForYield:

• ReportKind.rsemExpectedValueForYield

rsemExpectNonFinalForBase:

• ReportKind.rsemExpectNonFinalForBase

rsemExpectObjectForBase:

• ReportKind.rsemExpectObjectForBase

rsemExperimentalRequiresToplevel:

• ReportKind.rsemExperimentalRequiresToplevel

rsemExportRequiresToplevel:

• ReportKind.rsemExportRequiresToplevel

rsemExprAlwaysX:

• ReportKind.rsemExprAlwaysX

rsemExpressionCannotBeCalled:

• ReportKind.rsemExpressionCannotBeCalled

rsemExpressionHasNoType:

• ReportKind.rsemExpressionHasNoType

rsemExpressionIsNotAPath:

• ReportKind.rsemExpressionIsNotAPath

rsemExprHasNoAddress:

• ReportKind.rsemExprHasNoAddress

rsemExtendedContext:

• ReportKind.rsemExtendedContext

rsemExternalLocalNotAllowed:

• ReportKind.rsemExternalLocalNotAllowed

rsemFatalError:

• ReportKind.rsemFatalError

rsemFieldAssignmentInvalid:

• ReportKind.rsemFieldAssignmentInvalid

rsemFieldAssignmentInvalidNeedSpace:

• ReportKind.rsemFieldAssignmentInvalidNeedSpace

rsemFieldInitTwice:

• ReportKind.rsemFieldInitTwice

rsemFieldNotAccessible:

• ReportKind.rsemFieldNotAccessible

rsemFieldsIteratorCannotContinue:

• ReportKind.rsemFieldsIteratorCannotContinue

rsemForExpectsIterator:

• ReportKind.rsemForExpectsIterator

rsemGenericInstantiationTooNested:

• ReportKind.rsemGenericInstantiationTooNested

rsemGenericLambdaNowAllowed:

• ReportKind.rsemGenericLambdaNowAllowed

rsemGenericMethodsDeprecated:

• ReportKind.rsemGenericMethodsDeprecated

rsemGenericTypeExpected:

• ReportKind.rsemGenericTypeExpected

rsemGlobalVar:

• ReportKind.rsemGlobalVar

rsemHasSideEffects:

• ReportKind.rsemHasSideEffects

rsemHintKinds:

• report_enums: rsemHintKinds

rsemHintLibDependency:

• ReportKind.rsemHintLibDependency

rsemHoleEnumConvert:

• ReportKind.rsemHoleEnumConvert

rsemHookCannotRaise:

• ReportKind.rsemHookCannotRaise

rsemIgnoreInvalidForLoop:

• ReportKind.rsemIgnoreInvalidForLoop

rsemIllegalCallconvCapture:

• ReportKind.rsemIllegalCallconvCapture

rsemIllegalCompileTime:

• ReportKind.rsemIllegalCompileTime

rsemIllegalCompileTimeAccess:

• ReportKind.rsemIllegalCompileTimeAccess

rsemIllegalCompTimeCapture:

• ReportKind.rsemIllegalCompTimeCapture

rsemIllegalConversion:

• ReportKind.rsemIllegalConversion

rsemIllegalCustomPragma:

• ReportKind.rsemIllegalCustomPragma

rsemIllegalMemoryCapture:

• ReportKind.rsemIllegalMemoryCapture

rsemIllegalNimvmContext:

• ReportKind.rsemIllegalNimvmContext

rsemIllegalRecursion:

• ReportKind.rsemIllegalRecursion

rsemIllformedAst:

• ReportKind.rsemIllformedAst

rsemImmutableBorrowMutation:

• ReportKind.rsemImmutableBorrowMutation

rsemImplementationExpected:

• ReportKind.rsemImplementationExpected

rsemImplementationNotAllowed:

• ReportKind.rsemImplementationNotAllowed

rsemImplicitAddrIsNotFirstParam:

• ReportKind.rsemImplicitAddrIsNotFirstParam

rsemImplicitCstringConvert:

• ReportKind.rsemImplicitCstringConvert

rsemImplicitObjConv:

• ReportKind.rsemImplicitObjConv

rsemImplicitPragmaError:

• ReportKind.rsemImplicitPragmaError

rsemImportjsRequiresJs:

• ReportKind.rsemImportjsRequiresJs

rsemImportRequiresToplevel:

• ReportKind.rsemImportRequiresToplevel

rsemIncompatibleDefaultExpr:

• ReportKind.rsemIncompatibleDefaultExpr

rsemIncorrectResultProcSymbol:

• ReportKind.rsemIncorrectResultProcSymbol

rsemIndexOutOfBounds:

• ReportKind.rsemIndexOutOfBounds

rsemInheritFromException:

• ReportKind.rsemInheritFromException

rsemInitHereNotAllowed:

• ReportKind.rsemInitHereNotAllowed

rsemInseparableTypeBoundOp:

• ReportKind.rsemInseparableTypeBoundOp

rsemIntLiteralExpected:

• ReportKind.rsemIntLiteralExpected

rsemInvalidArgumentFor:

• ReportKind.rsemInvalidArgumentFor

rsemInvalidBindContext:

• ReportKind.rsemInvalidBindContext

rsemInvalidBooldefine:

• ReportKind.rsemInvalidBooldefine

rsemInvalidControlFlow:

• ReportKind.rsemInvalidControlFlow

rsemInvalidExpression:

• ReportKind.rsemInvalidExpression

rsemInvalidExtern:

• ReportKind.rsemInvalidExtern

rsemInvalidGuardField:

• ReportKind.rsemInvalidGuardField

rsemInvalidIntdefine:

• ReportKind.rsemInvalidIntdefine

rsemInvalidMethodDeclarationOrder:

• ReportKind.rsemInvalidMethodDeclarationOrder

rsemInvalidModuleName:

• ReportKind.rsemInvalidModuleName

rsemInvalidModulePath:

• ReportKind.rsemInvalidModulePath

rsemInvalidNestedLocking:

• ReportKind.rsemInvalidNestedLocking

rsemInvalidOrderInArrayConstructor:

• ReportKind.rsemInvalidOrderInArrayConstructor

rsemInvalidOrderInEnum:

• ReportKind.rsemInvalidOrderInEnum

rsemInvalidPragma:

• ReportKind.rsemInvalidPragma

rsemInvalidPragmaBlock:

• ReportKind.rsemInvalidPragmaBlock

rsemInvalidTupleConstructor:

• ReportKind.rsemInvalidTupleConstructor

rsemInvalidTupleSubscript:

• ReportKind.rsemInvalidTupleSubscript

rsemInvalidVisibility:

• ReportKind.rsemInvalidVisibility

rsemIsOperatorTakes2Args:

• ReportKind.rsemIsOperatorTakes2Args

rsemLetNeedsInit:

• ReportKind.rsemLetNeedsInit

rsemLinePragmaExpectsTuple:

• ReportKind.rsemLinePragmaExpectsTuple

rsemLinterReport:

• ReportKind.rsemLinterReport

rsemLinterReportUse:

• ReportKind.rsemLinterReportUse

rsemLocalEscapesStackFrame:

• ReportKind.rsemLocalEscapesStackFrame

rsemLockLevelMismatch:

• ReportKind.rsemLockLevelMismatch

rsemLocksPragmaBadLevel:

• ReportKind.rsemLocksPragmaBadLevel

rsemLocksPragmaExpectsList:

• ReportKind.rsemLocksPragmaExpectsList

rsemLocksRequiresArgs:

• ReportKind.rsemLocksRequiresArgs

rsemMacroBodyDependsOnGenericTypes:

• ReportKind.rsemMacroBodyDependsOnGenericTypes

rsemMacroInstantiationTooNested:

• ReportKind.rsemMacroInstantiationTooNested

rsemMalformedNotNilType:

• ReportKind.rsemMalformedNotNilType

rsemMethodLockMismatch:

• ReportKind.rsemMethodLockMismatch

rsemMethodRequiresToplevel:

• ReportKind.rsemMethodRequiresToplevel

rsemMismatchedPopPush:

• ReportKind.rsemMismatchedPopPush

rsemMisplacedDeprecation:

• ReportKind.rsemMisplacedDeprecation

rsemMisplacedEffectsOf:

• ReportKind.rsemMisplacedEffectsOf

rsemMisplacedMagicType:

• ReportKind.rsemMisplacedMagicType

rsemMisplacedRunnableExample:

• ReportKind.rsemMisplacedRunnableExample

rsemMissingCaseBranches:

• ReportKind.rsemMissingCaseBranches

rsemMissingGenericParamsForTemplate:

• ReportKind.rsemMissingGenericParamsForTemplate

rsemMissingMethodDispatcher:

• ReportKind.rsemMissingMethodDispatcher

rsemMissingPragmaArg:

• ReportKind.rsemMissingPragmaArg

rsemModuleAliasMustBeIdentifier:

• ReportKind.rsemModuleAliasMustBeIdentifier

rsemMultilockRequiresSameLevel:

• ReportKind.rsemMultilockRequiresSameLevel

rsemNamedExprExpected:

• ReportKind.rsemNamedExprExpected

rsemNamedExprNotAllowed:

• ReportKind.rsemNamedExprNotAllowed

rsemNodeNotAllowed:

• ReportKind.rsemNodeNotAllowed

rsemNoGenericParamsAllowed:

• ReportKind.rsemNoGenericParamsAllowed

rsemNoMagicEqualsForType:

• ReportKind.rsemNoMagicEqualsForType

rsemNonInvariantCannotBeUsedWith:

• ReportKind.rsemNonInvariantCannotBeUsedWith

rsemNonInvariantCnnnotBeUsedInConcepts:

• ReportKind.rsemNonInvariantCnnnotBeUsedInConcepts

rsemNonMatchingCandidates:

• ReportKind.rsemNonMatchingCandidates

rsemNoObjectOrTupleType:

• ReportKind.rsemNoObjectOrTupleType

rsemNoReturnHasReturn:

• ReportKind.rsemNoReturnHasReturn

rsemNoReturnTypeDeclared:

• ReportKind.rsemNoReturnTypeDeclared

rsemNotABaseMethod:

• ReportKind.rsemNotABaseMethod

rsemNoTupleTypeForConstructor:

• ReportKind.rsemNoTupleTypeForConstructor

rsemNoUnionForJs:

• ReportKind.rsemNoUnionForJs

rsemObjectDoesNotHaveDefaultValue:

• ReportKind.rsemObjectDoesNotHaveDefaultValue

rsemObjectRequiresFieldInit:

• ReportKind.rsemObjectRequiresFieldInit

rsemObjectRequiresFieldInitNoDefault:

• ReportKind.rsemObjectRequiresFieldInitNoDefault

rsemObservableStores:

• ReportKind.rsemObservableStores

rsemOffsetInUnion:

• ReportKind.rsemOffsetInUnion

rsemOldDoesNotBelongTo:

• ReportKind.rsemOldDoesNotBelongTo

rsemOldTakesParameterName:

• ReportKind.rsemOldTakesParameterName

rsemOnlyDeclaredIdentifierFoundIsError:

• ReportKind.rsemOnlyDeclaredIdentifierFoundIsError

rsemOnOrOffExpected:

• ReportKind.rsemOnOrOffExpected

rsemOverrideLockMismatch:

• ReportKind.rsemOverrideLockMismatch

rsemOverrideSafetyMismatch:

• ReportKind.rsemOverrideSafetyMismatch

rsemOwnedTypeDeprecated:

• ReportKind.rsemOwnedTypeDeprecated

rsemPackageRequiresToplevel:

• ReportKind.rsemPackageRequiresToplevel

rsemParallelFieldsDisallowsCase:

• ReportKind.rsemParallelFieldsDisallowsCase

rsemParameterNotPointerToPartial:

• ReportKind.rsemParameterNotPointerToPartial

rsemParameterRedefinition:

• ReportKind.rsemParameterRedefinition

rsemParameterRequiresAType:

• ReportKind.rsemParameterRequiresAType

rsemPattern:

• ReportKind.rsemPattern

rsemPragmaDisallowedForTupleUnpacking:

• ReportKind.rsemPragmaDisallowedForTupleUnpacking

rsemPragmaDynlibRequiresExportc:

• ReportKind.rsemPragmaDynlibRequiresExportc

rsemPragmaOptionExpected:

• ReportKind.rsemPragmaOptionExpected

rsemPragmaRecursiveDependency:

• ReportKind.rsemPragmaRecursiveDependency

rsemProcessing:

• ReportKind.rsemProcessing

rsemProcessingStmt:

• ReportKind.rsemProcessingStmt

rsemProcHasNoConcreteType:

• ReportKind.rsemProcHasNoConcreteType

rsemProcIsNotAConcreteType:

• ReportKind.rsemProcIsNotAConcreteType

rsemPropositionExpected:

• ReportKind.rsemPropositionExpected

rsemProvablyNil:

• ReportKind.rsemProvablyNil

rsemProveField:

• ReportKind.rsemProveField

rsemProveInit:

• ReportKind.rsemProveInit

rsemPtrRegionIsDeprecated:

• ReportKind.rsemPtrRegionIsDeprecated

rsemQuantifierInRangeExpected:

• ReportKind.rsemQuantifierInRangeExpected

rsemRaisesPragmaExpectsObject:

• ReportKind.rsemRaisesPragmaExpectsObject

rsemRangeDoesNotSupportNan:

• ReportKind.rsemRangeDoesNotSupportNan

rsemRangeIsEmpty:

• ReportKind.rsemRangeIsEmpty

rsemRangeRequiresDotDot:

• ReportKind.rsemRangeRequiresDotDot

rsemRawTypeMismatch:

• ReportKind.rsemRawTypeMismatch

rsemRebidingDeepCopy:

• ReportKind.rsemRebidingDeepCopy

rsemRebidingDestructor:

• ReportKind.rsemRebidingDestructor

rsemRebidingImplicitDestructor:

• ReportKind.rsemRebidingImplicitDestructor

rsemRecursiveDependencyIterator:

• ReportKind.rsemRecursiveDependencyIterator

rsemRecursiveInclude:

• ReportKind.rsemRecursiveInclude

rsemRedefinitionOf:

• ReportKind.rsemRedefinitionOf

rsemReportBigOrdsEnergy:

• report_enums: rsemReportBigOrdsEnergy

rsemReportCountMismatch:

• report_enums: rsemReportCountMismatch

rsemReportListSym:

• report_enums: rsemReportListSym

rsemReportOneSym:

• report_enums: rsemReportOneSym

rsemReportTwoSym:

• report_enums: rsemReportTwoSym

rsemRequiresDeepCopyEnabled:

• ReportKind.rsemRequiresDeepCopyEnabled

rsemResultMustBorrowFirst:

• ReportKind.rsemResultMustBorrowFirst

rsemResultShadowed:

• ReportKind.rsemResultShadowed

rsemResultUsed:

• ReportKind.rsemResultUsed

rsemReturnNotAllowed:

• ReportKind.rsemReturnNotAllowed

rsemRttiRequestForIncompleteObject:

• ReportKind.rsemRttiRequestForIncompleteObject

rsemRuntimeDiscriminantInitCap:

• ReportKind.rsemRuntimeDiscriminantInitCap

rsemRuntimeDiscriminantMustBeImmutable:

• ReportKind.rsemRuntimeDiscriminantMustBeImmutable

rsemRuntimeDiscriminantRequiresElif:

• ReportKind.rsemRuntimeDiscriminantRequiresElif

rsemSelectorMustBeOfCertainTypes:

• ReportKind.rsemSelectorMustBeOfCertainTypes

rsemSemfoldDivByZero:

• ReportKind.rsemSemfoldDivByZero

rsemSemfoldOverflow:

• ReportKind.rsemSemfoldOverflow

rsemSetTooBig:

• ReportKind.rsemSetTooBig

rsemSinkIsNotATypeClass:

• ReportKind.rsemSinkIsNotATypeClass

rsemStackEscape:

• ReportKind.rsemStackEscape

rsemStaticFieldNotFound:

• ReportKind.rsemStaticFieldNotFound

rsemStaticIndexGeProvable:

• ReportKind.rsemStaticIndexGeProvable

rsemStaticIndexLeqUnprovable:

• ReportKind.rsemStaticIndexLeqUnprovable

rsemStaticOutOfBounds:

• ReportKind.rsemStaticOutOfBounds

rsemStrictNotNilExpr:

• ReportKind.rsemStrictNotNilExpr

rsemStrictNotNilResult:

• ReportKind.rsemStrictNotNilResult

rsemStringLiteralExpected:

• ReportKind.rsemStringLiteralExpected

rsemStringOrIdentNodeExpected:

• ReportKind.rsemStringOrIdentNodeExpected

rsemStringRangeNotAllowed:

• ReportKind.rsemStringRangeNotAllowed

rsemSugNoSymbolAtPosition:

• ReportKind.rsemSugNoSymbolAtPosition

rsemSuspiciousEnumConv:

• ReportKind.rsemSuspiciousEnumConv

rsemSymbolKindMismatch:

• ReportKind.rsemSymbolKindMismatch

rsemSystemNeeds:

• ReportKind.rsemSystemNeeds

rsemTemplateInstantiationTooNested:

• ReportKind.rsemTemplateInstantiationTooNested

rsemThisPragmaRequires01Args:

• ReportKind.rsemThisPragmaRequires01Args

rsemThreadvarCannotInit:

• ReportKind.rsemThreadvarCannotInit

rsemTIsNotAConcreteType:

• ReportKind.rsemTIsNotAConcreteType

rsemTooNestedConcept:

• ReportKind.rsemTooNestedConcept

rsemTVoidNotAllowed:

• ReportKind.rsemTVoidNotAllowed

rsemTypeCannotBeForwarded:

• ReportKind.rsemTypeCannotBeForwarded

rsemTypeConversionArgumentMismatch:

• ReportKind.rsemTypeConversionArgumentMismatch

rsemTypedReturnDeprecated:

• ReportKind.rsemTypedReturnDeprecated

rsemTypeExpected:

• ReportKind.rsemTypeExpected

rsemTypeInvalid:

• ReportKind.rsemTypeInvalid

rsemTypeKindMismatch:

• ReportKind.rsemTypeKindMismatch

rsemTypelessParam:

• ReportKind.rsemTypelessParam

rsemTypeMismatch:

• ReportKind.rsemTypeMismatch

rsemTypeNotAllowed:

• ReportKind.rsemTypeNotAllowed

rsemUnavailableLocation:

• ReportKind.rsemUnavailableLocation

rsemUnavailableTypeBound:

• ReportKind.rsemUnavailableTypeBound

rsemUndeclaredField:

• ReportKind.rsemUndeclaredField

rsemUndeclaredIdentifier:

• ReportKind.rsemUndeclaredIdentifier

rsemUnexpectedArrayAssignForCstring:

• ReportKind.rsemUnexpectedArrayAssignForCstring

rsemUnexpectedAutoInForwardDeclaration:

• ReportKind.rsemUnexpectedAutoInForwardDeclaration

rsemUnexpectedClosureOnToplevelProc:

• ReportKind.rsemUnexpectedClosureOnToplevelProc

rsemUnexpectedEqInObjectConstructor:

• ReportKind.rsemUnexpectedEqInObjectConstructor

rsemUnexpectedExportcInAlias:

• ReportKind.rsemUnexpectedExportcInAlias

rsemUnexpectedInfixInInclude:

• ReportKind.rsemUnexpectedInfixInInclude

rsemUnexpectedInNewConcept:

• ReportKind.rsemUnexpectedInNewConcept

rsemUnexpectedPattern:

• ReportKind.rsemUnexpectedPattern

rsemUnexpectedPragma:

• ReportKind.rsemUnexpectedPragma

rsemUnexpectedPragmaInDefinitionOf:

• ReportKind.rsemUnexpectedPragmaInDefinitionOf

rsemUnexpectedPushArgument:

• ReportKind.rsemUnexpectedPushArgument

rsemUnexpectedToplevelDefer:

• ReportKind.rsemUnexpectedToplevelDefer

rsemUnexpectedTypeBoundOpSignature:

• ReportKind.rsemUnexpectedTypeBoundOpSignature

rsemUnexpectedVoidType:

• ReportKind.rsemUnexpectedVoidType

rsemUnexpectedYield:

• ReportKind.rsemUnexpectedYield

rsemUnguardedAccess:

• ReportKind.rsemUnguardedAccess

rsemUninit:

• ReportKind.rsemUninit

rsemUnknownExperimental:

• ReportKind.rsemUnknownExperimental

rsemUnknownHint:

• ReportKind.rsemUnknownHint

rsemUnknownIdentifier:

• ReportKind.rsemUnknownIdentifier

rsemUnknownMagic:

• ReportKind.rsemUnknownMagic

rsemUnknownPackageName:

• ReportKind.rsemUnknownPackageName

rsemUnknownTrait:

• ReportKind.rsemUnknownTrait

rsemUnknownWarning:

• ReportKind.rsemUnknownWarning

rsemUnlistedEffects:

• ReportKind.rsemUnlistedEffects

rsemUnlistedRaises:

• ReportKind.rsemUnlistedRaises

rsemUnreachableCode:

• ReportKind.rsemUnreachableCode

rsemUnreachableElse:

• ReportKind.rsemUnreachableElse

rsemUnsafeDefault:

• ReportKind.rsemUnsafeDefault

rsemUnsafeRuntimeDiscriminantInit:

• ReportKind.rsemUnsafeRuntimeDiscriminantInit

rsemUnsafeSetLen:

• ReportKind.rsemUnsafeSetLen

rsemUntypedParamsFollwedByMoreSpecificType:

• ReportKind.rsemUntypedParamsFollwedByMoreSpecificType

rsemUnusedImport:

• ReportKind.rsemUnusedImport

rsemUsageIsError:

• ReportKind.rsemUsageIsError

rsemUseBase:

• ReportKind.rsemUseBase

rsemUseOfGc:

• ReportKind.rsemUseOfGc

rsemUseOrDiscard:

• ReportKind.rsemUseOrDiscard

rsemUseOrDiscardExpr:

• ReportKind.rsemUseOrDiscardExpr

rsemUserError:

• ReportKind.rsemUserError

rsemUserHint:

• ReportKind.rsemUserHint

rsemUserWarning:

• ReportKind.rsemUserWarning

rsemUsingDisallowsAssign:

• ReportKind.rsemUsingDisallowsAssign

rsemUsingRequiresToplevel:

• ReportKind.rsemUsingRequiresToplevel

rsemUsingRequiresType:

• ReportKind.rsemUsingRequiresType

rsemVarForOutParamNeeded:

• ReportKind.rsemVarForOutParamNeeded

rsemVarVarNotAllowed:

• ReportKind.rsemVarVarNotAllowed

rsemWarnGcUnsafe:

• ReportKind.rsemWarnGcUnsafe

rsemWarnGcUnsafeListing:

• ReportKind.rsemWarnGcUnsafeListing

rsemWarningKinds:

• report_enums: rsemWarningKinds

rsemWarnUnlistedRaises:

• ReportKind.rsemWarnUnlistedRaises

rsemWrappedError:

• ReportKind.rsemWrappedError

rsemWrongIdent:

• ReportKind.rsemWrongIdent

rsemWrongNumberOfArguments:

• ReportKind.rsemWrongNumberOfArguments

rsemWrongNumberOfGenericParams:

• ReportKind.rsemWrongNumberOfGenericParams

rsemWrongNumberOfQuoteArguments:

• ReportKind.rsemWrongNumberOfQuoteArguments

rsemWrongNumberOfVariables:

• ReportKind.rsemWrongNumberOfVariables

rsemXCannotRaiseY:

• ReportKind.rsemXCannotRaiseY

rsemXDeclaredButNotUsed:

• ReportKind.rsemXDeclaredButNotUsed

rsemYieldExpectedTupleConstr:

• ReportKind.rsemYieldExpectedTupleConstr

rsevDebug:

• ReportSeverity.rsevDebug

rsevError:

• ReportSeverity.rsevError

rsevFatal:

• ReportSeverity.rsevFatal

rsevHint:

• ReportSeverity.rsevHint

rsevTrace:

• ReportSeverity.rsevTrace

rsevWarning:

• ReportSeverity.rsevWarning

rstWarnings:

• report_enums: rstWarnings

runJsonBuildInstructions:

• extccomp: runJsonBuildInstructions(conf: ConfigRef; jsonFile: AbsoluteFile)

runNimScript:

• scripting: runNimScript(cache: IdentCache; scriptName: AbsoluteFile; freshDefines = true; conf: ConfigRef; stream: PLLStream)

runtimeFormat:

• ropes: runtimeFormat(frmt: FormatStr; args: openArray[Rope]): Rope

Rvalue:

• ExprKind.Rvalue

RvalueExprKinds:

• mirtrees: RvalueExprKinds

rvmAccessNoLocation:

• ReportKind.rvmAccessNoLocation

rvmAccessOutOfBounds:

• ReportKind.rvmAccessOutOfBounds

rvmAccessTypeMismatch:

• ReportKind.rvmAccessTypeMismatch

rvmCacheKeyAlreadyExists:

• ReportKind.rvmCacheKeyAlreadyExists

rvmCannotAddChild:

• ReportKind.rvmCannotAddChild

rvmCannotCallMethod:

• ReportKind.rvmCannotCallMethod

rvmCannotCast:

• ReportKind.rvmCannotCast

rvmCannotCreateNode:

• ReportKind.rvmCannotCreateNode

rvmCannotEvaluateAtComptime:

• ReportKind.rvmCannotEvaluateAtComptime

rvmCannotGenerateCode:

• ReportKind.rvmCannotGenerateCode

rvmCannotGetChild:

• ReportKind.rvmCannotGetChild

rvmCannotImportc:

• ReportKind.rvmCannotImportc

rvmCannotModifyTypechecked:

• ReportKind.rvmCannotModifyTypechecked

rvmCannotSetChild:

• ReportKind.rvmCannotSetChild

rvmDivisionByConstZero:

• ReportKind.rvmDivisionByConstZero

rvmErrInternal:

• ReportKind.rvmErrInternal

rvmErrorKinds:

• report_enums: rvmErrorKinds

rvmFieldInavailable:

• ReportKind.rvmFieldInavailable

rvmFieldNotFound:

• ReportKind.rvmFieldNotFound

rvmHintKinds:

• report_enums: rvmHintKinds

rvmIllegalConv:

• ReportKind.rvmIllegalConv

rvmIllegalConvFromXToY:

• ReportKind.rvmIllegalConvFromXToY

rvmIndexError:

• ReportKind.rvmIndexError

rvmMissingCacheKey:

• ReportKind.rvmMissingCacheKey

rvmMissingImportcCompleteStruct:

• ReportKind.rvmMissingImportcCompleteStruct

rvmNilAccess:

• ReportKind.rvmNilAccess

rvmNodeNotAProcSymbol:

• ReportKind.rvmNodeNotAProcSymbol

rvmNodeNotASymbol:

• ReportKind.rvmNodeNotASymbol

rvmNotAField:

• ReportKind.rvmNotAField

rvmNotUnused:

• ReportKind.rvmNotUnused

rvmNoType:

• ReportKind.rvmNoType

rvmOpcParseExpectedExpression:

• ReportKind.rvmOpcParseExpectedExpression

rvmOutOfRange:

• ReportKind.rvmOutOfRange

rvmOverOrUnderflow:

• ReportKind.rvmOverOrUnderflow

rvmQuit:

• ReportKind.rvmQuit

rvmStackTrace:

• ReportKind.rvmStackTrace

rvmTooLargetOffset:

• ReportKind.rvmTooLargetOffset

rvmTooManyIterations:

• ReportKind.rvmTooManyIterations

rvmTooManyRegistersRequired:

• ReportKind.rvmTooManyRegistersRequired

rvmTraceKinds:

• report_enums: rvmTraceKinds

rvmUnhandledException:

• ReportKind.rvmUnhandledException

rvmUnsupportedNonNil:

• ReportKind.rvmUnsupportedNonNil

rvmUserError:

• ReportKind.rvmUserError

rvmWarningKinds:

• report_enums: rvmWarningKinds

s:

• cgendata: s(p: BProc; s: TCProcSection): var Rope

Safe:

• Nilability.Safe

safeCopyMem:

• vmdef: safeCopyMem(dest: var openArray[byte | char]; src: openArray[byte | char]; numBytes: Natural)

safeCopyMemSrc:

• vmdef: safeCopyMemSrc(dest: var openArray[byte]; src: openArray[byte])

safeInheritanceDiff:

• types: safeInheritanceDiff(a, b: PType): int

safeLen:

• ast_parsed_types: safeLen(node: ParsedNode): int
• ast_query: safeLen(n: PNode): int

safeSemExpr:

• suggest: safeSemExpr(c: PContext; n: PNode): PNode

safeSkipTypes:

• types: safeSkipTypes(t: PType; kinds: TTypeKinds): PType

safeZeroMem:

• vmdef: safeZeroMem(dest: var openArray[byte]; numBytes: Natural)

sameBackendType:

• types: sameBackendType(x, y: PType): bool

sameDistinctTypes:

• types: sameDistinctTypes(a, b: PType): bool

sameEnumTypes:

• types: sameEnumTypes(a, b: PType): bool

sameFlags:

• types: sameFlags(a, b: PType): bool

sameIndex:

• aliasanalysis: sameIndex(a, b: MirNode): Ternary

sameLocationType:

• types: sameLocationType(x, y: PType): bool

sameObjectTypes:

• types: sameObjectTypes(a, b: PType): bool

sameSubexprs:

• guards: sameSubexprs(m: TModel; a, b: PNode): bool

sameTree:

• guards: sameTree(a, b: PNode): bool

sameTrees:

• patterns: sameTrees(a, b: PNode): bool

sameType:

• types: sameType(a, b: PType; flags: TTypeCmpFlags = {}): bool

sameTypeOrNil:

• types: sameTypeOrNil(a, b: PType; flags: TTypeCmpFlags = {}): bool

sameValue:

• astalgo: sameValue(a, b: PNode): bool

saveRodFile:

• ic: saveRodFile(filename: AbsoluteFile; encoder: var PackedEncoder; m: var PackedModule)

sckInstantiationFrom:

• ReportContextKind.sckInstantiationFrom

sckInstantiationOf:

• ReportContextKind.sckInstantiationOf

scope:

• mirconstr: scope(bu: var MirBuilder; body: untyped)

scopeDepth:

• semdata: scopeDepth(c: PContext): int

searchForCompilerproc:

• ic: searchForCompilerproc(m: LoadedModule; name: string): int32

searchForProc:

• procfind: searchForProc(c: PContext; scope: PScope; fn: PSym): tuple[proto: PSym, comesFromShadowScope: bool]

searchInScopes:

• lookups: searchInScopes(c: PContext; s: PIdent; ambiguous: var bool): PSym

searchInScopesFilterBy:

• lookups: searchInScopesFilterBy(c: PContext; s: PIdent; filter: TSymKinds): seq[PSym]

searchPaths:

• options: searchPaths(conf`gensym58: ConfigRef): seq[AbsoluteDir]

searchPaths=:

• options: searchPaths=(conf`gensym58: ConfigRef; val`gensym58: seq[AbsoluteDir])

searchPathsAdd:

• options: searchPathsAdd(conf`gensym57: ConfigRef; item`gensym57: AbsoluteDir | seq[AbsoluteDir])

searchTypeFor:

• types: searchTypeFor(t: PType; predicate: TTypePredicate): bool

searchTypeNodeFor:

• types: searchTypeNodeFor(n: PNode; predicate: TTypePredicate): bool

selectedGC:

• options: selectedGC(conf`gensym30: ConfigRef): TGCMode

selectedGC=:

• options: selectedGC=(conf`gensym30: ConfigRef; val`gensym30: TGCMode)

selectWhenBranch:

• proto_mir: selectWhenBranch(n: PNode; isNimvm: bool): PNode

semAsmOrEmit:

• pragmas: semAsmOrEmit(con: PContext; n: PNode; marker: char): PNode

SemCallMismatch:

• ast_types: SemCallMismatch

SemDiagnostics:

• ast_types: SemDiagnostics

semDiagTypeMismatch:

• types: semDiagTypeMismatch(node: PNode; expected: set[TTypeKind]; received: PType): PAstDiag

semFinishOperands:

• sigmatch: semFinishOperands(c: PContext; n: PNode)

SemGcUnsafetyKind:

• reports_sem: SemGcUnsafetyKind

SemishReportBase:

• reports_base_sem: SemishReportBase

semLocals:

• locals: semLocals(c: PContext; n: PNode): PNode

SemNilHistory:

• reports_sem: SemNilHistory

semNodeKindConstraints:

• parampatterns: semNodeKindConstraints(n: PNode; conf: ConfigRef; start: Natural): PNode

SemOrVMReportKind:

• report_enums: SemOrVMReportKind

semPass:

• sem: semPass

SemReport:

• reports_sem: SemReport

semReportCountMismatch:

• msgs: semReportCountMismatch(kind: ReportKind; expected, got: distinct SomeInteger; node: PNode = nil): SemReport

SemReportErrorKind:

• report_enums: SemReportErrorKind

semReportIllformedAst:

• msgs: semReportIllformedAst(conf: ConfigRef; node: PNode; expected: set[TNodeKind]): untyped
• msgs: semReportIllformedAst(conf: ConfigRef; node: PNode; explain: string): untyped

SemReportKind:

• report_enums: SemReportKind

SemSideEffectCallKind:

• reports_sem: SemSideEffectCallKind

SemSpellCandidate:

• ast_types: SemSpellCandidate

semstepEnter:

• DebugSemStepDirection.semstepEnter

semstepLeave:

• DebugSemStepDirection.semstepLeave

semtabAll:

• modulegraphs: semtabAll(g: ModuleGraph; m: PSym): TStrTable

SemTypeMismatch:

• ast_types: SemTypeMismatch

seNoSideEffect:

• TSideEffectAnalysis.seNoSideEffect

SeqMap:

• containers: SeqMap

seSideEffect:

• TSideEffectAnalysis.seSideEffect

setAttachedOp:

• modulegraphs: setAttachedOp(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym)

setAttachedOpPartial:

• modulegraphs: setAttachedOpPartial(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp; value: PSym)

setCaseContextIdx:

• semdata: setCaseContextIdx(c: PContext; idx: int)

setCC:

• extccomp: setCC(conf: ConfigRef; ccname: string): TSystemCC

setCmd:

• optionsprocessor: setCmd(conf: ConfigRef; cmd: Command)

setCommandEarly:

• optionsprocessor: setCommandEarly(conf: ConfigRef; command: string)

setConfigVar:

• options: setConfigVar(conf: ConfigRef; key, val: string)

setData:

• mirenv: setData(env: var MirEnv; id: ConstId; data: DataId)

setDefaultLibpath:

• options: setDefaultLibpath(conf: ConfigRef)

setDirtyFile:

• msgs: setDirtyFile(conf: ConfigRef; fileIdx: FileIndex; filename: AbsoluteFile)

setEffectsForProcType:

• sempass2: setEffectsForProcType(g: ModuleGraph; t: PType; n: PNode; s: PSym = nil)

setErrorMaxHighMaybe:

• options: setErrorMaxHighMaybe(conf: ConfigRef)

setFromProjectName:

• options: setFromProjectName(conf: ConfigRef; projectName: string)

setGlobalValue:

• compilerbridge: setGlobalValue(c: var EvalContext; s: PSym; val: PNode)

setHash:

• msgs: setHash(conf: ConfigRef; fileIdx: FileIndex; hash: string)

setHasRange:

• nimsets: setHasRange(s: PNode): bool

setImplicitDebugConfRef:

• astrepr: setImplicitDebugConfRef(conf: ConfigRef)

setInfoContextLen:

• msgs: setInfoContextLen(conf: ConfigRef; L: int)

setIntLitType:

• semdata: setIntLitType(c: PContext; result: PNode)

setLen:

• containers: setLen[I; T](x: var OrdinalSeq[I, T]; len: int)
• vmobjects: setLen(s: var VmString; newLen: Natural; a: var VmAllocator)

setLenSeq:

• vmobjects: setLenSeq(s: var VmSeq; typ: PVmType; len: int; mm: var VmMemoryManager)

setModuleOverride:

• backends: setModuleOverride(discovery: var DiscoveryData; id: ProcedureId; module: FileIndex)

setNote:

• options: setNote(conf: ConfigRef; note: ReportKind; enabled = true)

setNoteDefaults:

• options: setNoteDefaults(conf: ConfigRef; note: ReportKind; enabled = true)

setReportHook:

• options: setReportHook(conf: ConfigRef; hook: ReportHook)

setResult:

• vmhooks: setResult(a: VmArgs; v: AbsoluteDir)
• vmhooks: setResult(a: VmArgs; v: BiggestFloat)
• vmhooks: setResult(a: VmArgs; v: BiggestInt)
• vmhooks: setResult(a: VmArgs; v: bool)
• vmhooks: setResult(a: VmArgs; v: openArray[char])
• vmhooks: setResult(a: VmArgs; v: PNode)

setSource:

• mirconstr: setSource(bu: var MirBuilder; id: SourceId)

setTarget:

• platform: setTarget(t: var Target; o: TSystemOS; c: TSystemCPU)

setTargetFromSystem:

• platform: setTargetFromSystem(t: var Target)

setToStringProc:

• modulegraphs: setToStringProc(g: ModuleGraph; t: PType; value: PSym)

setTransformed:

• modulegraphs: setTransformed(g: ModuleGraph; prc: PSym; body: PNode)

setup:

• vmobjects: setup(ctx: var VariantFieldIterCtx; typ: PVmType; branch: uint32)

setupCompileTimeVar:

• compilerbridge: setupCompileTimeVar(module: PSym; idgen: IdGenerator; g: ModuleGraph; n: PNode)

setupGlobalCtx:

• compilerbridge: setupGlobalCtx(module: PSym; graph: ModuleGraph; idgen: IdGenerator)

setupModule:

• modulelowering: setupModule(graph: ModuleGraph; idgen: IdGenerator; m: PSym; decls, imperative: seq[PNode]): Module

setupParser:

• syntaxes: setupParser(p: var Parser; fileIdx: FileIndex; cache: IdentCache; config: ConfigRef): bool

setupVM:

• scripting: setupVM(module: PSym; cache: IdentCache; scriptName: string; graph: ModuleGraph; idgen: IdGenerator): TCtx

setUseIc:

• ast_types: setUseIc(useIc: bool)

seUnknown:

• TSideEffectAnalysis.seUnknown

Severity:

• lineinfos: Severity

severity:

• reports: severity(report: Report; asError: ReportKinds = default(ReportKinds); asWarning: ReportKinds = default(ReportKinds)): ReportSeverity
• reports: severity(report: ReportTypes; asError: ReportKinds; asWarning: ReportKinds = default(ReportKinds)): ReportSeverity
• reports_backend: severity(report: BackendReport): ReportSeverity
• reports_cmd: severity(report: CmdReport): ReportSeverity
• reports_debug: severity(report: DebugReport): ReportSeverity
• reports_external: severity(report: ExternalReport): ReportSeverity
• reports_internal: severity(report: InternalReport): ReportSeverity
• reports_lexer: severity(rep: LexerReport): ReportSeverity
• reports_parser: severity(parser: ParserReport): ReportSeverity
• reports_sem: severity(report: SemReport): ReportSeverity
• reports_vm: severity(vm: VMReport): ReportSeverity
• options: severity(conf: ConfigRef; report: ReportTypes | Report): ReportSeverity

sexp:

• sexp_reporter: sexp[R, T](s: array[R, T]): SexpNode
• sexp_reporter: sexp(s: cstring): SexpNode
• sexp_reporter: sexp[E: enum](e: E): SexpNode
• sexp_reporter: sexp(id: FileIndex): SexpNode
• sexp_reporter: sexp(n: NodeId): SexpNode
• sexp_reporter: sexp[T](o: Option[T]): SexpNode
• sexp_reporter: sexp(node: PNode): SexpNode
• sexp_reporter: sexp(t: PSym): SexpNode
• sexp_reporter: sexp(typ: PType): SexpNode
• sexp_reporter: sexp[T: object | tuple](obj: ref T): SexpNode
• sexp_reporter: sexp(i: ReportLineInfo): SexpNode
• sexp_reporter: sexp[T](s: seq[T]): SexpNode
• sexp_reporter: sexp[I](s: set[I]): SexpNode
• sexp_reporter: sexp(v: SomeInteger): SexpNode
• sexp_reporter: sexp(e: StackTraceEntry): SexpNode
• sexp_reporter: sexp[T: object | tuple](obj: T): SexpNode
• sexp_reporter: sexp(i: TLineInfo): SexpNode

sexpItems:

• sexp_reporter: sexpItems[T](s: T): SexpNode

sfAddrTaken:

• TSymFlag.sfAddrTaken

sfAllUntyped:

• ast_types: sfAllUntyped

sfAnon:

• ast_types: sfAnon

sfBase:

• ast_types: sfBase

sfBorrow:

• TSymFlag.sfBorrow

sfCallsite:

• TSymFlag.sfCallsite

sfCompilerProc:

• TSymFlag.sfCompilerProc

sfCompileTime:

• TSymFlag.sfCompileTime

sfCursor:

• TSymFlag.sfCursor

sfCustomPragma:

• ast_types: sfCustomPragma

sfDeprecated:

• TSymFlag.sfDeprecated

sfDirty:

• ast_types: sfDirty

sfDiscardable:

• TSymFlag.sfDiscardable

sfDiscriminant:

• TSymFlag.sfDiscriminant

sfDispatcher:

• TSymFlag.sfDispatcher

sfEffectsDelayed:

• TSymFlag.sfEffectsDelayed

sfError:

• TSymFlag.sfError

sfEscapes:

• ast_types: sfEscapes

sfExperimental:

• ast_types: sfExperimental

sfExplain:

• TSymFlag.sfExplain

sfExportc:

• TSymFlag.sfExportc

sfExported:

• TSymFlag.sfExported

sfForward:

• TSymFlag.sfForward

sfFromGeneric:

• TSymFlag.sfFromGeneric

sfGeneratedOp:

• TSymFlag.sfGeneratedOp

sfGenSym:

• TSymFlag.sfGenSym

sfGlobal:

• TSymFlag.sfGlobal

sfImportc:

• TSymFlag.sfImportc

sfInfixCall:

• TSymFlag.sfInfixCall

sfInjectDestructors:

• TSymFlag.sfInjectDestructors

sfMainModule:

• TSymFlag.sfMainModule

sfModuleInit:

• jsgen: sfModuleInit

sfNeverRaises:

• TSymFlag.sfNeverRaises

sfNoalias:

• TSymFlag.sfNoalias

sfNoForward:

• ast_types: sfNoForward

sfNoInit:

• ast_types: sfNoInit

sfNoReturn:

• TSymFlag.sfNoReturn

sfNoSideEffect:

• TSymFlag.sfNoSideEffect

sfOverriden:

• TSymFlag.sfOverriden

sfProcvar:

• TSymFlag.sfProcvar

sfPure:

• TSymFlag.sfPure

sfRegister:

• TSymFlag.sfRegister

sfRequiresInit:

• TSymFlag.sfRequiresInit

sfShadowed:

• TSymFlag.sfShadowed

sfSideEffect:

• TSymFlag.sfSideEffect

sfSystemModule:

• TSymFlag.sfSystemModule

sfTemplateParam:

• TSymFlag.sfTemplateParam

sfThread:

• TSymFlag.sfThread

sfTopLevel:

• cgen: sfTopLevel

sfUsed:

• TSymFlag.sfUsed

sfUsedInFinallyOrExcept:

• TSymFlag.sfUsedInFinallyOrExcept

sfVolatile:

• TSymFlag.sfVolatile

sfWasForwarded:

• TSymFlag.sfWasForwarded

sfWrittenTo:

• ast_types: sfWrittenTo

sgcuAccessesGcGlobal:

• SemGcUnsafetyKind.sgcuAccessesGcGlobal

sgcuCallsUnsafe:

• SemGcUnsafetyKind.sgcuCallsUnsafe

sgcuIndirectCallHere:

• SemGcUnsafetyKind.sgcuIndirectCallHere

sgcuIndirectCallVia:

• SemGcUnsafetyKind.sgcuIndirectCallVia

shallowCopy:

• ast: shallowCopy(src: PNode): PNode

shouldInjectDestructorCalls:

• injectdestructors: shouldInjectDestructorCalls(owner: PSym): bool

showMsg:

• commands: showMsg(conf: ConfigRef; msg: string)

sibling:

• mirtrees: sibling(tree: MirTree; n: NodePosition): NodePosition

SigHash:

• modulegraphs: SigHash

sigHash:

• sighashes: sigHash(s: PSym): SigHash

signExtended:

• vmobjects: signExtended(val, size: BiggestInt): untyped

simpleSlice:

• guards: simpleSlice(a, b: PNode): BiggestInt

simulateCachedModule:

• modulegraphs: simulateCachedModule(g: ModuleGraph; moduleSym: PSym; m: PackedModule)

simulateLoadedModule:

• ic: simulateLoadedModule(g: var PackedModuleGraph; conf: ConfigRef; cache: IdentCache; moduleSym: PSym; m: PackedModule)

since:

• datatables: since(t: DataTable; p: Checkpoint): (DataId, lent ConstrTree)
• mirenv: since[I; T](tab: SymbolTable[I, T]; p: Checkpoint): (I, lent T)
• containers: since[I; T](s: Store[I, T]; p: Checkpoint): (I, lent T)

SingleOperandNodes:

• mirtrees: SingleOperandNodes

size:

• mirtypes: size(desc: TypeHeader; env: TypeEnv): BiggestInt

sizeType:

• mirtypes: sizeType(env: TypeEnv): TypeId

skConditional:

• TSymKind.skConditional

skConst:

• TSymKind.skConst

skConverter:

• TSymKind.skConverter

skDynLib:

• TSymKind.skDynLib

skEnumField:

• TSymKind.skEnumField

skError:

• ast_types: skError

skField:

• TSymKind.skField

skForVar:

• TSymKind.skForVar

skFunc:

• TSymKind.skFunc

skGenericParam:

• TSymKind.skGenericParam

skip:

• mirtrees: skip(tree: MirTree; n: OpValue; kind: MirNodeKind): OpValue

skipAddr:

• ast_query: skipAddr(n: PNode): PNode

skipCodegen:

• passes: skipCodegen(config: ConfigRef; n: PNode): bool

skipColon:

• ast_query: skipColon(n: PNode): PNode

skipConv:

• types: skipConv(n: PNode): PNode
• compat: skipConv(n: CgNode): CgNode

skipConvCastAndClosure:

• astalgo: skipConvCastAndClosure(n: PNode): PNode

skipConversions:

• analysis: skipConversions(tree: MirTree; val: OpValue): OpValue

skipConvTakeType:

• types: skipConvTakeType(n: PNode): PNode

skipDistincts:

• ast_query: skipDistincts(t: PType): PType

skipForDiscardable:

• ast_query: skipForDiscardable

skipForHooks:

• ast_types: skipForHooks

skipGenericAlias:

• types: skipGenericAlias(t: PType): PType

skipGenericOwner:

• ast_query: skipGenericOwner(s: PSym): PSym

skipHidden:

• types: skipHidden(n: PNode): PNode

skipIntLit:

• magicsys: skipIntLit(t: PType; id: IdGenerator): PType

skipIntLiteralParams:

• semtypinst: skipIntLiteralParams(t: PType; idgen: IdGenerator)

skipPtrs:

• ast_types: skipPtrs

skipStmtList:

• ast_query: skipStmtList(n: PNode): PNode

skipToObject:

• types: skipToObject(t: PType; numIndirectsAllowed = 1): PType

skipTypes:

• ast_query: skipTypes(t: PType; kinds: TTypeKinds): PType
• ast_query: skipTypes(t: PType; kinds: TTypeKinds; maxIters: int): PType

skipTypesOrNil:

• ast_query: skipTypesOrNil(t: PType; kinds: TTypeKinds): PType

skIterator:

• TSymKind.skIterator

skLabel:

• TSymKind.skLabel

skLet:

• TSymKind.skLet

skLocalVars:

• ast_query: skLocalVars

skMacro:

• TSymKind.skMacro

skMethod:

• TSymKind.skMethod

skModule:

• TSymKind.skModule

skPackage:

• TSymKind.skPackage

skParam:

• TSymKind.skParam

skProc:

• TSymKind.skProc

skProcKinds:

• ast_query: skProcKinds

skResult:

• TSymKind.skResult

skStub:

• TSymKind.skStub

skTemp:

• TSymKind.skTemp

skTemplate:

• TSymKind.skTemplate

skType:

• TSymKind.skType

skUnknown:

• TSymKind.skUnknown

skVar:

• TSymKind.skVar

slice:

• vmmemory: slice(p: VmMemPointer | CellPtr; len: Natural): untyped
• vmmemory: slice(p: VmMemPointer | CellPtr; offset, len: Natural): untyped

SliceAllArguments:

• NodeSliceName.SliceAllArguments

SliceAllBranches:

• NodeSliceName.SliceAllBranches

SliceAllIdents:

• NodeSliceName.SliceAllIdents

SliceBranchExpressions:

• NodeSliceName.SliceBranchExpressions

sliceIt:

• cgir: sliceIt[T](x: seq[T]; lo, hi: Natural): (int, lent T)

SliceListType:

• packed_env: SliceListType

slotSomeTemp:

• vmgen: slotSomeTemp

smolSwitchTxtBackend:

• CmdSwitchTextKind.smolSwitchTxtBackend

smolSwitchTxtCompileonly:

• CmdSwitchTextKind.smolSwitchTxtCompileonly

smolSwitchTxtDefine:

• CmdSwitchTextKind.smolSwitchTxtDefine

smolSwitchTxtForcebuild:

• CmdSwitchTextKind.smolSwitchTxtForcebuild

smolSwitchTxtOut:

• CmdSwitchTextKind.smolSwitchTxtOut

smolSwitchTxtPath:

• CmdSwitchTextKind.smolSwitchTxtPath

smolSwitchTxtProjStdin:

• CmdSwitchTextKind.smolSwitchTxtProjStdin

smolSwitchTxtUndef:

• CmdSwitchTextKind.smolSwitchTxtUndef

smolSwitchTxtWarnings:

• CmdSwitchTextKind.smolSwitchTxtWarnings

someInSet:

• nimsets: someInSet(s: PNode; a, b: PNode): bool

someSym:

• modulegraphs: someSym(g: ModuleGraph; m: PSym; name: PIdent): PSym

someSymFromImportTable:

• lookups: someSymFromImportTable(c: PContext; name: PIdent; ambiguous: var bool): PSym

sons:

• packed_ast: sons(dest: var PackedTree; tree: PackedTree; n: NodePos): NodePos

sons2:

• packed_ast: sons2(tree: PackedTree; n: NodePos): (NodePos, NodePos)

sons3:

• packed_ast: sons3(tree: PackedTree; n: NodePos): (NodePos, NodePos, NodePos)

sonsFrom1:

• packed_ast: sonsFrom1(tree: PackedTree; n: NodePos): NodePos

sonsReadonly:

• packed_ast: sonsReadonly(tree: PackedTree; n: NodePos): NodePos

sonsWithoutLast2:

• packed_ast: sonsWithoutLast2(tree: PackedTree; n: NodePos): NodePos

source:

• vm: source(c: TCtx; t: VmThread): TLineInfo

sourceFor:

• mirbodies: sourceFor(body: MirBody; n: NodePosition): PNode

SourceId:

• mirtrees: SourceId

sourceLine:

• msgs: sourceLine(conf: ConfigRef; i: TLineInfo): string

SourceMap:

• sourcemaps: SourceMap
• sourcemap: SourceMap

SourceNode:

• sourcemap: SourceNode

span:

• packed_ast: span(tree: PackedTree; pos: int): int

spellSuggestSecretSauce:

• options: spellSuggestSecretSauce

splitCustomLit:

• ast: splitCustomLit(n: ParsedNode): tuple[num, ident: ParsedNode]

splitFile:

• pathutils: splitFile(x: AbsoluteFile): tuple[dir: AbsoluteDir, name, ext: string]

ssefCallsSideEffect:

• SemSideEffectCallKind.ssefCallsSideEffect

ssefCallsViaHiddenIndirection:

• SemSideEffectCallKind.ssefCallsViaHiddenIndirection

ssefCallsViaIndirection:

• SemSideEffectCallKind.ssefCallsViaIndirection

ssefParameterMutation:

• SemSideEffectCallKind.ssefParameterMutation

ssefUsesGlobalState:

• SemSideEffectCallKind.ssefUsesGlobalState

StackFrameIndex:

• vmdef: StackFrameIndex

staging:

• mirconstr: staging(bu: var MirBuilder): var MirNodeSeq

start:

• mirconstr: start(bu: var MirBuilder; n: sink MirNode): Context

startEncoding:

• packed_env: startEncoding(enc: var DataEncoder; e: PackedEnv)

startProc:

• cgen: startProc(m: BModule; id: ProcedureId; procBody: sink Body): BProc
• jsgen: startProc(g: PGlobals; module: BModule; id: ProcedureId; body: sink Body): PProc

startScope:

• mirgen_blocks: startScope(c): int

StartSize:

• ast: StartSize

StdOrrKind:

• options: StdOrrKind

stdOrrStderr:

• StdOrrKind.stdOrrStderr

stdOrrStdout:

• StdOrrKind.stdOrrStdout

stepError:

• DebugSemStepKind.stepError

stepIdentToSym:

• DebugSemStepKind.stepIdentToSym

stepNodeFlagsToNode:

• DebugSemStepKind.stepNodeFlagsToNode

stepNodeSigMatch:

• DebugSemStepKind.stepNodeSigMatch

stepNodeToNode:

• DebugSemStepKind.stepNodeToNode

stepNodeToSym:

• DebugSemStepKind.stepNodeToSym

stepNodeTypeToType:

• DebugSemStepKind.stepNodeTypeToType

StepParams:

• debugutils: StepParams

stepParams:

• debugutils: stepParams(c: ConfigRef; kind: DebugSemStepKind; indentLevel: int; action: string): StepParams

stepResolveOverload:

• DebugSemStepKind.stepResolveOverload

stepSymNodeToNode:

• DebugSemStepKind.stepSymNodeToNode

stepTrack:

• DebugSemStepKind.stepTrack

stepTypeTypeToType:

• DebugSemStepKind.stepTypeTypeToType

stepWrongNode:

• DebugSemStepKind.stepWrongNode

stkBlock:

• StructKind.stkBlock

stkCatch:

• StructKind.stkCatch

stkEnd:

• StructKind.stkEnd

stkFinally:

• StructKind.stkFinally

stkReturn:

• StructKind.stkReturn

stkStructStart:

• StructKind.stkStructStart

stkTerminator:

• StructKind.stkTerminator

stkTry:

• StructKind.stkTry

stmtList:

• mirconstr: stmtList(bu: var MirBuilder; body: untyped)

StmtNodes:

• mirtrees: StmtNodes

stmtPragmas:

• pragmas: stmtPragmas

stmtToStr:

• utils: stmtToStr(tree: MirTree; n: NodePosition; env: ptr MirEnv = nil; body: ptr MirBody = nil): string

stopCompile:

• modulegraphs: stopCompile(g: ModuleGraph): bool

store:

• bitabs: store[T](f: var RodFile; t: BiTable[T])

Store:

• containers: Store

storeAttachedOp:

• ic: storeAttachedOp(c: var PackedEncoder; m: var PackedModule; kind: TTypeAttachedOp; t: PType; s: PSym)

stored:

• ModuleStatus.stored

storeData:

• packed_env: storeData(enc: var DataEncoder; e: var PackedEnv; tree: MirTree): int

storeEnv:

• packed_env: storeEnv(enc: var PackedEncoder; dst: var PackedEnv; c: TCtx)

storeExpansion:

• ic: storeExpansion(c: var PackedEncoder; m: var PackedModule; info: TLineInfo; s: PSym)

storeHeader:

• rodfiles: storeHeader(f: var RodFile)

storeInstantiation:

• ic: storeInstantiation(c: var PackedEncoder; m: var PackedModule; s: PSym; i: PInstantiation)

storeLib:

• ic: storeLib(c: var PackedEncoder; m: var PackedModule; lib: TLib)

storeLibs:

• modulegraphs: storeLibs(g: ModuleGraph; module: int)

storePrim:

• rodfiles: storePrim(f: var RodFile; s: string)
• rodfiles: storePrim[T](f: var RodFile; x: T)

storeRodNode:

• semdata: storeRodNode(c: PContext; n: PNode)

storeSection:

• rodfiles: storeSection(f: var RodFile; s: RodSection)

storeSeq:

• rodfiles: storeSeq[T](f: var RodFile; s: seq[T])

storeSym:

• ic: storeSym(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId

storeTypeInst:

• ic: storeTypeInst(c: var PackedEncoder; m: var PackedModule; s: PSym; inst: PType)

storing:

• ModuleStatus.storing

strArg:

• filters: strArg(conf: ConfigRef; n: PNode; name: string; pos: int; default: string): string

stressTest:

• SymbolFilesOption.stressTest

strictEffects:

• Feature.strictEffects

strictFuncs:

• Feature.strictFuncs

strictNotNil:

• Feature.strictNotNil

StringId:

• mirtrees: StringId

stringsSection:

• RodSection.stringsSection

StringType:

• mirtypes: StringType

strTableAdd:

• astalgo: strTableAdd(t: var TStrTable; n: PSym)

strTableAdds:

• modulegraphs: strTableAdds(g: ModuleGraph; m: PSym; s: PSym)

strTableContains:

• astalgo: strTableContains(t: TStrTable; n: PSym): bool

strTableGet:

• astalgo: strTableGet(t: TStrTable; name: PIdent): PSym

strTableIncl:

• astalgo: strTableIncl(t: var TStrTable; n: PSym; onConflictKeepOld = false): bool

strTableInclReportConflict:

• astalgo: strTableInclReportConflict(t: var TStrTable; n: PSym; onConflictKeepOld = false): PSym

StructDesc:

• jsflow: StructDesc

StructKind:

• jsflow: StructKind

StructuralEquivTypes:

• ast_query: StructuralEquivTypes

Structure:

• jsflow: Structure

strVal:

• vm: strVal(r: TFullReg): untyped

strVal=:

• vm: strVal=(r: TFullReg; s: string)
• vm: strVal=(r: TFullReg; s: VmString)

stupidStmtListExpr:

• trees: stupidStmtListExpr(n: PNode): bool

styleCheckDef:

• linter: styleCheckDef(conf: ConfigRef; s: PSym)
• linter: styleCheckDef(conf: ConfigRef; info: TLineInfo; s: PSym)
• linter: styleCheckDef(conf: ConfigRef; info: TLineInfo; s: PSym; k: TSymKind)

styleCheckUse:

• linter: styleCheckUse(conf: ConfigRef; info: TLineInfo; s: PSym)

stylize:

• commands: stylize(str: string; color: ForegroundColor; styles: set[Style] = {}): string
• commands: stylize(str: string; color: ForegroundColor; style: Style): string

Subgraph:

• mirexec: Subgraph

subgraphFor:

• mirexec: subgraphFor(dfg: DataFlowGraph; span: Slice[NodePosition]): Subgraph

subLocation:

• vmmemory: subLocation(h: LocHandle; offset: Natural; typ: PVmType): LocHandle

subNodes:

• mirtrees: subNodes(tree: MirTree; n: NodePosition; start = 0): NodePosition

subTree:

• mirconstr: subTree(bu: var MirBuilder; n: MirNode; body: untyped)
• mirconstr: subTree(bu: var MirBuilder; k: MirNodeKind; body: untyped)

SubTreeNodes:

• mirtrees: SubTreeNodes

subView:

• vmdef: subView[T](x: openArray[T]; off): untyped
• vmdef: subView[T](x: openArray[T]; off, len): untyped

Suggest:

• options: Suggest

SuggestCallback:

• modulegraphs: SuggestCallback

suggestDecl:

• suggest: suggestDecl(c: PContext; n: PNode; s: PSym)

suggestEnum:

• suggest: suggestEnum(c: PContext; n: PNode; t: PType)

suggestExpr:

• suggest: suggestExpr(c: PContext; n: PNode)

suggestExprNoCheck:

• suggest: suggestExprNoCheck(c: PContext; n: PNode)

SuggestFlag:

• options: SuggestFlag

Suggestions:

• options: Suggestions

suggestQuit:

• msgs: suggestQuit()

suggestSentinel:

• suggest: suggestSentinel(c: PContext)

suggestStmt:

• suggest: suggestStmt(c: PContext; n: PNode)

suggestSym:

• suggest: suggestSym(g: ModuleGraph; info: TLineInfo; s: PSym; usageSym: var PSym; isDecl = true)

symBodyDigest:

• sighashes: symBodyDigest(graph: ModuleGraph; sym: PSym): SigHash

symbolFiles:

• options: symbolFiles(conf`gensym23: ConfigRef): SymbolFilesOption

symbolFiles=:

• options: symbolFiles=(conf`gensym23: ConfigRef; val`gensym23: SymbolFilesOption)

SymbolFilesOption:

• in_options: SymbolFilesOption

symbols:

• options: symbols(conf`gensym72: ConfigRef): StringTableRef

symbols=:

• options: symbols=(conf`gensym72: ConfigRef; val`gensym72: StringTableRef)

symbolsDel:

• options: symbolsDel(conf`gensym71: ConfigRef; key`gensym71: string)

symbolsGet:

• options: symbolsGet(conf`gensym71: ConfigRef; key`gensym71: string): string

symbolsSet:

• options: symbolsSet(conf`gensym71: ConfigRef; key`gensym71: string; value`gensym71: string)

SymbolTable:

• mirenv: SymbolTable

symbolToPmir:

• proto_mir: symbolToPmir(s: PSym): range[pirProc .. pirConst]

SymChars:

• lexer: SymChars

symdiffSets:

• nimsets: symdiffSets(conf: ConfigRef; a, b: PNode): PNode

SymId:

• packed_ast: SymId

symId:

• packed_ast: symId(n: NodePos): SymId

symInDynamicLib:

• cgen: symInDynamicLib(m: BModule; id: ProcedureId)

symsSection:

• RodSection.symsSection

SymStartChars:

• lexer: SymStartChars

symstr:

• reports: symstr(r: SemReport | VMReport): string

symTabReplace:

• astalgo: symTabReplace(t: var TStrTable; prevSym: PSym; newSym: PSym)

synchronize:

• containers: synchronize[I; A; B](x: var OrdinalSeq[I, A]; s: Store[I, B])

systemModule:

• modulelowering: systemModule(modules: ModuleList): lent Module

systemModuleSym:

• modulegraphs: systemModuleSym(g: ModuleGraph; name: PIdent): PSym

systemModuleSyms:

• modulegraphs: systemModuleSyms(g: ModuleGraph; name: PIdent): PSym

sysTypeFromName:

• magicsys: sysTypeFromName(g: ModuleGraph; info: TLineInfo; name: string): PType

szIllegalRecursion:

• types: szIllegalRecursion

szTooBigSize:

• types: szTooBigSize

szUncomputedSize:

• types: szUncomputedSize

szUnknownSize:

• types: szUnknownSize

Tabulator:

• nimlexbase: Tabulator

taConcept:

• TTypeAllowedFlag.taConcept

taField:

• TTypeAllowedFlag.taField

tagEffects:

• ast_types: tagEffects

TagsExt:

• options: TagsExt

taHeap:

• TTypeAllowedFlag.taHeap

taIsOpenArray:

• TTypeAllowedFlag.taIsOpenArray

taIsTemplateOrMacro:

• TTypeAllowedFlag.taIsTemplateOrMacro

takeModuleList:

• modulelowering: takeModuleList(graph: ModuleGraph): ModuleList

TAliasRequest:

• parampatterns: TAliasRequest

TAnalysisResult:

• aliases: TAnalysisResult

taNoUntyped:

• TTypeAllowedFlag.taNoUntyped

taProcContextIsNotMacro:

• TTypeAllowedFlag.taProcContextIsNotMacro

TArg:

• NilTransition.TArg

target:

• options: target(conf`gensym27: ConfigRef): Target

Target:

• platform: Target

target=:

• options: target=(conf`gensym27: ConfigRef; val`gensym27: Target)

TargetBackend:

• mirpasses: TargetBackend

targetC:

• TargetBackend.targetC

targetJs:

• TargetBackend.targetJs

targetVm:

• TargetBackend.targetVm

TAssign:

• NilTransition.TAssign

TAssignableResult:

• parampatterns: TAssignableResult

TAstDiag:

• ast_types: TAstDiag

TBackend:

• in_options: TBackend

TBaseLexer:

• nimlexbase: TBaseLexer

TBitSet:

• bitsets: TBitSet

TBitSetView:

• bitsets: TBitSetView

TBlock:

• cgendata: TBlock

TCallingConvention:

• ast_types: TCallingConvention

TCandidate:

• sigmatch: TCandidate

TCandidateState:

• sigmatch: TCandidateState

TCFileSection:

• cgendata: TCFileSection

TCFileSections:

• cgendata: TCFileSections

TCheckPointResult:

• suggest: TCheckPointResult

TCmdLinePass:

• options: TCmdLinePass

TContext:

• semdata: TContext

TCProcFlag:

• cgendata: TCProcFlag

TCProcSection:

• cgendata: TCProcSection

TCProcSections:

• cgendata: TCProcSections

TCtx:

• vmdef: TCtx

TCTypeKind:

• cgendata: TCTypeKind

TDependant:

• NilTransition.TDependant

TDistinctCompare:

• types: TDistinctCompare

temp:

• mirconstr: temp(typ: TypeId; id: LocalId): Value

templatePragmas:

• pragmas: templatePragmas

temporaryStringError:

• msgs: temporaryStringError(conf: ConfigRef; info: TLineInfo; text: string)

Ten:

• int128: Ten

Ternary:

• aliasanalysis: Ternary

TErrorHandling:

• options: TErrorHandling

TErrorOutput:

• lineinfos: TErrorOutput

TErrorOutputs:

• lineinfos: TErrorOutputs

testCompileOption:

• optionsprocessor: testCompileOption(conf: ConfigRef; switch: string): CompileOptCheckResult

testCompileOptionArg:

• optionsprocessor: testCompileOptionArg(conf: ConfigRef; switch, arg: string): CompileOptArgCheckResult

TEvalMode:

• vmdef: TEvalMode

TexExt:

• options: TexExt

TExprFlag:

• ast_types: TExprFlag

TExprFlags:

• ast_types: TExprFlags

text:

• sourcemap: text(sourceNode: SourceNode; depth: int): string

tfAcyclic:

• TTypeFlag.tfAcyclic

tfBorrowDot:

• TTypeFlag.tfBorrowDot

tfByCopy:

• TTypeFlag.tfByCopy

tfByRef:

• TTypeFlag.tfByRef

tfCheckedForDestructor:

• TTypeFlag.tfCheckedForDestructor

tfCompleteStruct:

• TTypeFlag.tfCompleteStruct

tfConceptMatchedTypeSym:

• TTypeFlag.tfConceptMatchedTypeSym

tfContravariant:

• TTypeFlag.tfContravariant

tfCovariant:

• TTypeFlag.tfCovariant

tfEffectSystemWorkaround:

• TTypeFlag.tfEffectSystemWorkaround

tfEnumHasHoles:

• TTypeFlag.tfEnumHasHoles

tfExplicit:

• TTypeFlag.tfExplicit

tfExplicitCallConv:

• TTypeFlag.tfExplicitCallConv

tfFinal:

• TTypeFlag.tfFinal

tfFromGeneric:

• TTypeFlag.tfFromGeneric

tfGcSafe:

• ast_types: tfGcSafe

tfGenericTypeParam:

• TTypeFlag.tfGenericTypeParam

tfHasAsgn:

• TTypeFlag.tfHasAsgn

tfHasGCedMem:

• TTypeFlag.tfHasGCedMem

tfHasMeta:

• TTypeFlag.tfHasMeta

tfHasStatic:

• TTypeFlag.tfHasStatic

TFileInfo:

• lineinfos: TFileInfo

tfImplicitTypeParam:

• TTypeFlag.tfImplicitTypeParam

tfIncompleteStruct:

• TTypeFlag.tfIncompleteStruct

tfInferrableStatic:

• TTypeFlag.tfInferrableStatic

tfInheritable:

• TTypeFlag.tfInheritable

tfIsConstructor:

• TTypeFlag.tfIsConstructor

tfIterator:

• TTypeFlag.tfIterator

tfNeedsFullInit:

• TTypeFlag.tfNeedsFullInit

tfNoSideEffect:

• TTypeFlag.tfNoSideEffect

tfNotNil:

• TTypeFlag.tfNotNil

tfObjHasKids:

• ast_types: tfObjHasKids

tfPacked:

• TTypeFlag.tfPacked

tfRefsAnonObj:

• TTypeFlag.tfRefsAnonObj

tfRequiresInit:

• TTypeFlag.tfRequiresInit

tfResolved:

• TTypeFlag.tfResolved

tfRetType:

• TTypeFlag.tfRetType

tfReturnsNew:

• ast_types: tfReturnsNew

tfThread:

• TTypeFlag.tfThread

tfTriggersCompileTime:

• TTypeFlag.tfTriggersCompileTime

TFullReg:

• vmdef: TFullReg

tfUnion:

• ast_types: tfUnion

tfUnresolved:

• TTypeFlag.tfUnresolved

tfVarargs:

• TTypeFlag.tfVarargs

tfWeakCovariant:

• TTypeFlag.tfWeakCovariant

tfWildcard:

• TTypeFlag.tfWildcard

TGCMode:

• in_options: TGCMode

TGlobalOption:

• in_options: TGlobalOption

TGlobalOptions:

• in_options: TGlobalOptions

theindexFname:

• nimpaths: theindexFname

threadVarAccessed:

• TCProcFlag.threadVarAccessed

throwAwayLastNode:

• packed_ast: throwAwayLastNode(tree: var PackedTree)

TIdent:

• idents: TIdent

TIdentIter:

• astalgo: TIdentIter

TIdNodePair:

• ast_types: TIdNodePair

TIdNodePairSeq:

• ast_types: TIdNodePairSeq

TIdNodeTable:

• ast_types: TIdNodeTable

TIdObj:

• ast_types: TIdObj

TIdPair:

• ast_types: TIdPair

TIdPairSeq:

• ast_types: TIdPairSeq

TIdTable:

• ast_types: TIdTable

TIIPair:

• astalgo: TIIPair

TIIPairSeq:

• astalgo: TIIPairSeq

TIITable:

• astalgo: TIITable

TImplication:

• ast_types: TImplication

TInfoCC:

• extccomp: TInfoCC

TInfoCCProp:

• extccomp: TInfoCCProp

TInfoCCProps:

• extccomp: TInfoCCProps

TInfoCPU:

• platform: TInfoCPU

TInfoOS:

• platform: TInfoOS

TInfoOSProp:

• platform: TInfoOSProp

TInfoOSProps:

• platform: TInfoOSProps

TInstantiation:

• ast_types: TInstantiation

TInstantiationPair:

• semdata: TInstantiationPair

TInstr:

• vmdef: TInstr

TInstrType:

• vmdef: TInstrType

tkAccent:

• TokType.tkAccent

tkAddr:

• TokType.tkAddr

tkAnd:

• TokType.tkAnd

tkArray:

• TypeKind.tkArray

tkAs:

• TokType.tkAs

tkAsm:

• TokType.tkAsm

tkBind:

• TokType.tkBind

tkBlock:

• TokType.tkBlock

tkBool:

• TypeKind.tkBool

tkBracketDotLe:

• TokType.tkBracketDotLe

tkBracketDotRi:

• TokType.tkBracketDotRi

tkBracketLe:

• TokType.tkBracketLe

tkBracketLeColon:

• TokType.tkBracketLeColon

tkBracketRi:

• TokType.tkBracketRi

tkBreak:

• TokType.tkBreak

tkCase:

• TokType.tkCase

tkCast:

• TokType.tkCast

tkChar:

• TypeKind.tkChar

tkCharLit:

• TokType.tkCharLit

tkClosure:

• TypeKind.tkClosure

tkColon:

• TokType.tkColon

tkColonColon:

• TokType.tkColonColon

tkComma:

• TokType.tkComma

tkComment:

• TokType.tkComment

tkConcept:

• TokType.tkConcept

tkConst:

• TokType.tkConst

tkContinue:

• TokType.tkContinue

tkConverter:

• TokType.tkConverter

tkCstring:

• TypeKind.tkCstring

tkCurlyDotLe:

• TokType.tkCurlyDotLe

tkCurlyDotRi:

• TokType.tkCurlyDotRi

tkCurlyLe:

• TokType.tkCurlyLe

tkCurlyRi:

• TokType.tkCurlyRi

tkCustomLit:

• TokType.tkCustomLit

tkDefer:

• TokType.tkDefer

tkDiscard:

• TokType.tkDiscard

tkDistinct:

• TokType.tkDistinct

tkDiv:

• TokType.tkDiv

tkDo:

• TokType.tkDo

tkDot:

• TokType.tkDot

tkDotDot:

• TokType.tkDotDot

tkElif:

• TokType.tkElif

tkElse:

• TokType.tkElse

tkEnd:

• TokType.tkEnd

tkEnum:

• TokType.tkEnum

tkEof:

• TokType.tkEof

tkEquals:

• TokType.tkEquals

tkError:

• TokType.tkError

tkExcept:

• TokType.tkExcept

tkExport:

• TokType.tkExport

tkFinally:

• TokType.tkFinally

tkFloat:

• TypeKind.tkFloat

tkFloat32Lit:

• TokType.tkFloat32Lit

tkFloat64Lit:

• TokType.tkFloat64Lit

tkFloatLit:

• TokType.tkFloatLit

tkFor:

• TokType.tkFor

tkFrom:

• TokType.tkFrom

tkFunc:

• TokType.tkFunc

tkGStrLit:

• TokType.tkGStrLit

tkGTripleStrLit:

• TokType.tkGTripleStrLit

tkHideableEnd:

• TokType.tkHideableEnd

tkHideableStart:

• TokType.tkHideableStart

tkIf:

• TokType.tkIf

tkImport:

• TokType.tkImport

tkImported:

• TypeKind.tkImported

tkIn:

• TokType.tkIn

tkInclude:

• TokType.tkInclude

tkIndirect:

• TypeKind.tkIndirect

tkInfixOpr:

• TokType.tkInfixOpr

tkInt:

• TypeKind.tkInt

tkInt16Lit:

• TokType.tkInt16Lit

tkInt32Lit:

• TokType.tkInt32Lit

tkInt64Lit:

• TokType.tkInt64Lit

tkInt8Lit:

• TokType.tkInt8Lit

tkInterface:

• TokType.tkInterface

tkIntLit:

• TokType.tkIntLit

tkInvalid:

• TokType.tkInvalid

tkIs:

• TokType.tkIs

tkIsnot:

• TokType.tkIsnot

tkIterator:

• TokType.tkIterator

tkKeywords:

• lexer: tkKeywords

tkLent:

• TypeKind.tkLent

tkLet:

• TokType.tkLet

tkMacro:

• TokType.tkMacro

tkMethod:

• TokType.tkMethod

tkMixin:

• TokType.tkMixin

tkMod:

• TokType.tkMod

tkNil:

• TokType.tkNil

tkNot:

• TokType.tkNot

tkNotin:

• TokType.tkNotin

tkObject:

• TokType.tkObject

tkOf:

• TokType.tkOf

tkOpenArray:

• TypeKind.tkOpenArray

tkOpr:

• TokType.tkOpr

tkOr:

• TokType.tkOr

tkOut:

• TokType.tkOut

tkParDotLe:

• TokType.tkParDotLe

tkParDotRi:

• TokType.tkParDotRi

tkParLe:

• TokType.tkParLe

tkParRi:

• TokType.tkParRi

tkPointer:

• TypeKind.tkPointer

tkPostfixOpr:

• TokType.tkPostfixOpr

tkPrefixOpr:

• TokType.tkPrefixOpr

tkProc:

• TokType.tkProc
• TypeKind.tkProc

tkPtr:

• TokType.tkPtr
• TypeKind.tkPtr

tkRaise:

• TokType.tkRaise

tkRecord:

• TypeKind.tkRecord

tkRef:

• TokType.tkRef
• TypeKind.tkRef

tkReturn:

• TokType.tkReturn

tkRStrLit:

• TokType.tkRStrLit

tkSemiColon:

• TokType.tkSemiColon

tkSeq:

• TypeKind.tkSeq

tkSet:

• TypeKind.tkSet

tkShl:

• TokType.tkShl

tkShr:

• TokType.tkShr

tkSpaces:

• TokType.tkSpaces

tkStatic:

• TokType.tkStatic

tkString:

• TypeKind.tkString

tkStrLit:

• TokType.tkStrLit

tkSymbol:

• TokType.tkSymbol

tkTaggedUnion:

• TypeKind.tkTaggedUnion

tkTemplate:

• TokType.tkTemplate

tkTripleStrLit:

• TokType.tkTripleStrLit

tkTry:

• TokType.tkTry

tkTuple:

• TokType.tkTuple

tkType:

• TokType.tkType

tkUInt:

• TypeKind.tkUInt

tkUInt16Lit:

• TokType.tkUInt16Lit

tkUInt32Lit:

• TokType.tkUInt32Lit

tkUInt64Lit:

• TokType.tkUInt64Lit

tkUInt8Lit:

• TokType.tkUInt8Lit

tkUIntLit:

• TokType.tkUIntLit

tkUncheckedArray:

• TypeKind.tkUncheckedArray

tkUnion:

• TypeKind.tkUnion

tkUsing:

• TokType.tkUsing

tkVar:

• TokType.tkVar
• TypeKind.tkVar

tkVoid:

• TypeKind.tkVoid

tkWhen:

• TokType.tkWhen

tkWhile:

• TokType.tkWhile

tkXor:

• TokType.tkXor

tkYield:

• TokType.tkYield

TLabel:

• cgendata: TLabel

TLib:

• ast_types: TLib

TLibKind:

• ast_types: TLibKind

TLineInfo:

• lineinfos: TLineInfo

TLLRepl:

• llstream: TLLRepl

TLLStream:

• llstream: TLLStream

TLLStreamKind:

• llstream: TLLStreamKind

TLoc:

• cgendata: TLoc

TLocKind:

• cgendata: TLocKind

TLockLevel:

• ast_types: TLockLevel

TLookupFlag:

• lookups: TLookupFlag

TMagic:

• ast_types: TMagic

TMatchedConcept:

• semdata: TMatchedConcept

TModel:

• guards: TModel

TNil:

• NilTransition.TNil

TNode:

• ast_types: TNode

TNodeFlag:

• ast_types: TNodeFlag

TNodeFlags:

• ast_types: TNodeFlags

TNodeKind:

• ast_types: TNodeKind

TNodeKinds:

• ast_types: TNodeKinds

TNodePair:

• ast_types: TNodePair

TNodePairSeq:

• ast_types: TNodePairSeq

TNodeSeq:

• ast_types: TNodeSeq

TNodeTable:

• ast_types: TNodeTable

toAbsolute:

• pathutils: toAbsolute(file: string; base: AbsoluteDir): AbsoluteFile

toAbsoluteDir:

• pathutils: toAbsoluteDir(path: string): AbsoluteDir

toBitSet:

• nimsets: toBitSet(conf: ConfigRef; s: PNode): TBitSet
• compat: toBitSet(conf: ConfigRef; s: CgNode): TBitSet

TObjectSeq:

• ast_types: TObjectSeq

TObjectSet:

• ast_types: TObjectSet

toBlockId:

• ccgflow: toBlockId(id: CLabelId): BlockId

toCChar:

• options: toCChar(c: char; result: var string)

toCLabel:

• ccgflow: toCLabel(n: CgNode): CLabelId
• ccgflow: toCLabel(n: CgNode; specifier: Option[CLabelSpecifier]): CLabel

toColumn:

• msgs: toColumn(info: TLineInfo): int

toConstId:

• mirtrees: toConstId(id: DataId): ConstId

toDebugCallableCandidate:

• sigmatch: toDebugCallableCandidate(c: TCandidate): DebugCallableCandidate

toExceptionAst:

• vmdeps: toExceptionAst(name, msg: sink string): PNode

toFieldIndex:

• vmtypes: toFieldIndex(t: PVmType; p: FieldPosition): FieldIndex

toFieldPos:

• vmtypes: toFieldPos(t: PVmType; i: FieldIndex): FieldPosition

toFileIndex:

• ic: toFileIndex(x: LitId; m: PackedModule; config: ConfigRef): FileIndex

toFileIndexCached:

• ic: toFileIndexCached(c: var PackedDecoder; g: PackedModuleGraph; thisModule: int; f: LitId): FileIndex

toFileLineCol:

• msgs: toFileLineCol(conf: ConfigRef; info: TLineInfo): string
• msgs: toFileLineCol(info: InstantiationInfo): string

toFilename:

• options: toFilename(conf: ConfigRef; fileIdx: FileIndex): string
• options: toFilename(conf: ConfigRef; info: TLineInfo): string

toFilenameOption:

• msgs: toFilenameOption(conf: ConfigRef; fileIdx: FileIndex; opt: FilenameOption): string

toFloat64:

• int128: toFloat64(arg: Int128): float64

toFullPath:

• msgs: toFullPath(conf: ConfigRef; fileIdx: FileIndex): string
• msgs: toFullPath(conf: ConfigRef; info: TLineInfo): string

toFullPathConsiderDirty:

• msgs: toFullPathConsiderDirty(conf: ConfigRef; fileIdx: FileIndex): AbsoluteFile
• msgs: toFullPathConsiderDirty(conf: ConfigRef; info: TLineInfo): string

toFuncIndex:

• vmdef: toFuncIndex(x: VmFunctionPtr): FunctionIndex

toFuncPtr:

• vmdef: toFuncPtr(x: FunctionIndex): VmFunctionPtr

toGeneratedFile:

• options: toGeneratedFile(conf: CurrentConf | ConfigRef; path: AbsoluteFile; ext: string): AbsoluteFile

toHex:

• int128: toHex(arg: Int128): string

toHumanStr:

• ast: toHumanStr(kind: TSymKind): string
• ast: toHumanStr(kind: TTypeKind): string

toInstrList:

• ccgflow: toInstrList(stmts: CgNode; isFull: bool): seq[CInstr]

toInt:

• int128: toInt(arg: Int128): int

toInt128:

• int128: toInt128(arg: float64): Int128
• int128: toInt128[T: SomeInteger | bool](arg: T): Int128

toInt16:

• int128: toInt16(arg: Int128): int16

toInt32:

• int128: toInt32(arg: Int128): int32

toInt64:

• int128: toInt64(arg: Int128): int64

toInt64Checked:

• int128: toInt64Checked(arg: Int128; onError: int64): int64

toInt8:

• int128: toInt8(arg: Int128): int8

Token:

• lexer: Token

tokenize:

• sourcemap: tokenize(line: string): (bool, string)

tokKeywordHigh:

• lexer: tokKeywordHigh

tokKeywordLow:

• lexer: tokKeywordLow

TokType:

• lexer: TokType

TokTypes:

• lexer: TokTypes

toLinenumber:

• msgs: toLinenumber(info: TLineInfo): int

toLiterals:

• sem: toLiterals(vals: IntSet; t: PType): seq[PNode]

toMsgFilename:

• msgs: toMsgFilename(conf: ConfigRef; fileIdx: FileIndex): string
• msgs: toMsgFilename(conf: ConfigRef; info: TLineInfo): string

tooBig:

• RodFileError.tooBig

toObject:

• ast: toObject(typ: PType): PType

toObjectFromRefPtrGeneric:

• ast: toObjectFromRefPtrGeneric(typ: PType): PType

toObjFile:

• extccomp: toObjFile(conf: ConfigRef; filename: AbsoluteFile): AbsoluteFile

toPackedGeneratedProcDef:

• ic: toPackedGeneratedProcDef(s: PSym; encoder: var PackedEncoder; m: var PackedModule)

toPackedItemId:

• packed_ast: toPackedItemId(item: int32): PackedItemId

toPackedNode:

• ic: toPackedNode(n: PNode; ir: var PackedTree; c: var PackedEncoder; m: var PackedModule)

toPackedNodeTopLevel:

• ic: toPackedNodeTopLevel(n: PNode; encoder: var PackedEncoder; m: var PackedModule)

toParsedToken:

• ast_parsed_types: toParsedToken(t: Token): ParsedToken

TOpcode:

• vm_enums: TOpcode

topLevelSection:

• RodSection.topLevelSection

toPNode:

• ast: toPNode(parsed: ParsedNode): PNode

toProjPath:

• msgs: toProjPath(conf: ConfigRef; fileIdx: FileIndex): string
• msgs: toProjPath(conf: ConfigRef; info: TLineInfo): string

TOption:

• in_options: TOption

TOptionEntry:

• semdata: TOptionEntry

TOptions:

• in_options: TOptions

toReplaySection:

• RodSection.toReplaySection

toReportLineInfo:

• reports: toReportLineInfo(iinfo: InstantiationInfo): ReportLineInfo
• msgs: toReportLineInfo(conf: ConfigRef; info: TLineInfo): ReportLineInfo

toReportPoint:

• msgs: toReportPoint(conf: ConfigRef; info: TLineInfo): ReportLineInfo

toRodFile:

• options: toRodFile(conf: ConfigRef; f: AbsoluteFile; ext = RodExt): AbsoluteFile

toSlice:

• vmobjects: toSlice(loc: LocHandle): VmSlice
• vmobjects: toSlice(s: VmSeq; elemTyp: PVmType; a: VmAllocator): VmSlice

toSourceMap:

• sourcemap: toSourceMap(node: SourceNode; file: string): SourceMapGenerator

toString:

• ic: toString(tree: PackedTree; n: NodePos; m: PackedModule): string
• ic: toString(tree: PackedTree; n: NodePos; m: PackedModule; nesting: int; result: var string)

toStrMaxPrecision:

• rodutils: toStrMaxPrecision(f: BiggestFloat | float32): string

toStructureList:

• jsflow: toStructureList(stmts: openArray[CgNode]): StructDesc

totalFieldCount:

• vmtypes: totalFieldCount(t: PVmType): int

toTNodeKind:

• ast: toTNodeKind(kind: ParsedNodeKind): TNodeKind

toTreeSet:

• nimsets: toTreeSet(conf: ConfigRef; s: TBitSetView; settype: PType; info: TLineInfo): PNode

toUInt:

• int128: toUInt(arg: Int128): uint

toUInt16:

• int128: toUInt16(arg: Int128): uint16

toUInt32:

• int128: toUInt32(arg: Int128): uint32

toUInt64:

• int128: toUInt64(arg: Int128): uint64

toUInt8:

• int128: toUInt8(arg: Int128): uint8

toValue:

• mirconstr: toValue(id: ConstId; typ: TypeId): Value
• mirconstr: toValue(id: GlobalId; typ: TypeId): Value
• mirconstr: toValue(id: ProcedureId; typ: TypeId): Value
• mirconstr: toValue(kind: range[mnkParam .. mnkLocal]; id: LocalId; typ: TypeId): Value

toVar:

• ast: toVar(typ: PType; kind: TTypeKind; idgen: IdGenerator): PType

TOverloadIter:

• lookups: TOverloadIter

TOverloadIterMode:

• lookups: TOverloadIterMode

TPair:

• ast_types: TPair

TPairSeq:

• ast_types: TPairSeq

TParamsEquality:

• types: TParamsEquality

TPass:

• modulegraphs: TPass

TPassClose:

• modulegraphs: TPassClose

TPassContext:

• modulegraphs: TPassContext

TPassData:

• passes: TPassData

TPassOpen:

• modulegraphs: TPassOpen

TPassProcess:

• modulegraphs: TPassProcess

TPotentialAlias:

• NilTransition.TPotentialAlias

TPreferedDesc:

• types: TPreferedDesc

TProc:

• jsgen: TProc

TProcCon:

• semdata: TProcCon

traceEnterIt:

• debugutils: traceEnterIt(loc: InstantiationInfo; params: StepParams; body: untyped): untyped

TraceHandler:

• vmdef: TraceHandler

traceLeaveIt:

• debugutils: traceLeaveIt(loc: InstantiationInfo; params: StepParams; body: untyped): untyped

traceStepImpl:

• debugutils: traceStepImpl(params: StepParams; stepDirection: DebugSemStepDirection; body: untyped)

trackPosInvalidFileIdx:

• lineinfos: trackPosInvalidFileIdx

trackProc:

• sempass2: trackProc(c: PContext; s: PSym; body: PNode)

trackStmt:

• sempass2: trackStmt(c: PContext; module: PSym; n: PNode; isTopLevel: bool)

Transformation:

• pluginsupport: Transformation

transformBody:

• transf: transformBody(g: ModuleGraph; idgen: IdGenerator; prc: PSym; cache: bool): PNode
• transf: transformBody(g: ModuleGraph; idgen: IdGenerator; prc: PSym; body: PNode): PNode

transformBodyWithCache:

• transf: transformBodyWithCache(g: ModuleGraph; idgen: IdGenerator; prc: PSym): PNode

transformClosureIterator:

• closureiters: transformClosureIterator(g: ModuleGraph; idgen: IdGenerator; fn: PSym; n: PNode): PNode

transformExpr:

• transf: transformExpr(g: ModuleGraph; idgen: IdGenerator; module: PSym; n: PNode): PNode

transformStmt:

• transf: transformStmt(g: ModuleGraph; idgen: IdGenerator; module: PSym; n: PNode): PNode

transitionGenericParamToType:

• ast: transitionGenericParamToType(s: PSym)

transitionIntKind:

• ast: transitionIntKind(n: PNode; kind: range[nkCharLit .. nkUInt64Lit])

transitionNoneToSym:

• ast: transitionNoneToSym(n: PNode)

transitionRoutineSymKind:

• ast: transitionRoutineSymKind(s: PSym; kind: range[skProc .. skTemplate])

transitionSonsKind:

• ast: transitionSonsKind(n: PNode; kind: range[nkDotCall .. nkTupleConstr])
• ast_parsed_types: transitionSonsKind(n: ParsedNode; kind: ParsedNodeKind)

transitionSymKindCommon:

• ast: transitionSymKindCommon(k: TSymKind)

transitionToError:

• ast: transitionToError(s: PSym; err: PNode)

transitionToLet:

• ast: transitionToLet(s: PSym)

translate:

• backends: translate(id: ProcedureId; body: PNode; graph: ModuleGraph; config: BackendConfig; idgen: IdGenerator; env: var MirEnv): MirBody
• compat: translate(t: MirTree; env: MirEnv): CgNode

TranslateCtx:

• proto_mir: TranslateCtx

translateId:

• ic: translateId(id: PackedItemId; g: PackedModuleGraph; thisModule: int; config: ConfigRef): ItemId

TranslationConfig:

• mirgen: TranslationConfig

traverse:

• mirexec: traverse(c: DataFlowGraph; span: Subgraph; start: InstrPos; state: var TraverseState): (DataFlowOpcode, OpValue)

traverseFromExits:

• mirexec: traverseFromExits(c: DataFlowGraph; span: Subgraph; exit: var bool): ( DataFlowOpcode, OpValue)

traverseReverse:

• mirexec: traverseReverse(c: DataFlowGraph; span: Subgraph; start: InstrPos; exit: var bool): (DataFlowOpcode, OpValue)

TraverseState:

• mirexec: TraverseState

trBindGenericParam:

• TTypeRelFlag.trBindGenericParam

trDontBind:

• TTypeRelFlag.trDontBind

TreeChangeset:

• treechangesets: TreeChangeset

treeRepr:

• cgirutils: treeRepr(n: CgNode): string
• utils: treeRepr(tree: MirTree; pos = NodePosition(0)): string
• astrepr: treeRepr(conf: ConfigRef; pnode: ParsedNode; rconf: TReprConf = implicitTReprConf; indent: int = 0): ColText
• astrepr: treeRepr(conf: ConfigRef; id: PIdent; rconf: TReprConf = implicitTReprConf; indent: int = 0): ColText
• astrepr: treeRepr(conf: ConfigRef; pnode: PNode; rconf: TReprConf = implicitTReprConf; indent: int = 0): ColText
• astrepr: treeRepr(conf: ConfigRef; sym: PSym; rconf: TReprConf = implicitTReprConf; indent: int = 0): ColText
• astrepr: treeRepr(conf: ConfigRef; typ: PType; rconf: TReprConf = implicitTReprConf; indent: int = 0): ColText

treeReprAllFields:

• astrepr: treeReprAllFields

TRegister:

• vmdef: TRegister

TRegisterKind:

• vm_enums: TRegisterKind

TRenderFlag:

• renderer: TRenderFlag

TRenderFlags:

• renderer: TRenderFlags

TRenderTok:

• renderer: TRenderTok

TRenderTokSeq:

• renderer: TRenderTokSeq

TReplTypeVars:

• semtypinst: TReplTypeVars

TReprConf:

• astrepr: TReprConf

TReprFlag:

• astrepr: TReprFlag

TResult:

• NilTransition.TResult

trfDescFlag:

• TReprFlag.trfDescFlag

trfIndexVisisted:

• TReprFlag.trfIndexVisisted

trfPackedFields:

• TReprFlag.trfPackedFields

trfReportInfo:

• TReprFlag.trfReportInfo

trfShowDebugLocation:

• TReprFlag.trfShowDebugLocation

trfShowDefaultedFields:

• TReprFlag.trfShowDefaultedFields

trfShowFullSymChoice:

• TReprFlag.trfShowFullSymChoice

trfShowFullSymTypes:

• TReprFlag.trfShowFullSymTypes

trfShowKindTypes:

• TReprFlag.trfShowKindTypes

trfShowNilFields:

• TReprFlag.trfShowNilFields

trfShowNodeComments:

• TReprFlag.trfShowNodeComments

trfShowNodeErrors:

• TReprFlag.trfShowNodeErrors

trfShowNodeFlags:

• TReprFlag.trfShowNodeFlags

trfShowNodeIds:

• TReprFlag.trfShowNodeIds

trfShowNodeLineInfo:

• TReprFlag.trfShowNodeLineInfo

trfShowNodeTypes:

• TReprFlag.trfShowNodeTypes

trfShowSymAlignment:

• TReprFlag.trfShowSymAlignment

trfShowSymAst:

• TReprFlag.trfShowSymAst

trfShowSymBitsize:

• TReprFlag.trfShowSymBitsize

trfShowSymFlags:

• TReprFlag.trfShowSymFlags

trfShowSymId:

• TReprFlag.trfShowSymId

trfShowSymKind:

• TReprFlag.trfShowSymKind

trfShowSymLineInfo:

• TReprFlag.trfShowSymLineInfo

trfShowSymMagic:

• TReprFlag.trfShowSymMagic

trfShowSymName:

• TReprFlag.trfShowSymName

trfShowSymOffset:

• TReprFlag.trfShowSymOffset

trfShowSymOptions:

• TReprFlag.trfShowSymOptions

trfShowSymOwner:

• TReprFlag.trfShowSymOwner

trfShowSymPosition:

• TReprFlag.trfShowSymPosition

trfShowSymTypes:

• TReprFlag.trfShowSymTypes

trfShowTypeAlloc:

• TReprFlag.trfShowTypeAlloc

trfShowTypeAst:

• TReprFlag.trfShowTypeAst

trfShowTypeCallConv:

• TReprFlag.trfShowTypeCallConv

trfShowTypeFlags:

• TReprFlag.trfShowTypeFlags

trfShowTypeId:

• TReprFlag.trfShowTypeId

trfShowTypeOwner:

• TReprFlag.trfShowTypeOwner

trfShowTypeSym:

• TReprFlag.trfShowTypeSym

trfSkipAuxError:

• TReprFlag.trfSkipAuxError

trmacrosSection:

• RodSection.trmacrosSection

trNoCovariance:

• TTypeRelFlag.trNoCovariance

tryDeref:

• vmmemory: tryDeref(heap: VmHeap; slot: HeapSlotHandle): Option[LocHandle]
• vmmemory: tryDeref(heap: VmHeap; slot: HeapSlotHandle; typ: PVmType): Result[LocHandle, DerefFailureCode]

tryGenerateInstance:

• semtypinst: tryGenerateInstance(c: PContext; pt: TIdTable; info: TLineInfo; t: PType): PType

tryReadTo:

• vmconv: tryReadTo[T](src: LocHandle; dst: var set[T]): bool

tryWriteTo:

• vmconv: tryWriteTo[T: enum](v: T; dest: LocHandle; mm: var VmMemoryManager): bool
• vmconv: tryWriteTo[T: SomeSignedInt](v: T; dest: LocHandle; mm: var VmMemoryManager): bool
• vmconv: tryWriteTo[T: SomeUnsignedInt](v: T; dest: LocHandle; mm: var VmMemoryManager): bool
• vmconv: tryWriteTo[T: string](v: T; dest: LocHandle; mm: var VmMemoryManager): bool
• vmconv: tryWriteTo[T: seq](v: T; dest: LocHandle; mm: var VmMemoryManager): bool
• vmconv: tryWriteTo[T: object | tuple](v: T; dest: LocHandle; mm: var VmMemoryManager): bool

TSafe:

• NilTransition.TSafe

TSandboxFlag:

• vmdef: TSandboxFlag

TSandboxFlags:

• vmdef: TSandboxFlags

TScope:

• ast_types: TScope

TSideEffectAnalysis:

• parampatterns: TSideEffectAnalysis

TSpecialWord:

• wordrecg: TSpecialWord

TSpecialWords:

• wordrecg: TSpecialWords

TSrcGen:

• renderer: TSrcGen

TStackFrame:

• vmdef: TStackFrame

TStorageLoc:

• cgendata: TStorageLoc

TStringSeq:

• options: TStringSeq

TStrTable:

• ast_types: TStrTable

TSym:

• ast_types: TSym

TSymFlag:

• ast_types: TSymFlag

TSymFlags:

• ast_types: TSymFlags

TSymKind:

• ast_types: TSymKind

TSymKinds:

• ast_types: TSymKinds

TSystemCC:

• in_options: TSystemCC

TSystemCPU:

• platform: TSystemCPU

TSystemOS:

• platform: TSystemOS

TTabIter:

• astalgo: TTabIter

TType:

• ast_types: TType
• NilTransition.TType

TTypeAllowedFlag:

• ast_types: TTypeAllowedFlag

TTypeAllowedFlags:

• ast_types: TTypeAllowedFlags

TTypeAttachedOp:

• ast_types: TTypeAttachedOp

TTypeCmpFlag:

• types: TTypeCmpFlag

TTypeCmpFlags:

• types: TTypeCmpFlags

TTypeFieldResult:

• types: TTypeFieldResult

TTypeFlag:

• ast_types: TTypeFlag

TTypeFlags:

• ast_types: TTypeFlags

TTypeIter:

• types: TTypeIter

TTypeKind:

• ast_types: TTypeKind

TTypeKinds:

• ast_types: TTypeKinds

TTypeMutator:

• types: TTypeMutator

TTypePredicate:

• types: TTypePredicate

TTypeRelation:

• ast_types: TTypeRelation

TTypeRelFlag:

• sigmatch: TTypeRelFlag

TTypeRelFlags:

• sigmatch: TTypeRelFlags

TTypeSeq:

• ast_types: TTypeSeq
• cgendata: TTypeSeq

TValidBackend:

• in_options: TValidBackend

TVarArg:

• NilTransition.TVarArg

tyAlias:

• TTypeKind.tyAlias

tyAnd:

• TTypeKind.tyAnd

tyAnything:

• TTypeKind.tyAnything

tyArray:

• TTypeKind.tyArray

tyBool:

• TTypeKind.tyBool

tyBuiltInTypeClass:

• TTypeKind.tyBuiltInTypeClass

tyBuiltInTypeClasses:

• ast_types: tyBuiltInTypeClasses

tyChar:

• TTypeKind.tyChar

tyCompositeTypeClass:

• TTypeKind.tyCompositeTypeClass

tyCstring:

• TTypeKind.tyCstring

tyDistinct:

• TTypeKind.tyDistinct

tyEmpty:

• TTypeKind.tyEmpty

tyEnum:

• TTypeKind.tyEnum

tyError:

• ast_types: tyError

tyFloat:

• TTypeKind.tyFloat

tyFloat32:

• TTypeKind.tyFloat32

tyFloat64:

• TTypeKind.tyFloat64

tyForward:

• TTypeKind.tyForward

tyFromExpr:

• TTypeKind.tyFromExpr

tyGenericBody:

• TTypeKind.tyGenericBody

tyGenericInst:

• TTypeKind.tyGenericInst

tyGenericInvocation:

• TTypeKind.tyGenericInvocation

tyGenericLike:

• sem: tyGenericLike

tyGenericParam:

• TTypeKind.tyGenericParam

tyInferred:

• TTypeKind.tyInferred

tyInt:

• TTypeKind.tyInt

tyInt16:

• TTypeKind.tyInt16

tyInt32:

• TTypeKind.tyInt32

tyInt64:

• TTypeKind.tyInt64

tyInt8:

• TTypeKind.tyInt8

tyLent:

• TTypeKind.tyLent

tyMagicGenerics:

• sem: tyMagicGenerics

tyMetaTypes:

• ast_types: tyMetaTypes

tyNil:

• TTypeKind.tyNil

tyNone:

• TTypeKind.tyNone

tyNot:

• TTypeKind.tyNot

tyObject:

• TTypeKind.tyObject

tyOpenArray:

• TTypeKind.tyOpenArray

tyOr:

• TTypeKind.tyOr

tyOrdinal:

• TTypeKind.tyOrdinal

typ:

• checked_ast: typ(x: CheckedAst): PType
• packed_ast: typ(n: NodePos): PackedItemId
• mirconstr: typ(val: Value): TypeId
• proto_mir: typ(n: seq[ProtoItem]): PType

typ=:

• checked_ast: typ=(x: var CheckedAst; typ: PType)

typeAllowed:

• typeallowed: typeAllowed(t: PType; kind: TSymKind; c: PContext; flags: TTypeAllowedFlags = {}): PType

typeAllowedOrError:

• typeallowed: typeAllowedOrError(t: PType; kind: TSymKind; c: PContext; def: PNode; flags: TTypeAllowedFlags = {}): PType

TypeCache:

• cgendata: TypeCache

TypeCacheWithOwner:

• cgendata: TypeCacheWithOwner

typeCompleted:

• ast_query: typeCompleted(s: PSym)

typedescInst:

• ast_types: typedescInst

typedescPtrs:

• ast_types: typedescPtrs

TypeEnv:

• mirtypes: TypeEnv

TypeHeader:

• mirtypes: TypeHeader

TypeId:

• mirtrees: TypeId

TypeInfoCache:

• vmdef: TypeInfoCache

typeInfoSection:

• RodSection.typeInfoSection

typeInstCacheItems:

• modulegraphs: typeInstCacheItems(g: ModuleGraph; s: PSym): PType

typeInstCacheSection:

• RodSection.typeInstCacheSection

TypeKind:

• mirtypes: TypeKind

typeLit:

• mirconstr: typeLit(t: TypeId): Value

typeMismatch:

• types: typeMismatch(conf: ConfigRef; info: TLineInfo; formal, actual: PType; n: PNode): PNode
• types: typeMismatch(formal, actual: PType): SemTypeMismatch
• types: typeMismatch(formal: set[TTypeKind]; actual: PType): SemTypeMismatch

typePragmas:

• pragmas: typePragmas

typeRel:

• sigmatch: typeRel(c: var TCandidate; f, aOrig: PType; flags: TTypeRelFlags = {}): TTypeRelation

types:

• vmdef: types(c: TCtx): untyped

typesSection:

• RodSection.typesSection

TypeSym:

• mirtypes: TypeSym

TypeTable:

• typemaps: TypeTable
• vmdef: TypeTable

TypeTableEntry:

• vmdef: TypeTableEntry

typeToStr:

• typesrenderer: typeToStr

typeToString:

• typesrenderer: typeToString(typ: PType; prefer: TPreferedDesc = preferName): string

tyPointer:

• TTypeKind.tyPointer

tyProc:

• TTypeKind.tyProc

tyProxy:

• TTypeKind.tyProxy

typSym:

• astmsgs: typSym(t: PType): PSym

tyPtr:

• TTypeKind.tyPtr

tyPureObject:

• ast_types: tyPureObject

tyRange:

• TTypeKind.tyRange

tyRef:

• TTypeKind.tyRef

tySequence:

• TTypeKind.tySequence

tySet:

• TTypeKind.tySet

tySink:

• TTypeKind.tySink

tyStatic:

• TTypeKind.tyStatic

tyString:

• TTypeKind.tyString

tyTuple:

• TTypeKind.tyTuple

tyTypeClasses:

• ast_types: tyTypeClasses

tyTyped:

• TTypeKind.tyTyped

tyTypeDesc:

• TTypeKind.tyTypeDesc

tyUInt:

• TTypeKind.tyUInt

tyUInt16:

• TTypeKind.tyUInt16

tyUInt32:

• TTypeKind.tyUInt32

tyUInt64:

• TTypeKind.tyUInt64

tyUInt8:

• TTypeKind.tyUInt8

tyUncheckedArray:

• TTypeKind.tyUncheckedArray

tyUnknown:

• ast_types: tyUnknown

tyUnknownTypes:

• ast_types: tyUnknownTypes

tyUntyped:

• TTypeKind.tyUntyped

tyUserDefinedGenerics:

• sem: tyUserDefinedGenerics

tyUserTypeClass:

• TTypeKind.tyUserTypeClass

tyUserTypeClasses:

• ast_types: tyUserTypeClasses

tyUserTypeClassInst:

• TTypeKind.tyUserTypeClassInst

tyVar:

• TTypeKind.tyVar

tyVarargs:

• TTypeKind.tyVarargs

tyVoid:

• TTypeKind.tyVoid

UInt16Type:

• mirtypes: UInt16Type

UInt32Type:

• mirtypes: UInt32Type

UInt64Type:

• mirtypes: UInt64Type

UInt8Type:

• mirtypes: UInt8Type

UnaryOps:

• mirtrees: UnaryOps

undefined:

• ModuleStatus.undefined

undefSymbol:

• options: undefSymbol(conf: ConfigRef; symbol: string)

unicodeOperators:

• Feature.unicodeOperators

unionSets:

• nimsets: unionSets(conf: ConfigRef; a, b: PNode): PNode

uniqueModuleName:

• msgs: uniqueModuleName(conf: ConfigRef; fid: FileIndex): string

unknownLineInfo:

• lineinfos: unknownLineInfo

UnknownLockLevel:

• ast_query: UnknownLockLevel

unpackDiscr:

• vmobjects: unpackDiscr(v: BiggestInt; numBits: Natural): tuple[value: int, index: int]

unpackedConvDesc:

• vmdef: unpackedConvDesc(info: uint16): tuple[op: NumericConvKind, dstbytes, srcbytes: int]

Unreachable:

• Nilability.Unreachable

unreachable:

• idioms: unreachable()
• idioms: unreachable(msg: string)
• idioms: unreachable(e: enum)

unsafeDeref:

• vmmemory: unsafeDeref(heap: VmHeap; slot: HeapSlotHandle): LocHandle

UnspecifiedLockLevel:

• ast_query: UnspecifiedLockLevel

upName:

• lambdalifting: upName

use:

• mirconstr: use(bu: var MirBuilder; val: sink Value)

useColor:

• options: useColor(conf: ConfigRef): bool

useConst:

• cgen: useConst(m: BModule; id: ConstId)

UsedBuildParams:

• reports_internal: UsedBuildParams
• main: UsedBuildParams

useEffectSystem:

• options: useEffectSystem

usesThreadVars:

• CodegenFlag.usesThreadVars

useWriteTracking:

• options: useWriteTracking

usizeType:

• mirtypes: usizeType(env: TypeEnv): TypeId

v2Sf:

• SymbolFilesOption.v2Sf

validate:

• vmjit_checks: validate(env: MirEnv; n: PNode): Result[void, VmGenDiag]

validBackends:

• in_options: validBackends

Value:

• mirconstr: Value

values:

• containers: values[K, V](m: SeqMap[K, V]): lent V

variantFieldIndices:

• vmobjects: variantFieldIndices(src: VmMemoryRegion; typ: PVmType; branch: uint32 = 0'u32): FieldIndex

VariantFieldIterCtx:

• vmobjects: VariantFieldIterCtx

variantFields:

• vmobjects: variantFields(src: VmMemoryRegion; typ: PVmType; branch: uint32 = 0'u32): (int, PVmType)

varPragmas:

• pragmas: varPragmas

verbosePass:

• passaux: verbosePass

verboseTReprConf:

• astrepr: verboseTReprConf

Version:

• nimblecmd: Version
• nversion: Version

VersionAsString:

• nversion: VersionAsString

versionSection:

• RodSection.versionSection

views:

• Feature.views

ViewTypeKind:

• types: ViewTypeKind

VmAllocator:

• vmdef: VmAllocator

VmArgs:

• vmdef: VmArgs

vmAssert:

• vmerrors: vmAssert(cond: bool)

VmCallback:

• vmdef: VmCallback

VmCell:

• vmdef: VmCell

VmConstant:

• vmdef: VmConstant

VmError:

• vmerrors: VmError

VmEvent:

• vmdef: VmEvent

VmEventKind:

• vmdef: VmEventKind

VmEventKindAccessError:

• vmdef: VmEventKindAccessError

vmEventToAstDiagVmError:

• vm: vmEventToAstDiagVmError(evt: VmEvent): AstDiagVmError

vmEvtAccessNoLocation:

• VmEventKind.vmEvtAccessNoLocation

vmEvtAccessOutOfBounds:

• VmEventKind.vmEvtAccessOutOfBounds

vmEvtAccessTypeMismatch:

• VmEventKind.vmEvtAccessTypeMismatch

vmEvtArgNodeNotASymbol:

• VmEventKind.vmEvtArgNodeNotASymbol

vmEvtCacheKeyAlreadyExists:

• VmEventKind.vmEvtCacheKeyAlreadyExists

vmEvtCannotAddChild:

• VmEventKind.vmEvtCannotAddChild

vmEvtCannotCast:

• VmEventKind.vmEvtCannotCast

vmEvtCannotCreateNode:

• VmEventKind.vmEvtCannotCreateNode

vmEvtCannotGetChild:

• VmEventKind.vmEvtCannotGetChild

vmEvtCannotModifyTypechecked:

• VmEventKind.vmEvtCannotModifyTypechecked

vmEvtCannotSetChild:

• VmEventKind.vmEvtCannotSetChild

vmEvtDivisionByConstZero:

• VmEventKind.vmEvtDivisionByConstZero

vmEvtErrInternal:

• VmEventKind.vmEvtErrInternal

vmEvtFieldNotFound:

• VmEventKind.vmEvtFieldNotFound

vmEvtFieldUnavailable:

• VmEventKind.vmEvtFieldUnavailable

vmEvtIllegalConv:

• VmEventKind.vmEvtIllegalConv

vmEvtIllegalConvFromXToY:

• VmEventKind.vmEvtIllegalConvFromXToY

vmEvtIndexError:

• VmEventKind.vmEvtIndexError

vmEvtMissingCacheKey:

• VmEventKind.vmEvtMissingCacheKey

vmEvtNilAccess:

• VmEventKind.vmEvtNilAccess

vmEvtNodeNotAProcSymbol:

• VmEventKind.vmEvtNodeNotAProcSymbol

vmEvtNodeNotASymbol:

• VmEventKind.vmEvtNodeNotASymbol

vmEvtNotAField:

• VmEventKind.vmEvtNotAField

vmEvtNoType:

• VmEventKind.vmEvtNoType

vmEvtOpcParseExpectedExpression:

• VmEventKind.vmEvtOpcParseExpectedExpression

vmEvtOutOfRange:

• VmEventKind.vmEvtOutOfRange

vmEvtOverOrUnderflow:

• VmEventKind.vmEvtOverOrUnderflow

vmEvtTooManyIterations:

• VmEventKind.vmEvtTooManyIterations

vmEvtUnhandledException:

• VmEventKind.vmEvtUnhandledException

vmEvtUserError:

• VmEventKind.vmEvtUserError

VmExecTrace:

• vmdef: VmExecTrace

VmExecTraceKind:

• vmdef: VmExecTraceKind

VmFunctionPtr:

• vmdef: VmFunctionPtr

VmGenDiag:

• vmdef: VmGenDiag

vmGenDiagCannotCallMethod:

• VmGenDiagKind.vmGenDiagCannotCallMethod

vmGenDiagCannotCast:

• VmGenDiagKind.vmGenDiagCannotCast

vmGenDiagCannotEvaluateAtComptime:

• VmGenDiagKind.vmGenDiagCannotEvaluateAtComptime

vmGenDiagCannotImportc:

• VmGenDiagKind.vmGenDiagCannotImportc

vmGenDiagCodeGenUnhandledMagic:

• VmGenDiagKind.vmGenDiagCodeGenUnhandledMagic

VmGenDiagKind:

• vmdef: VmGenDiagKind

VmGenDiagKindAstRelated:

• vmdef: VmGenDiagKindAstRelated

VmGenDiagKindMagicRelated:

• vmdef: VmGenDiagKindMagicRelated

VmGenDiagKindSymRelated:

• vmdef: VmGenDiagKindSymRelated

vmGenDiagMissingImportcCompleteStruct:

• VmGenDiagKind.vmGenDiagMissingImportcCompleteStruct

vmGenDiagNotUnused:

• VmGenDiagKind.vmGenDiagNotUnused

vmGenDiagToAstDiagVmGenError:

• vmgen: vmGenDiagToAstDiagVmGenError(diag: VmGenDiag): AstDiagVmGenError

vmGenDiagToLegacyReport:

• vmlegacy: vmGenDiagToLegacyReport(diag: VmGenDiag): Report

vmGenDiagToLegacyVmReport:

• vmlegacy: vmGenDiagToLegacyVmReport(diag: VmGenDiag): VMReport

vmGenDiagTooLargeOffset:

• VmGenDiagKind.vmGenDiagTooLargeOffset

vmGenDiagTooManyRegistersRequired:

• VmGenDiagKind.vmGenDiagTooManyRegistersRequired

VmGenResult:

• vmgen: VmGenResult

VmHeap:

• vmdef: VmHeap

VmMemoryManager:

• vmdef: VmMemoryManager

VmMemoryRegion:

• vmdef: VmMemoryRegion

VmMemPointer:

• vmdef: VmMemPointer

vmopsDanger:

• Feature.vmopsDanger

VmRawStackTrace:

• vmdef: VmRawStackTrace

VMReport:

• reports_vm: VMReport

VMReportKind:

• report_enums: VMReportKind

VmSeq:

• vmdef: VmSeq

VmSlice:

• vmdef: VmSlice

VmStackTrace:

• vmdef: VmStackTrace

VmString:

• vmdef: VmString

VmThread:

• vm: VmThread

vmTraceFull:

• VmExecTraceKind.vmTraceFull

vmTraceMin:

• VmExecTraceKind.vmTraceMin

VmType:

• vmdef: VmType

VmTypeId:

• vmdef: VmTypeId

VmTypeInfo:

• vmdef: VmTypeInfo

VmTypeMismatch:

• vmdef: VmTypeMismatch

VmTypeRel:

• vmtypes: VmTypeRel

vmUnreachable:

• vmerrors: vmUnreachable(msg: sink string)

VoidType:

• mirtypes: VoidType

VT:

• nimlexbase: VT

vtrSame:

• VmTypeRel.vtrSame

vtrSub:

• VmTypeRel.vtrSub

vtrSuper:

• VmTypeRel.vtrSuper

vtrUnrelated:

• VmTypeRel.vtrUnrelated

wAcyclic:

• TSpecialWord.wAcyclic

wAddr:

• TSpecialWord.wAddr

wAlign:

• TSpecialWord.wAlign

wAlignas:

• TSpecialWord.wAlignas

wAlignof:

• TSpecialWord.wAlignof

walk:

• sourcemap: walk(node: SourceNode; fn: proc (line: string; original: SourceNode))

walkErrors:

• errorhandling: walkErrors(config: ConfigRef; n: PNode): PNode

wAnd:

• TSpecialWord.wAnd

wantConsumeable:

• proto_mir: wantConsumeable(e: var seq[ProtoItem])

wantMainModule:

• modules: wantMainModule(conf: ConfigRef)

wantOwning:

• proto_mir: wantOwning(e: var seq[ProtoItem]; forceTemp: bool)

wantPure:

• proto_mir: wantPure(e: var seq[ProtoItem])

wantShallow:

• proto_mir: wantShallow(e: var seq[ProtoItem])

wantStable:

• proto_mir: wantStable(e: var seq[ProtoItem])

wantValue:

• proto_mir: wantValue(e: var seq[ProtoItem])

warningAsErrors:

• options: warningAsErrors(conf: ConfigRef): ReportKinds

warningAsErrors=:

• options: warningAsErrors=(conf: ConfigRef; nset: ReportKinds)

wAs:

• TSpecialWord.wAs

wAsm:

• TSpecialWord.wAsm

wAsmNoStackFrame:

• TSpecialWord.wAsmNoStackFrame

wAssertions:

• TSpecialWord.wAssertions

wAuto:

• TSpecialWord.wAuto

wBase:

• TSpecialWord.wBase

wBind:

• TSpecialWord.wBind

wBitsize:

• TSpecialWord.wBitsize

wBlock:

• TSpecialWord.wBlock

wBool:

• TSpecialWord.wBool

wBoolDefine:

• TSpecialWord.wBoolDefine

wBorrow:

• TSpecialWord.wBorrow

wBoundChecks:

• TSpecialWord.wBoundChecks

wBreak:

• TSpecialWord.wBreak

wByCopy:

• TSpecialWord.wByCopy

wByRef:

• TSpecialWord.wByRef

wCallconv:

• TSpecialWord.wCallconv

wCase:

• TSpecialWord.wCase

wCast:

• TSpecialWord.wCast

wCatch:

• TSpecialWord.wCatch

wCdecl:

• TSpecialWord.wCdecl

wChar:

• TSpecialWord.wChar

wChar16_t:

• TSpecialWord.wChar16_t

wChar32_t:

• TSpecialWord.wChar32_t

wChecks:

• TSpecialWord.wChecks

wClass:

• TSpecialWord.wClass

wClosure:

• TSpecialWord.wClosure

wCodegenDecl:

• TSpecialWord.wCodegenDecl

wColon:

• TSpecialWord.wColon

wColonColon:

• TSpecialWord.wColonColon

wCompile:

• TSpecialWord.wCompile

wCompilerProc:

• TSpecialWord.wCompilerProc

wCompileTime:

• TSpecialWord.wCompileTime

wCompl:

• TSpecialWord.wCompl

wCompleteStruct:

• TSpecialWord.wCompleteStruct

wComputedGoto:

• TSpecialWord.wComputedGoto

wConcept:

• TSpecialWord.wConcept

wConst:

• TSpecialWord.wConst

wConst_cast:

• TSpecialWord.wConst_cast

wConstexpr:

• TSpecialWord.wConstexpr

wConstructor:

• TSpecialWord.wConstructor

wContinue:

• TSpecialWord.wContinue

wConverter:

• TSpecialWord.wConverter

wCore:

• TSpecialWord.wCore

wCursor:

• TSpecialWord.wCursor

wDebugger:

• TSpecialWord.wDebugger

wDecltype:

• TSpecialWord.wDecltype

wDefault:

• TSpecialWord.wDefault

wDefer:

• TSpecialWord.wDefer

wDefine:

• TSpecialWord.wDefine

wDelete:

• TSpecialWord.wDelete

wDeprecated:

• TSpecialWord.wDeprecated

wDestructor:

• TSpecialWord.wDestructor

wDirty:

• TSpecialWord.wDirty

wDiscard:

• TSpecialWord.wDiscard

wDiscardable:

• TSpecialWord.wDiscardable

wDistinct:

• TSpecialWord.wDistinct

wDiv:

• TSpecialWord.wDiv

wDo:

• TSpecialWord.wDo

wDot:

• TSpecialWord.wDot

wDotDot:

• TSpecialWord.wDotDot

wDouble:

• TSpecialWord.wDouble

wDynamic_cast:

• TSpecialWord.wDynamic_cast

wDynlib:

• TSpecialWord.wDynlib

weakLeValue:

• astalgo: weakLeValue(a, b: PNode): TImplication

wEffects:

• TSpecialWord.wEffects

wEffectsOf:

• TSpecialWord.wEffectsOf

wElif:

• TSpecialWord.wElif

wElse:

• TSpecialWord.wElse

wEmit:

• TSpecialWord.wEmit

wEnd:

• TSpecialWord.wEnd

wEnum:

• TSpecialWord.wEnum

wEquals:

• TSpecialWord.wEquals

wError:

• TSpecialWord.wError

wExcept:

• TSpecialWord.wExcept

wExperimental:

• TSpecialWord.wExperimental

wExplain:

• TSpecialWord.wExplain

wExplicit:

• TSpecialWord.wExplicit

wExport:

• TSpecialWord.wExport

wExportc:

• TSpecialWord.wExportc

wExportNims:

• TSpecialWord.wExportNims

wExtern:

• TSpecialWord.wExtern

wFalse:

• TSpecialWord.wFalse

wFastcall:

• TSpecialWord.wFastcall

wFatal:

• TSpecialWord.wFatal

wFieldChecks:

• TSpecialWord.wFieldChecks

wFinal:

• TSpecialWord.wFinal

wFinally:

• TSpecialWord.wFinally

wFloat:

• TSpecialWord.wFloat

wFloatChecks:

• TSpecialWord.wFloatChecks

wFor:

• TSpecialWord.wFor

wFriend:

• TSpecialWord.wFriend

wFrom:

• TSpecialWord.wFrom

wFunc:

• TSpecialWord.wFunc

wGcSafe:

• TSpecialWord.wGcSafe

wGensym:

• TSpecialWord.wGensym

wGlobal:

• TSpecialWord.wGlobal

wGoto:

• TSpecialWord.wGoto

wGuard:

• TSpecialWord.wGuard

wHeader:

• TSpecialWord.wHeader

whichAlias:

• parampatterns: whichAlias(p: PSym): TAliasRequest

whichKeyword:

• idents: whichKeyword(id: PIdent): TSpecialWord

whichPragma:

• trees: whichPragma(n: PNode): TSpecialWord

wHint:

• TSpecialWord.wHint

wHintAsError:

• TSpecialWord.wHintAsError

wHints:

• TSpecialWord.wHints

wholeCode:

• jsgen: wholeCode(globals: PGlobals): Rope

wIf:

• TSpecialWord.wIf

wImmediate:

• TSpecialWord.wImmediate

wImplicitStatic:

• TSpecialWord.wImplicitStatic

wImport:

• TSpecialWord.wImport

wImportc:

• TSpecialWord.wImportc

wImportCompilerProc:

• TSpecialWord.wImportCompilerProc

wImportHidden:

• TSpecialWord.wImportHidden

wImportJs:

• TSpecialWord.wImportJs

wIn:

• TSpecialWord.wIn

wInclude:

• TSpecialWord.wInclude

wIncompleteStruct:

• TSpecialWord.wIncompleteStruct

wInfChecks:

• TSpecialWord.wInfChecks

wInheritable:

• TSpecialWord.wInheritable

wInject:

• TSpecialWord.wInject

wInline:

• TSpecialWord.wInline

wInOut:

• TSpecialWord.wInOut

wInt:

• TSpecialWord.wInt

wIntDefine:

• TSpecialWord.wIntDefine

wInterface:

• TSpecialWord.wInterface

wInvalid:

• TSpecialWord.wInvalid

wIs:

• TSpecialWord.wIs

wIsnot:

• TSpecialWord.wIsnot

wIterator:

• TSpecialWord.wIterator

withFront:

• mirconstr: withFront(bu: var MirBuilder; body: untyped)

withInfo:

• ast: withInfo(n: PNode; info: TLineInfo): PNode

withPackageName:

• options: withPackageName(conf: ConfigRef; path: AbsoluteFile): AbsoluteFile

wLet:

• TSpecialWord.wLet

wLib:

• TSpecialWord.wLib

wLine:

• TSpecialWord.wLine

wLineDir:

• TSpecialWord.wLineDir

wLineTrace:

• TSpecialWord.wLineTrace

wLink:

• TSpecialWord.wLink

wLinksys:

• TSpecialWord.wLinksys

wLocalPassc:

• TSpecialWord.wLocalPassc

wLocks:

• TSpecialWord.wLocks

wLong:

• TSpecialWord.wLong

wMacro:

• TSpecialWord.wMacro

wMagic:

• TSpecialWord.wMagic

wMemTracker:

• TSpecialWord.wMemTracker

wMethod:

• TSpecialWord.wMethod

wMinus:

• TSpecialWord.wMinus

wMixin:

• TSpecialWord.wMixin

wMod:

• TSpecialWord.wMod

wMutable:

• TSpecialWord.wMutable

wNamespace:

• TSpecialWord.wNamespace

wNanChecks:

• TSpecialWord.wNanChecks

wNew:

• TSpecialWord.wNew

wNil:

• TSpecialWord.wNil

wNilChecks:

• TSpecialWord.wNilChecks

wNimcall:

• TSpecialWord.wNimcall

wNoalias:

• TSpecialWord.wNoalias

wNoconv:

• TSpecialWord.wNoconv

wNodecl:

• TSpecialWord.wNodecl

wNoDestroy:

• TSpecialWord.wNoDestroy

wNoexcept:

• TSpecialWord.wNoexcept

wNoInit:

• TSpecialWord.wNoInit

wNoInline:

• TSpecialWord.wNoInline

wNoreturn:

• TSpecialWord.wNoreturn

wNoRewrite:

• TSpecialWord.wNoRewrite

wNoSideEffect:

• TSpecialWord.wNoSideEffect

wNosinks:

• TSpecialWord.wNosinks

wNot:

• TSpecialWord.wNot

wNotin:

• TSpecialWord.wNotin

wNullptr:

• TSpecialWord.wNullptr

wObjChecks:

• TSpecialWord.wObjChecks

wObject:

• TSpecialWord.wObject

wOf:

• TSpecialWord.wOf

wOff:

• TSpecialWord.wOff

wOn:

• TSpecialWord.wOn

wOneWay:

• TSpecialWord.wOneWay

wOperator:

• TSpecialWord.wOperator

wOptimization:

• TSpecialWord.wOptimization

wOr:

• TSpecialWord.wOr

wordExcess:

• vmdef: wordExcess

wOut:

• TSpecialWord.wOut

wOverflowChecks:

• TSpecialWord.wOverflowChecks

wOverride:

• TSpecialWord.wOverride

wPackage:

• TSpecialWord.wPackage

wPacked:

• TSpecialWord.wPacked

wPassc:

• TSpecialWord.wPassc

wPassl:

• TSpecialWord.wPassl

wPop:

• TSpecialWord.wPop

wPragma:

• TSpecialWord.wPragma

wPrivate:

• TSpecialWord.wPrivate

wProc:

• TSpecialWord.wProc

wProcVar:

• TSpecialWord.wProcVar

wProfiler:

• TSpecialWord.wProfiler

wProtected:

• TSpecialWord.wProtected

wPtr:

• TSpecialWord.wPtr

wPublic:

• TSpecialWord.wPublic

wPure:

• TSpecialWord.wPure

wPush:

• TSpecialWord.wPush

wRaise:

• TSpecialWord.wRaise

wRaises:

• TSpecialWord.wRaises

wRangeChecks:

• TSpecialWord.wRangeChecks

wrap:

• reports: wrap[R: ReportTypes](iinfo: InstantiationInfo; rep: sink R): Report
• reports: wrap(rep: sink BackendReport): Report
• reports: wrap(rep: sink CmdReport): Report
• reports: wrap(rep: sink DebugReport): Report
• reports: wrap(rep: sink ExternalReport): Report
• reports: wrap(rep: sink InternalReport): Report
• reports: wrap(rep: sink LexerReport): Report
• reports: wrap(rep: sink ParserReport): Report
• reports: wrap[R: ReportTypes](rep: sink R; iinfo: InstantiationInfo): Report
• reports: wrap[R: ReportTypes](rep: sink R; iinfo: InstantiationInfo; point: TLineInfo): Report
• reports: wrap[R: ReportTypes](rep: sink R; iinfo: ReportLineInfo; point: TLineInfo): Report
• reports: wrap(rep: sink SemReport): Report
• reports: wrap(rep: sink VMReport): Report
• reports: wrap(rep: ReportTypes): Report
• cli_reporter: wrap(conf: ConfigRef; str: string; color: ForegroundColor; style: set[Style] = {}): string

wrapAlias:

• mirconstr: wrapAlias(bu: var MirBuilder; t: TypeId; body: untyped): Value

wrapError:

• errorhandling: wrapError(conf: ConfigRef; wrongNodeContainer: PNode): PNode

wrapIfErrorInSubTree:

• errorhandling: wrapIfErrorInSubTree(conf: ConfigRef; wrongNodeContainer: PNode): PNode

wrapInComesFrom:

• evaltempl: wrapInComesFrom(info: TLineInfo; sym: PSym; res: PNode): PNode

wrapMutAlias:

• mirconstr: wrapMutAlias(bu: var MirBuilder; t: TypeId; body: untyped): Value

wrapTemp:

• mirconstr: wrapTemp(bu: var MirBuilder; t: TypeId; body: untyped): Value

wReads:

• TSpecialWord.wReads

wRef:

• TSpecialWord.wRef

wRegister:

• TSpecialWord.wRegister

wReinterpret_cast:

• TSpecialWord.wReinterpret_cast

wRequiresInit:

• TSpecialWord.wRequiresInit

wRestrict:

• TSpecialWord.wRestrict

wReturn:

• TSpecialWord.wReturn

writabilityKind:

• options: writabilityKind(conf: ConfigRef; r: Report): ReportWritabilityKind

write:

• commands: write(conf: ConfigRef; dest: static[CmdOutputKind]; msg: string)
• options: write(conf: ConfigRef; args: varargs[string, `$`])

writeDepsFile:

• depfiles: writeDepsFile(g: ModuleGraph)

writeDisabled:

• ReportWritabilityKind.writeDisabled

writeDiscrField:

• vmobjects: writeDiscrField(loc: LocHandle; owner: PVmType; idx: FieldIndex; value, index: Natural)

writeEnabled:

• ReportWritabilityKind.writeEnabled

writeFile:

• pathutils: writeFile(x: AbsoluteFile; content: string)

writeFloat:

• vmobjects: writeFloat(h: LocHandle; f: BiggestFloat)

writeFloat32:

• vmobjects: writeFloat32(h: LocHandle; f: float32)
• vmobjects: writeFloat32(h: VmMemPointer; f: float32)

writeFloat64:

• vmobjects: writeFloat64(h: LocHandle; f: float64)
• vmobjects: writeFloat64(h: VmMemPointer; f: float64)

writeForceEnabled:

• ReportWritabilityKind.writeForceEnabled

writeGccDepfile:

• depfiles: writeGccDepfile(depfile: File; target: string; paths: openArray[string])

writeHook:

• options: writeHook(conf: ConfigRef; msg: string; flags: MsgFlags = {})

writeInt:

• vmobjects: writeInt(r: var VmMemoryRegion; val: BiggestInt)

writeJsonBuildInstructions:

• extccomp: writeJsonBuildInstructions(conf: ConfigRef)

writeln:

• commands: writeln(conf: ConfigRef; dest: static[CmdOutputKind]; msg: string)
• options: writeln(conf: ConfigRef; args: varargs[string, `$`])

writelnHook:

• options: writelnHook(conf: ConfigRef; msg: string; flags: MsgFlags = {})

writeMangledName:

• ndi: writeMangledName(f: NdiFile; s: PSym; n: string; conf: ConfigRef)
• ndi: writeMangledName(f: NdiFile; info: TLineInfo; orig: PIdent; n: string; conf: ConfigRef; id = 0)

writeMapping:

• extccomp: writeMapping(conf: ConfigRef; symbolMapping: Rope)

writeMatches:

• sigmatch: writeMatches(c: TCandidate)

writeOnlySf:

• SymbolFilesOption.writeOnlySf

writeOutput:

• docgen: writeOutput(d: PDoc; useWarning = false; groupedToc = false)

writeOutputJson:

• docgen: writeOutputJson(d: PDoc; useWarning = false)

writeRope:

• ropes: writeRope(f: File; r: Rope)
• ropes: writeRope(head: Rope; filename: AbsoluteFile): bool

writeRopeIfNotEqual:

• ropes: writeRopeIfNotEqual(r: Rope; filename: AbsoluteFile): bool

writeTo:

• vmconv: writeTo[T](v: T; dest: LocHandle; mm: var VmMemoryManager)

writeToFile:

• packed_env: writeToFile(p: PackedEnv; file: AbsoluteFile): RodFileError

writeUInt:

• vmobjects: writeUInt(h: LocHandle; val: BiggestInt)
• vmobjects: writeUInt(r: var VmMemoryRegion; val: BiggestInt)

writeUsage:

• commands: writeUsage(conf: ConfigRef)

wrongHeader:

• RodFileError.wrongHeader

wrongNodePos:

• ast_query: wrongNodePos

wrongRedefinition:

• lookups: wrongRedefinition(c: PContext; info: TLineInfo; s: PSym; conflictsWith: PSym)

wrongSection:

• RodFileError.wrongSection

wSafecall:

• TSpecialWord.wSafecall

wSafecode:

• TSpecialWord.wSafecode

wShl:

• TSpecialWord.wShl

wShort:

• TSpecialWord.wShort

wShr:

• TSpecialWord.wShr

wSideEffect:

• TSpecialWord.wSideEffect

wSigned:

• TSpecialWord.wSigned

wSinkInference:

• TSpecialWord.wSinkInference

wSize:

• TSpecialWord.wSize

wSizeof:

• TSpecialWord.wSizeof

wStackTrace:

• TSpecialWord.wStackTrace

wStar:

• TSpecialWord.wStar

wStatic:

• TSpecialWord.wStatic

wStatic_assert:

• TSpecialWord.wStatic_assert

wStaticBoundchecks:

• TSpecialWord.wStaticBoundchecks

wStatic_cast:

• TSpecialWord.wStatic_cast

wStdcall:

• TSpecialWord.wStdcall

wStdErr:

• TSpecialWord.wStdErr

wStdIn:

• TSpecialWord.wStdIn

wStdOut:

• TSpecialWord.wStdOut

wStrDefine:

• TSpecialWord.wStrDefine

wStruct:

• TSpecialWord.wStruct

wStyleChecks:

• TSpecialWord.wStyleChecks

wSubsChar:

• TSpecialWord.wSubsChar

wSwitch:

• TSpecialWord.wSwitch

wSyscall:

• TSpecialWord.wSyscall

wTags:

• TSpecialWord.wTags

wTemplate:

• TSpecialWord.wTemplate

wThis:

• TSpecialWord.wThis

wThread:

• TSpecialWord.wThread

wThread_local:

• TSpecialWord.wThread_local

wThreadVar:

• TSpecialWord.wThreadVar

wThrow:

• TSpecialWord.wThrow

wTrMacros:

• TSpecialWord.wTrMacros

wTrue:

• TSpecialWord.wTrue

wTry:

• TSpecialWord.wTry

wTuple:

• TSpecialWord.wTuple

wType:

• TSpecialWord.wType

wTypedef:

• TSpecialWord.wTypedef

wTypeid:

• TSpecialWord.wTypeid

wTypename:

• TSpecialWord.wTypename

wTypeof:

• TSpecialWord.wTypeof

wUncheckedAssign:

• TSpecialWord.wUncheckedAssign

wUndef:

• TSpecialWord.wUndef

wUnion:

• TSpecialWord.wUnion

wUnsigned:

• TSpecialWord.wUnsigned

wUsed:

• TSpecialWord.wUsed

wUsing:

• TSpecialWord.wUsing

wVar:

• TSpecialWord.wVar

wVarargs:

• TSpecialWord.wVarargs

wVirtual:

• TSpecialWord.wVirtual

wVoid:

• TSpecialWord.wVoid

wVolatile:

• TSpecialWord.wVolatile

wWarning:

• TSpecialWord.wWarning

wWarningAsError:

• TSpecialWord.wWarningAsError

wWarnings:

• TSpecialWord.wWarnings

wWchar_t:

• TSpecialWord.wWchar_t

wWhen:

• TSpecialWord.wWhen

wWhile:

• TSpecialWord.wWhile

wWrite:

• TSpecialWord.wWrite

wWrites:

• TSpecialWord.wWrites

wXor:

• TSpecialWord.wXor

wYield:

• TSpecialWord.wYield

yes:

• Ternary.yes

YieldReason:

• vm: YieldReason

YieldReasonKind:

• vm: YieldReasonKind

yrkDone:

• YieldReasonKind.yrkDone

yrkEcho:

• YieldReasonKind.yrkEcho

yrkError:

• YieldReasonKind.yrkError

yrkMissingProcedure:

• YieldReasonKind.yrkMissingProcedure

yrkQuit:

• YieldReasonKind.yrkQuit

Zero:

• int128: Zero