TOption = enum
  optNone, optObjCheck, optFieldCheck, optRangeCheck, optBoundsCheck,
  optOverflowCheck, optRefCheck, optNaNCheck, optInfCheck, optStaticBoundsCheck,
  optStyleCheck, optAssert, optLineDir, optWarns, optHints, optOptimizeSpeed,
  optOptimizeSize, optStackTrace, optStackTraceMsgs, optLineTrace, optByRef,
  optProfiler, optImplicitStatic, optTrMacros, optMemTracker, optNilSeqs,
  optSinkInference, optCursorInference

TOptions = set[TOption]

TGlobalOption = enum
  gloptNone, optForceFullMake, optWasNimscript, optListCmd, optCompileOnly,
  optNoLinking, optCDebug, optGenDynLib, optGenStaticLib, optGenGuiApp,
  optGenScript, optGenMapping, optRun, optUseNimcache, optStyleHint,
  optStyleError, optStyleUsages, optSkipSystemConfigFile, optSkipProjConfigFile,
  optSkipUserConfigFile, optSkipParentConfigFiles, optNoMain, optUseColors,
  optThreads, optStdout, optThreadAnalysis, optTaintMode, optTlsEmulation,
  optGenIndex, optEmbedOrigSrc, optIdeDebug, optIdeTerse,
  optExcessiveStackTrace, optShowAllMismatches, optWholeProject, optDocInternal,
  optMixedMode, optListFullPaths, optNoNimblePath, optHotCodeReloading,
  optDynlibOverrideAll, optSeqDestructors, optTinyRtti, optOwnedRefs,
  optMultiMethods, optBenchmarkVM, optProduceAsm, optPanics, optNimV1Emulation,
  optNimV12Emulation, optSourcemap, optProfileVM, optEnableDeepCopy

TGlobalOptions = set[TGlobalOption]

TBackend = enum
  backendInvalid = "", backendC = "c", backendCpp = "cpp", backendJs = "js",
  backendObjc = "objc"

TCommands = enum
  cmdNone, cmdCompileToC, cmdCompileToCpp, cmdCompileToOC, cmdCompileToJS,
  cmdCompileToLLVM, cmdInterpret, cmdPretty, cmdDoc, cmdGenDepend, cmdDump,
  cmdCheck, cmdParse, cmdScan, cmdIdeTools, cmdDef, cmdRst2html, cmdRst2tex,
  cmdInteractive, cmdRun, cmdJsonScript, cmdCompileToBackend

TStringSeq = seq[string]

TGCMode = enum
  gcUnselected, gcNone, gcBoehm, gcRegions, gcArc, gcOrc, gcMarkAndSweep,
  gcHooks, gcRefc, gcV2, gcGo

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

Feature = enum
  implicitDeref, dotOperators, callOperator, parallel, destructor, notnil,
  dynamicBindSym, forLoopMacros, caseStmtMacros, codeReordering, compiletimeFFI, ## This requires building nim with `-d:nimHasLibFFI`
                                                                                  ## which itself requires `nimble install libffi`, see #10150
                                                                                  ## Note: this feature can't be localized with {.push.}
  vmopsDanger, strictFuncs, views

LegacyFeature = enum
  allowSemcheckedAstModification, ## Allows to modify a NimNode where the type has already been
                                   ## flagged with nfSem. If you actually do this, it will cause
                                   ## bugs.
  checkUnsignedConversions ## Historically and especially in version 1.0.0 of the language
                           ## conversions to unsigned numbers were checked. In 1.0.4 they
                           ## are not anymore.

SymbolFilesOption = enum
  disabledSf, writeOnlySf, readOnlySf, v2Sf

TSystemCC = enum
  ccNone, ccGcc, ccNintendoSwitch, ccLLVM_Gcc, ccCLang, ccBcc, ccVcc, ccTcc,
  ccEnv, ccIcl, ccIcc, ccClangCl

ExceptionSystem = enum
  excNone, excSetjmp, excCpp, excGoto, excQuirky

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

Cfile = object
  nimname*: string
  cname*, obj*: AbsoluteFile
  flags*: set[CfileFlag]
  customArgs*: string

CfileList = seq[Cfile]

Suggest = ref object
  section*: IdeCmd
  qualifiedPath*: seq[string]
  name*: ptr string
  filePath*: string
  line*: int
  column*: int
  doc*: string
  forth*: string
  quality*: range[0 .. 100]
  isGlobal*: bool
  contextFits*: bool
  prefix*: PrefixMatch
  symkind*: byte
  scope*, localUsages*, globalUsages*: int
  tokenLen*: int
  version*: int

Suggestions = seq[Suggest]

ProfileInfo = object
  time*: float
  count*: int

ProfileData = ref object
  data*: TableRef[TLineInfo, ProfileInfo]

ConfigRef {...}{.acyclic.} = ref object
  backend*: TBackend
  target*: Target
  linesCompiled*: int
  options*: TOptions
  globalOptions*: TGlobalOptions
  macrosToExpand*: StringTableRef
  arcToExpand*: StringTableRef
  m*: MsgConfig
  evalTemplateCounter*: int
  evalMacroCounter*: int
  exitcode*: int8
  cmd*: TCommands
  selectedGC*: TGCMode
  exc*: ExceptionSystem
  verbosity*: int
  numberOfProcessors*: int
  evalExpr*: string
  lastCmdTime*: float
  symbolFiles*: SymbolFilesOption
  cppDefines*: HashSet[string]
  headerFile*: string
  features*: set[Feature]
  legacyFeatures*: set[LegacyFeature]
  arguments*: string         ## the arguments to be passed to the program that
                             ## should be run
  ideCmd*: IdeCmd
  oldNewlines*: bool
  cCompiler*: TSystemCC
  modifiedyNotes*: TNoteKinds
  cmdlineNotes*: TNoteKinds
  foreignPackageNotes*: TNoteKinds
  notes*: TNoteKinds
  warningAsErrors*: TNoteKinds
  mainPackageNotes*: TNoteKinds
  mainPackageId*: int
  errorCounter*: int
  hintCounter*: int
  warnCounter*: int
  errorMax*: int
  maxLoopIterationsVM*: int  ## VM: max iterations of all loops
  configVars*: StringTableRef
  symbols*: StringTableRef   ## We need to use a StringTableRef here as defined
                             ## symbols are always guaranteed to be style
                             ## insensitive. Otherwise hell would break lose.
  packageCache*: StringTableRef
  nimblePaths*: seq[AbsoluteDir]
  searchPaths*: seq[AbsoluteDir]
  lazyPaths*: seq[AbsoluteDir]
  outFile*: RelativeFile
  outDir*: AbsoluteDir
  jsonBuildFile*: AbsoluteFile
  prefixDir*, libpath*, nimcacheDir*: AbsoluteDir
  dllOverrides, moduleOverrides*, cfileSpecificOptions*: StringTableRef
  projectName*: string
  projectPath*: AbsoluteDir
  projectFull*: AbsoluteFile
  projectIsStdin*: bool
  lastMsgWasDot*: bool
  projectMainIdx*: FileIndex
  projectMainIdx2*: FileIndex
  command*: string
  commandArgs*: seq[string]
  commandLine*: string
  extraCmds*: seq[string]
  keepComments*: bool
  implicitImports*: seq[string]
  implicitIncludes*: seq[string]
  docSeeSrcUrl*: string
  docRoot*: string           ## see nim --fullhelp for --docRoot
  docCmd*: string            ## see nim --fullhelp for --docCmd
  cIncludes*: seq[AbsoluteDir]
  cLibs*: seq[AbsoluteDir]
  cLinkedLibs*: seq[string]
  externalToLink*: seq[string]
  linkOptionsCmd*: string
  compileOptionsCmd*: seq[string]
  linkOptions*: string
  compileOptions*: string
  cCompilerPath*: string
  toCompile*: CfileList
  suggestionResultHook*: proc (result: Suggest) {...}{.closure.}
  suggestVersion*: int
  suggestMaxResults*: int
  lastLineInfo*: TLineInfo
  writelnHook*: proc (output: string) {...}{.closure.}
  structuredErrorHook*: proc (config: ConfigRef; info: TLineInfo; msg: string;
                              severity: Severity) {...}{.closure, gcsafe.}
  cppCustomNamespace*: string
  vmProfileData*: ProfileData

hasTinyCBackend = false

useEffectSystem = true

useWriteTracking = false

hasFFI = false

copyrightYear = "2021"

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

oldExperimentalFeatures = {implicitDeref, dotOperators, callOperator, parallel}

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

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

DefaultGlobalOptions = {optThreadAnalysis, optExcessiveStackTrace,
                        optListFullPaths}

genSubDir = r"nimcache"

NimExt = "nim"

RodExt = "rod"

HtmlExt = "html"

JsonExt = "json"

TagsExt = "tags"

TexExt = "tex"

IniExt = "ini"

DefaultConfig = r"nim.cfg"

DefaultConfigNims = r"config.nims"

DocConfig = r"nimdoc.cfg"

DocTexConfig = r"nimdoc.tex.cfg"

htmldocsDir = "htmldocs"

docRootDefault = "@default"

oKeepVariableNames = true

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

proc getNimbleFile(conf: ConfigRef; path: string): string {...}{.raises: [KeyError],
    tags: [ReadDirEffect].}

proc getPackageName(conf: ConfigRef; path: string): string {...}{.raises: [KeyError],
    tags: [ReadDirEffect].}

proc fakePackageName(conf: ConfigRef; path: AbsoluteFile): string {...}{.
    raises: [Exception], tags: [RootEffect].}

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

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

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

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

proc toGeneratedFile(conf: ConfigRef; path: AbsoluteFile; ext: string): AbsoluteFile {...}{.
    raises: [OSError], tags: [ReadEnvEffect, ReadIOEffect].}

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

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

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

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

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

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

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

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

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

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

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

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

template setErrorMaxHighMaybe(conf: ConfigRef)

template depConfigFields(fn) {...}{.dirty.}

template newPackageCache(): untyped

template compilationCachePresent(conf: ConfigRef): untyped

template optPreserveOrigSource(conf: ConfigRef): untyped