Cfile = object
  nimname*: string
  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]

Command = enum
  cmdNone, cmdUnknown, cmdCompileToC, cmdCompileToCpp, cmdCompileToOC,
  cmdCompileToJS, cmdCrun, cmdTcc, cmdCheck, cmdParse, cmdRod, cmdIdeTools,
  cmdNimscript, cmdDoc0, cmdDoc, cmdDoc2tex, cmdRst2html, cmdRst2tex,
  cmdJsondoc0, cmdJsondoc, cmdCtags, cmdBuildindex, cmdGendepend, cmdDump,
  cmdInteractive, cmdNop, cmdJsonscript, cmdNimfix

ConfigRef {.acyclic.} = ref object
  backend*: TBackend
  target*: Target
  linesCompiled*: int
  options*: TOptions
  globalOptions*: TGlobalOptions
  macrosToExpand*: StringTableRef
  arcToExpand*: StringTableRef
  m*: MsgConfig
  filenameOption*: FilenameOption
  unitSep*: string
  evalTemplateCounter*: int
  evalMacroCounter*: int
  exitcode*: int8
  cmd*: Command
  cmdInput*: string
  projectIsCmd*: bool
  implicitCmd*: bool
  selectedGC*: TGCMode
  exc*: ExceptionSystem
  hintProcessingDots*: bool
  verbosity*: int
  numberOfProcessors*: int
  lastCmdTime*: float
  symbolFiles*: SymbolFilesOption
  spellSuggestMax*: int
  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
  isVmTrace*: bool
  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
  nimStdlibVersion*: NimVer
  dllOverrides, moduleOverrides*, cfileSpecificOptions*: StringTableRef
  projectName*: string
  projectPath*: AbsoluteDir
  projectFull*: AbsoluteFile
  projectIsStdin*: bool
  lastMsgWasDot*: set[StdOrrKind]
  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
  configFiles*: seq[AbsoluteFile]
  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
  nimMainPrefix*: string
  vmProfileData*: ProfileData

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

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, strictNotNil, overloadableEnums,
  strictEffects, unicodeOperators, flexibleOptionalParams

FilenameOption = enum
  foAbs, foRelProject, foCanonical, foLegacyRelProj, foName, foStacktrace

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

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.

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

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

ProfileInfo = object
  time*: float
  count*: int

StdOrrKind = enum
  stdOrrStdout, stdOrrStderr

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]

SymbolFilesOption = enum
  disabledSf, writeOnlySf, readOnlySf, v2Sf, stressTest

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

TGCMode = enum
  gcUnselected = "unselected", gcNone = "none", gcBoehm = "boehm",
  gcRegions = "regions", gcArc = "arc", gcOrc = "orc",
  gcMarkAndSweep = "markAndSweep", gcHooks = "hooks", gcRefc = "refc",
  gcV2 = "v2", gcGo = "go"

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, optTlsEmulation, optGenIndex,
  optEmbedOrigSrc, optIdeDebug, optIdeTerse, optExcessiveStackTrace,
  optShowAllMismatches, optWholeProject, optDocInternal, optMixedMode,
  optDeclaredLocs, optNoNimblePath, optHotCodeReloading, optDynlibOverrideAll,
  optSeqDestructors, optTinyRtti, optOwnedRefs, optMultiMethods, optBenchmarkVM,
  optProduceAsm, optPanics, optNimV1Emulation, optNimV12Emulation, optSourcemap,
  optProfileVM, optEnableDeepCopy

TGlobalOptions = set[TGlobalOption]

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, optSinkInference,
  optCursorInference, optImportHidden

TOptions = set[TOption]

TStringSeq = seq[string]

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

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

cmdBackends = {cmdCompileToC, cmdCompileToCpp, cmdCompileToOC, cmdCompileToJS,
               cmdCrun}

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

copyrightYear = "2021"

DefaultConfig = r"nim.cfg"

DefaultConfigNims = r"config.nims"

DefaultGlobalOptions = {optThreadAnalysis, optExcessiveStackTrace}

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

DocConfig = r"nimdoc.cfg"

docRootDefault = "@default"

DocTexConfig = r"nimdoc.tex.cfg"

foreignPackageNotesDefault = {hintProcessing, warnUnknownMagic, hintQuitCalled,
                              hintExecuting, hintUser, warnUser}

genSubDir = r"nimcache"

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

hasFFI = false

hasTinyCBackend = false

htmldocsDir = "htmldocs"

HtmlExt = "html"

IniExt = "ini"

JsonExt = "json"

nimEnableCovariance = false

NimExt = "nim"

oKeepVariableNames = true

oldExperimentalFeatures = {implicitDeref, dotOperators, callOperator, parallel}

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: [].}

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

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

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

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

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

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

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

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

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

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

proc fakePackageName(conf: ConfigRef; path: AbsoluteFile): string {.
    ...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 floatInt64Align(conf: ConfigRef): int16 {....raises: [], tags: [].}

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

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

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

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

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

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

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

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

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

proc getStdlibVersion(conf: ConfigRef): NimVer {....raises: [ValueError], 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 importantComments(conf: ConfigRef): bool {.inline, ...raises: [], tags: [].}

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

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

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

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

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

proc newPartialConfigRef(): ConfigRef {....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: [WriteDirEffect, ReadDirEffect].}

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

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: TNoteKind; enabled = true) {....raises: [],
    tags: [].}

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

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

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

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

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

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

template compilationCachePresent(conf: ConfigRef): untyped

template newPackageCache(): untyped

template optPreserveOrigSource(conf: ConfigRef): untyped

template quitOrRaise(conf: ConfigRef; msg = "")

template setErrorMaxHighMaybe(conf: ConfigRef)