Cfile = object
  nimname*: string           ## Original name of the nim file, constructed
                             ## from the module name.
  cname*, obj*: AbsoluteFile
  flags*: set[CfileFlag]
  customArgs*: string

CfileFlag {.pure.} = enum
  Cached,                   ## no need to recompile this time
  External                   ## file was introduced via .compile pragma

CfileList = seq[Cfile]

ConfigRef = ref object
  active*: CurrentConf
  spellSuggestMax*: int      ## max number of spelling suggestions for typos
  verbosity*: CompilerVerbosity ## how verbose the compiler is
  arguments*: string         ## the arguments to be passed to the program that
                             ## should be run
  linesCompiled*: int
  m*: MsgConfig
  unitSep*: string           ## Unit separator between compiler messages
  evalTemplateCounter*: int  ## Template instantiation depth used to guard
                             ## against infinite expansion recursion
  exitcode*: int8
  hintProcessingDots*: bool  ## true for dots, false for filenames
  lastCmdTime*: float ## Start of the last compiler commmand - set
                      ## in the `main.mainCommand` and then read to generate 'successX'
                      ## message
  headerFile*: string
  ideCmd*: IdeCmd
  oldNewlines*: bool
  mainPackageId*: int
  errorCounter*: int
  hintCounter*: int
  warnCounter*: int
  errorMax*: int             ## Maximum number of errors before compilation will be terminated
  maxLoopIterationsVM*: int  ## VM: max iterations of all loops
  packageCache*: StringTableRef ## absolute path -> absolute path
  jsonBuildFile*: AbsoluteFile
  nimStdlibVersion*: NimVer
  cfileSpecificOptions*: StringTableRef ## File specific compilation options for C backend.
                                        ## Modified by `{.localPassc.}`
  inputMode*: ProjectInputMode ## how the main module is sourced
  lastMsgWasDot*: set[StdOrrKind] ## the last compiler message was a single '.'
  projectMainIdx*: FileIndex ## the canonical path id of the main module
  commandLineSrcIdx*: FileIndex ## used by `commands` to base paths off for
                                ## path, lib, and other additions; default
                                ## to `lineinfos.commandLineIdx` and
                                ## altered by `nimconf` as needed
  command*: string           ## the main command (e.g. cc, check, scan, etc)
  commandArgs*: seq[string]  ## any arguments after the main command
  commandLine*: string
  extraCmds*: seq[string]    ## for writeJsonBuildInstructions
  keepComments*: bool        ## whether the parser needs to keep comments
  docSeeSrcUrl*: string ## if empty, no seeSrc will be
                        ## generated. The string uses the formatting variables `path` and
                        ## `line`.
  docRoot*: string           ## see nim --fullhelp for --docRoot
  docCmd*: string            ## see nim --fullhelp for --docCmd
  configFiles*: seq[AbsoluteFile] ## List of config files that have been
                                  ## processed during compilation.
  externalToLink*: seq[string] ## files to link in addition to the file
                               ## we compiled. Modified by the `{.link.}` pragma and `--link`
                               ## command-line flag.
  linkOptions*: string       ## Additional linking options, modified by the
                             ## `{.passl.}` pragma
  compileOptions*: string    ## Additional compilation options, modified by
                             ## the `{.passc.}` pragma
  cCompilerPath*: string
  toCompile*: CfileList
  suggestionResultHook*: proc (result: Suggest) {.closure.}
  suggestMaxResults*: int
  lastLineInfo*: TLineInfo
  writelnHook*: proc (conf: ConfigRef; output: string; flags: MsgFlags) {.
      closure.}              ## All
                             ## textual output from the compiler goes through this callback.
  writeHook*: proc (conf: ConfigRef; output: string; flags: MsgFlags) {.closure.}
  structuredReportHook*: ReportHook ## callback that is invoked when an enabled report is passed to report
                                    ## handling. The callback is meant to handle rendering/displaying of
                                    ## the report
  astDiagToLegacyReport*: proc (conf: ConfigRef; d: PAstDiag): Report
  setMsgFormat*: proc (config: ConfigRef; fmt: MsgFormatKind) {.closure.} ## callback that sets the message format for legacy reporting, needs to
                                                                          ## set before CLI handling, because reports are just that awful
  hack*: HackController      ## Configuration values for debug printing
  when defined(nimDebugUtils):
      debugUtilsStack*: seq[string] ## which proc name to stop trace output
                                    ## len is also used for output indent level
    
  toDebugProc*: StringTableRef ## maps identifiers to the name of the IR to print to the standard
                               ## output
  toDebugIr*: set[IrName] ## the IRs which should always be always printed to the standard
                          ## output
  when defined(nimDebugUnreportedErrors):
      unreportedErrors*: OrderedTable[NodeId, PNode]

  

HackController = object
  semStack*: bool            ## Show `| context` entries in the call tracer
  reportInTrace*: bool       ## Error messages are shown with matching indentation
                             ## if report was triggered during execution of the
                             ## sem trace
  semTraceData*: bool        ## For each sem step show processed data, or only
                             ## procedure calls.
  bypassWriteHookForTrace*: bool ## Output trace reports directly into
                                 ## the `echo` instead of going through the `ConfigRef.writeln` hook.
                                 ## This is useful for environments such as nimsuggest, which discard
                                 ## the output.
  

IdeCmd = enum
  ideNone, ideSug, ideCon, ideDef, ideUse, ideDus, ideChk, ideMod, ideHighlight,
  ideOutline, ideKnown, ideMsg, ideProject

IrName = enum
  irTransf = "transf", irMirIn = "mir_in", irMirOut = "mir_out",
  irCgir = "cgir", irVm = "vm"

MsgConfig = object
  trackPos*: TLineInfo
  trackPosAttached*: bool    ## whether the tracking position was attached to
                             ## some close token.
  errorOutputs*: TErrorOutputs ## Allowed output streams for messages.
  msgContext*: seq[tuple[info: TLineInfo, detail: PSym]] ## \ Contextual
                                                         ## 
                                                         ## information about instantiation stack - "template/generic
                                                         ## 
                                                         ## instantiation of" message is constructed from this field. Right now
                                                         ## 
                                                         ## `.detail` field is only used in the 
                                                         ## `sem.semMacroExpr()`,
                                                         ## 
                                                         ## `seminst.generateInstance()` and 
                                                         ## `semexprs.semTemplateExpr()`. 
                                                         ## In
                                                         ## all other cases this field is left empty (SemReport is `skUnknown`)
  writtenSemReports*: ReportSet
  lastError*: TLineInfo
  filenameToIndexTbl*: Table[string, FileIndex]
  rawPathToIndexTbl*: Table[string, FileIndex] ## maps non-canonicalized
                                               ## paths of known-files to the corresponding file index
  fileInfos*: seq[TFileInfo] ## Information about all known source files
                             ## is stored in this field - full/relative paths, list of line etc.
                             ## (For full list see `TFileInfo`)
  systemFileIdx*: FileIndex

MsgFlag = enum
  msgStdout,                ## force writing to stdout, even stderr is default
  msgNoUnitSep               ## the message is a complete "paragraph".

MsgFlags = set[MsgFlag]

NimVer = tuple[major: int, minor: int, patch: int]

PkgDesc = object
  case pkgKnown*: bool
  of true:
      pkgFile*: AbsoluteFile ## if applicable, package file
    
  of false:
      nil

  pkgRootName*: string       ## name of the package root
  pkgRoot*: AbsoluteDir      ## path to the root or project path if unknown pkg
  pkgSubpath*: string        ## if not empty, sub-package it's a part of
  pkgName*: string           ## fully escaped package name with any subpaths, same
                             ## as `pkgRootName` if no subpaths present
  

ProjectInputMode = enum
  pimStdin,                 ## the contents of the main module are provided by stdin
  pimCmd, ## the contents of the main module are provided by a command-line
           ## argument
  pimFile                    ## the main module is a file

ReportHook = proc (conf: ConfigRef; report: Report): TErrorHandling {.closure.}

ReportSet = object
  ids: PackedSet[uint32]

ReportWritabilityKind = enum
  writeEnabled, writeDisabled, writeForceEnabled

StdOrrKind = enum
  stdOrrStdout, stdOrrStderr

Suggest = ref object
  section*: IdeCmd
  qualifiedPath*: seq[string]
  name*: string              ## display name
  filePath*: string
  line*: int                 ## Starts at 1
  column*: int               ## Starts at 0
  doc*: string               ## Unescaped documentation string
  forth*: string             ## type
  quality*: range[0 .. 100]  ## matching quality
  contextFits*: bool         ## type/non-type context matches
  prefix*: PrefixMatch
  symkind*: byte
  scope*: int
  localUsages*, globalUsages*: int
  tokenLen*: int
  flags*: set[SuggestFlag]

SuggestFlag {.pure.} = enum
  deprecated = 1, isGlobal = 2

Suggestions = seq[Suggest]

TCmdLinePass = enum
  passCmd1, passCmd2, passPP

TErrorHandling = enum
  doDefault, ## Default action, custom report hook can return this in
              ## order for automatic handing to decide appropriate
              ## reaction.
  doNothing,                ## Don't do anything
  doAbort,                  ## Immediately abort compilation
  doRaise                    ## Raise recoverable error

TStringSeq = seq[string]

ChecksOptions = {optObjCheck, optFieldCheck, optRangeCheck, optOverflowCheck,
                 optBoundsCheck, optAssert, optNaNCheck, optInfCheck,
                 optStyleCheck}

cmdBackends = {cmdCompileToC, cmdCompileToJS, cmdCompileToVM, cmdCrun}

cmdDocLike = {cmdDoc, cmdDoc2tex, cmdJsondoc, cmdCtags, cmdBuildindex}

commandLineDesc = "command line"

copyrightYear = "2022"

DefaultConfig = r"nim.cfg"

DefaultConfigNims = r"config.nims"

DefaultGlobalOptions = {optThreadAnalysis, optExcessiveStackTrace}

DefaultOptions = {optObjCheck, optFieldCheck, optRangeCheck, optBoundsCheck,
                  optOverflowCheck, optAssert, optWarns, optHints,
                  optStackTrace, optLineTrace, optTrMacros, optStyleCheck,
                  optCursorInference}

DocConfig = r"nimdoc.cfg"

docRootDefault = "@default"

DocTexConfig = r"nimdoc.tex.cfg"

genSubDir = r"nimskullcache"

harmlessOptions = {optForceFullMake, optNoLinking, optRun, optUseColors,
                   optStdout}

hasTinyCBackend = false

htmldocsDir = "htmldocs"

HtmlExt = "html"

IdeLocCmds = {ideSug, ideCon, ideDef, ideUse, ideDus}

IniExt = "ini"

JsonExt = "json"

nimEnableCovariance = false

NimExt = "nim"

NotesVerbosity = (main: [{rintUnreachable..rintSource,
                          rintQuitCalled..rintMissingStackTrace,
                          rintStackTrace..rextCmdRequiresFile,
                          rlexMalformedNumUnderscores..rlexLinterReport,
                          rparInvalidIndentation..rvmStackTrace,
                          rsemUserError..rsemMissingPragmaArg,
                          rsemEmptyAsm..rsemDotForModuleImport,
                          rsemStrictNotNilExpr..rsemStrictNotNilResult,
                          rsemWarnGcUnsafeListing..rsemProveInit,
                          rsemImplicitCstringConvert..rsemHoleEnumConvert,
                          rsemMethodLockMismatch..rsemResultShadowed,
                          rsemGenericMethodsDeprecated..rsemBindDeprecated,
                          rsemUnknownHint..rsemLinterReportUse,
                          rsemXDeclaredButNotUsed..rsemClosureWithoutEnv,
                          rsemExprAlwaysX..rsemConditionAlwaysFalse,
                          rsemEffectsListingHint..rsemNonMatchingCandidates,
                          rsemDiagnostics..rcmdFailedExecution,
                          rcmdRunnableExamplesSuccess,
                          rbackCannotWriteScript..rbackProducedAssembly}, {
    rintUnreachable..rintSource, rintQuitCalled..rextCmdRequiresFile,
    rlexMalformedNumUnderscores..rlexLinterReport,
    rparInvalidIndentation..rvmStackTrace, rsemUserError..rsemMissingPragmaArg,
    rsemEmptyAsm..rsemDotForModuleImport,
    rsemStrictNotNilExpr..rsemStrictNotNilResult,
    rsemWarnGcUnsafeListing..rsemProveInit,
    rsemImplicitCstringConvert..rsemHoleEnumConvert,
    rsemMethodLockMismatch..rsemResultShadowed,
    rsemGenericMethodsDeprecated..rsemBindDeprecated,
    rsemUnknownHint..rsemLinterReportUse,
    rsemXDeclaredButNotUsed..rsemProcessing, rsemExprAlwaysX..rsemPattern,
    rsemEffectsListingHint..rsemNonMatchingCandidates,
    rsemDiagnostics..rcmdFailedExecution,
    rcmdExecuting..rcmdRunnableExamplesSuccess,
    rbackCannotWriteScript..rbackProducedAssembly}, {
    rintUnreachable..rintMsgOrigin, rintQuitCalled..rextCmdRequiresFile,
    rextPath..rvmStackTrace, rsemUserError..rsemStrictNotNilResult,
    rsemWarnGcUnsafeListing..rsemProveInit,
    rsemImplicitCstringConvert..rsemHoleEnumConvert,
    rsemMethodLockMismatch..rsemResultShadowed,
    rsemGenericMethodsDeprecated..rsemBindDeprecated,
    rsemUnknownHint..rsemProcessing, rsemExprAlwaysX..rsemNonMatchingCandidates,
    rsemDiagnostics..rcmdFailedExecution,
    rcmdExecuting..rcmdRunnableExamplesSuccess,
    rbackCannotWriteScript..rbackProducedAssembly}, {
    rintUnreachable..rintMsgOrigin, rintQuitCalled..rvmStackTrace,
    rsemUserError..rsemHoleEnumConvert,
    rsemMethodLockMismatch..rsemResultShadowed,
    rsemGenericMethodsDeprecated..rsemBindDeprecated,
    rsemUnknownHint..rcmdFailedExecution,
    rcmdExecuting..rcmdRunnableExamplesSuccess,
    rbackCannotWriteScript..rbackProducedAssembly}], foreign: {
    rintUnreachable..rextCmdRequiresFile,
    rlexMalformedNumUnderscores..rlexUnclosedComment,
    rparInvalidIndentation..rparInvalidFilter,
    rvmOpcParseExpectedExpression..rvmStackTrace,
    rsemUserError..rsemUserWarning, rsemUserHint, rsemProcessing,
    rsemImplicitObjConv..rcmdFailedExecution,
    rbackCannotWriteScript..rbackCannotProduceAssembly}, base: {
    rintUnreachable..rextCmdRequiresFile,
    rlexMalformedNumUnderscores..rlexUnclosedComment,
    rparInvalidIndentation..rparInvalidFilter,
    rvmOpcParseExpectedExpression..rvmStackTrace, rsemUserError..rsemEmptyAsm,
    rcmdFailedExecution, rbackCannotWriteScript..rbackCannotProduceAssembly})

oldExperimentalFeatures = {dotOperators, callOperator}

RodExt = "rod"

spellSuggestSecretSauce = -1

TagsExt = "tags"

TexExt = "tex"

useEffectSystem = true

useWriteTracking = false

proc `$`(c: IdeCmd): string {....raises: [], tags: [].}

proc absOutFile(conf: ConfigRef): AbsoluteFile {....raises: [OSError],
    tags: [ReadDirEffect].}

proc asgn(conf: ConfigRef; nset: ConfNoteSet; notes: ReportKinds) {....raises: [],
    tags: [].}

proc asgn(conf: ConfigRef; sto, sfrom: ConfNoteSet) {....raises: [], tags: [].}

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

proc canonDynlibName(s: string): string {....raises: [], tags: [].}

proc canonicalImport(conf: ConfigRef; file: AbsoluteFile): string {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc canonicalImportAux(conf: ConfigRef; file: AbsoluteFile): string {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc canonicalizePath(conf: ConfigRef; path: AbsoluteFile): AbsoluteFile {.
    ...raises: [OSError], tags: [ReadDirEffect].}

proc canReport(conf: ConfigRef; id: NodeId): bool {....raises: [], tags: [].}

proc canReport(conf: ConfigRef; node: PNode): bool {....raises: [], tags: [].}

proc clearNimblePath(conf: ConfigRef) {....raises: [], tags: [].}

proc cmdlineNotes(conf: ConfigRef): ReportKinds {....raises: [], tags: [].}

proc cmdlineNotes=(conf: ConfigRef; nset: ReportKinds) {....raises: [], tags: [].}

proc completeGeneratedExtFilePath(conf: ConfigRef; f: AbsoluteFile): AbsoluteFile {.
    ...raises: [OSError, IOError],
    tags: [ReadEnvEffect, ReadIOEffect, WriteDirEffect, ReadDirEffect].}

proc completeGeneratedFilePath(conf: ConfigRef; f: AbsoluteFile;
                               createSubDir: bool = true): AbsoluteFile {.
    ...raises: [OSError, IOError],
    tags: [ReadEnvEffect, ReadIOEffect, WriteDirEffect, ReadDirEffect].}

func contains(s: var ReportSet; id: NodeId): bool {....raises: [], tags: [].}

proc countDefinedSymbols(conf: ConfigRef): int {....raises: [], tags: [].}

proc cppDefine(c: ConfigRef; define: string) {....raises: [], tags: [].}

proc defineSymbol(conf: ConfigRef; symbol: string; value: string = "true") {.
    ...raises: [], tags: [].}

proc demanglePackageName(path: string): string {....raises: [], tags: [].}

proc disableNimblePath(conf: ConfigRef) {....raises: [], tags: [].}

proc excl(conf: ConfigRef; nset: ConfNoteSet; note: ReportKind) {....raises: [],
    tags: [].}

proc existsConfigVar(conf: ConfigRef; key: string): bool {....raises: [], tags: [].}

proc fileInfoIdx(conf: ConfigRef; filename: AbsoluteFile): FileIndex {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc fileInfoIdx(conf: ConfigRef; filename: AbsoluteFile; isKnownFile: var bool): FileIndex {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc fileInfoKnown(conf: ConfigRef; filename: AbsoluteFile): bool {....raises: [],
    tags: [ReadDirEffect].}

proc findFile(conf: ConfigRef; f: string; suppressStdlib = false): AbsoluteFile {.
    ...raises: [OSError], tags: [ReadDirEffect].}

proc findModule(conf: ConfigRef; modulename, currentModule: string): AbsoluteFile {.
    ...raises: [OSError], tags: [ReadDirEffect].}

proc findProjectNimFile(conf: ConfigRef; pkg: string): string {.
    ...raises: [OSError], tags: [ReadDirEffect].}

proc flip(conf: ConfigRef; nset: ConfNoteSet; note: ReportKind; state: bool) {.
    ...raises: [], tags: [].}

proc floatInt64Align(conf: ConfigRef): int16 {....raises: [], tags: [].}

proc foreignPackageNotes(conf: ConfigRef): ReportKinds {....raises: [], tags: [].}

proc foreignPackageNotes=(conf: ConfigRef; nset: ReportKinds) {....raises: [],
    tags: [].}

proc getClockStr(): string {....raises: [], tags: [ReadEnvEffect, TimeEffect].}

proc getCompileOptionsStr(conf: ConfigRef): string {....raises: [], tags: [].}

proc getConfigVar(conf: ConfigRef; key: string; default = ""): string {.
    ...raises: [], tags: [].}

proc getDateStr(): string {....raises: [], tags: [ReadEnvEffect, TimeEffect].}

proc getDefined(conf: ConfigRef; sym: string): string {....raises: [KeyError],
    tags: [].}

proc getLinkOptionsStr(conf: ConfigRef): string {....raises: [], tags: [].}

proc getNimcacheDir(conf: ConfigRef): AbsoluteDir {....raises: [OSError],
    tags: [ReadEnvEffect, ReadIOEffect].}

proc getNimcacheDir(conf: CurrentConf): AbsoluteDir {....raises: [OSError],
    tags: [ReadEnvEffect, ReadIOEffect].}

proc getOutFile(conf: ConfigRef; filename: RelativeFile; ext: string): AbsoluteFile {.
    ...raises: [OSError], tags: [].}

proc getPkgDesc(conf: ConfigRef; modulePath: string): PkgDesc {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc getPrefixDir(conf: ConfigRef): AbsoluteDir {....raises: [],
    tags: [ReadIOEffect].}

proc getRelativePathFromConfigPath(conf: ConfigRef; f: AbsoluteFile;
                                   isTitle = false): RelativeFile {.
    ...raises: [Exception], tags: [RootEffect].}

proc getReportHook(conf: ConfigRef): ReportHook {....raises: [], tags: [].}

proc getStdlibVersion(conf: ConfigRef): NimVer {....raises: [ValueError], tags: [].}

proc hasHint(conf: ConfigRef; note: ReportKind): bool {....raises: [], tags: [].}

proc hasWarn(conf: ConfigRef; note: ReportKind): bool {.inline, ...raises: [],
    tags: [].}

proc hintsAsErrors(conf: ConfigRef): ReportKinds {....raises: [], tags: [].}

proc hintsAsErrors=(conf: ConfigRef; nset: ReportKinds) {....raises: [], tags: [].}

proc importantComments(conf: ConfigRef): bool {.inline, ...raises: [], tags: [].}

proc incl(conf: ConfigRef; nset: ConfNoteSet; note: ReportKind) {....raises: [],
    tags: [].}

func incl(s: var ReportSet; id: NodeId) {....raises: [], tags: [].}

proc inclDynlibOverride(conf: ConfigRef; lib: string) {....raises: [], tags: [].}

func inDebug(conf: ConfigRef): bool {....deprecated: "DEBUG proc, do not use in the final build!",
                                      noSideEffect, ...raises: [], tags: [].}

proc inFile(conf: ConfigRef; info: TLineInfo; file: string;
            lrange: Slice[int] = low(int) .. high(int)): bool {.
    ...deprecated: "DEBUG proc, do not use in the final build!", noSideEffect,
    ...raises: [], tags: [].}

proc initMsgConfig(): MsgConfig {....raises: [], tags: [].}

func isCodeError(conf: ConfigRef; report: Report): bool {....raises: [], tags: [].}

proc isDefined(conf: ConfigRef; symbol: string): bool {....raises: [], tags: [].}

proc isDefined(conf: CurrentConf; symbol: string): bool {....raises: [], tags: [].}

proc isDynlibOverride(conf: ConfigRef; lib: string): bool {....raises: [], tags: [].}

func isEnabled(conf: ConfigRef; report: Report): bool {....raises: [], tags: [].}

func isEnabled(conf: ConfigRef; report: ReportKind): bool {....raises: [], tags: [].}

proc mainCommandArg(conf: ConfigRef): string {....raises: [], tags: [].}

proc mainPackageNotes(conf: ConfigRef): ReportKinds {....raises: [], tags: [].}

proc mainPackageNotes=(conf: ConfigRef; nset: ReportKinds) {....raises: [],
    tags: [].}

proc makeCString(s: string): string {....raises: [], tags: [].}

proc modifiedyNotes(conf: ConfigRef): ReportKinds {....raises: [], tags: [].}

proc modifiedyNotes=(conf: ConfigRef; nset: ReportKinds) {....raises: [], tags: [].}

proc newConfigRef(hook: ReportHook): ConfigRef {....raises: [], tags: [].}

proc newLineInfo(conf: ConfigRef; filename: AbsoluteFile; line, col: int): TLineInfo {.
    inline, ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc newPartialConfigRef(): ConfigRef {....raises: [], tags: [].}

proc notes(conf: ConfigRef): ReportKinds {....raises: [], tags: [].}

proc notes=(conf: ConfigRef; nset: ReportKinds) {....raises: [], tags: [].}

func options(conf: ConfigRef): TOptions {....raises: [], tags: [].}

proc options=(conf: ConfigRef; opts: TOptions) {....raises: [], tags: [].}

proc parseIdeCmd(s: string): IdeCmd {....raises: [], tags: [].}

proc parseNimVersion(a: string): NimVer {....raises: [ValueError], tags: [].}

proc pathSubs(conf: ConfigRef; p, config: string): string {.
    ...raises: [ValueError, OSError], tags: [ReadEnvEffect, ReadIOEffect].}

proc prepareToWriteOutput(conf: ConfigRef): AbsoluteFile {.
    ...raises: [OSError, IOError], tags: [ReadDirEffect, WriteDirEffect].}

proc removeTrailingDirSep(path: string): string {....raises: [], tags: [].}

proc report(conf: ConfigRef; inReport: Report): TErrorHandling {.
    ...raises: [Exception], tags: [RootEffect].}

proc setConfigVar(conf: ConfigRef; key, val: string) {....raises: [], tags: [].}

proc setDefaultLibpath(conf: ConfigRef) {....raises: [OSError],
    tags: [ReadIOEffect, ReadDirEffect, ReadEnvEffect].}

proc setFromProjectName(conf: ConfigRef; projectName: string) {.
    ...raises: [OSError], tags: [ReadDirEffect].}

proc setNote(conf: ConfigRef; note: ReportKind; enabled = true) {....raises: [],
    tags: [].}

proc setNoteDefaults(conf: ConfigRef; note: ReportKind; enabled = true) {.
    ...raises: [], tags: [].}

proc setReportHook(conf: ConfigRef; hook: ReportHook) {....raises: [], tags: [].}

func severity(conf: ConfigRef; report: ReportTypes | Report): ReportSeverity

proc toCChar(c: char; result: var string) {.inline, ...raises: [], tags: [].}

proc toGeneratedFile(conf: CurrentConf | ConfigRef; path: AbsoluteFile;
                     ext: string): AbsoluteFile

proc toRodFile(conf: ConfigRef; f: AbsoluteFile; ext = RodExt): AbsoluteFile {.
    ...raises: [OSError, IOError, KeyError, Exception], tags: [ReadEnvEffect,
    ReadIOEffect, WriteDirEffect, ReadDirEffect, RootEffect].}

proc undefSymbol(conf: ConfigRef; symbol: string) {....raises: [], tags: [].}

func useColor(conf: ConfigRef): bool {....raises: [], tags: [].}

proc warningAsErrors(conf: ConfigRef): ReportKinds {....raises: [], tags: [].}

proc warningAsErrors=(conf: ConfigRef; nset: ReportKinds) {....raises: [], tags: [].}

proc withPackageName(conf: ConfigRef; path: AbsoluteFile): AbsoluteFile {.
    ...raises: [KeyError, OSError, Exception], tags: [ReadDirEffect, RootEffect].}

func writabilityKind(conf: ConfigRef; r: Report): ReportWritabilityKind {.
    ...raises: [], tags: [].}

proc write(conf: ConfigRef; args: varargs[string, `$`]) {....raises: [Exception],
    tags: [RootEffect].}

proc writeHook(conf: ConfigRef; msg: string; flags: MsgFlags = {}) {.
    ...raises: [Exception], tags: [RootEffect].}

proc writeln(conf: ConfigRef; args: varargs[string, `$`]) {....raises: [Exception],
    tags: [RootEffect].}

proc writelnHook(conf: ConfigRef; msg: string; flags: MsgFlags = {}) {.
    ...raises: [Exception], tags: [RootEffect].}

iterator definedSymbolNames(conf: ConfigRef): string {....raises: [], tags: [].}

iterator nimbleSubs(conf: ConfigRef; p: string): string {....raises: [ValueError],
    tags: [].}

template `[]`(conf: ConfigRef; idx: FileIndex): TFileInfo

template arcToExpand(conf`gensym76: ConfigRef): StringTableRef

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

template arcToExpandDel(conf`gensym75: ConfigRef; key`gensym75: string)

template arcToExpandGet(conf`gensym75: ConfigRef; key`gensym75: string): string

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

template backend(conf`gensym22: ConfigRef): TBackend

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

template cCompiler(conf`gensym32: ConfigRef): TSystemCC

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

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

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

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

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

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

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

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

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

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

template cmd(conf`gensym29: ConfigRef): Command

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

template compilationCachePresent(conf: ConfigRef): untyped

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

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

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

template configVars(conf`gensym70: ConfigRef): StringTableRef

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

template configVarsDel(conf`gensym69: ConfigRef; key`gensym69: string)

template configVarsGet(conf`gensym69: ConfigRef; key`gensym69: string): string

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

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

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

template depfile(conf`gensym37: ConfigRef): AbsoluteFile

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

template dllOverrides(conf`gensym68: ConfigRef): StringTableRef

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

template dllOverridesDel(conf`gensym67: ConfigRef; key`gensym67: string)

template dllOverridesGet(conf`gensym67: ConfigRef; key`gensym67: string): string

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

template exc(conf`gensym31: ConfigRef): ExceptionSystem

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

template excl(conf`gensym61: ConfigRef; item`gensym61: TOption | TOptions)

template excl(conf`gensym63: ConfigRef;
              item`gensym63: TGlobalOption | TGlobalOptions)

template excl(conf`gensym65: ConfigRef; item`gensym65: Feature | set[Feature])

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

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

template filenameOption(conf`gensym33: ConfigRef): FilenameOption

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

template globalOptions(conf`gensym64: ConfigRef): TGlobalOptions

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

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

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

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

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

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

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

template incl(conf`gensym61: ConfigRef; item`gensym61: TOption | TOptions)

template incl(conf`gensym63: ConfigRef;
              item`gensym63: TGlobalOption | TGlobalOptions)

template incl(conf`gensym65: ConfigRef; item`gensym65: Feature | set[Feature])

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

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

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

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

template libpath(conf`gensym25: ConfigRef): AbsoluteDir

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

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

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

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

template localOptions(conf`gensym62: ConfigRef): TOptions

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

template macrosToExpand(conf`gensym74: ConfigRef): StringTableRef

template macrosToExpand=(conf`gensym74: ConfigRef; val`gensym74: StringTableRef)

template macrosToExpandDel(conf`gensym73: ConfigRef; key`gensym73: string)

template macrosToExpandGet(conf`gensym73: ConfigRef; key`gensym73: string): string

template macrosToExpandSet(conf`gensym73: ConfigRef; key`gensym73: string;
                           value`gensym73: string)