LoadedModule = object
  status*: ModuleStatus
  symsInit, typesInit, loadedButAliveSetChanged*: bool
  fromDisk*: PackedModule
  syms: seq[PSym]
  types: seq[PType]
  module*: PSym
  iface, ifaceHidden: Table[PIdent, seq[PackedItemId]]

ModuleBackendFlag = enum
  HasDatInitProc, HasModuleInitProc

ModuleStatus = enum
  undefined, storing, loading, loaded, outdated, stored

PackedConfig = object
  backend: TBackend
  selectedGC: TGCMode
  cCompiler: TSystemCC
  options: TOptions
  globalOptions: TGlobalOptions

PackedDecoder = object
  lastModule: int
  lastLit: LitId
  lastFile: FileIndex
  config*: ConfigRef
  cache*: IdentCache

PackedEncoder = object
  thisModule*: int32
  lastFile*: FileIndex
  lastLit*: LitId
  filenames*: Table[FileIndex, LitId]
  pendingTypes*: seq[PType]
  pendingSyms*: seq[PSym]
  typeMarker*: IntSet
  symMarker*: IntSet
  config*: ConfigRef

PackedModule = object
  definedSymbols: string
  moduleFlags: TSymFlags
  includes*: seq[(LitId, string)]
  imports: seq[LitId]
  toReplay*: PackedTree
  topLevel*: PackedTree
  bodies*: PackedTree
  exports*: seq[(LitId, int32)]
  hidden*: seq[(LitId, int32)]
  reexports*: seq[(LitId, PackedItemId)]
  compilerProcs*: seq[(LitId, int32)]
  converters*, methods*, trmacros*, pureEnums*: seq[int32]
  macroUsages*: seq[(PackedItemId, PackedLineInfo)]
  typeInstCache*: seq[(PackedItemId, PackedItemId)]
  procInstCache*: seq[PackedInstantiation]
  attachedOps*: seq[(TTypeAttachedOp, PackedItemId, PackedItemId)]
  methodsPerType*: seq[(PackedItemId, int, PackedItemId)]
  enumToStringProcs*: seq[(PackedItemId, PackedItemId)]
  emittedTypeInfo*: seq[string]
  backendFlags*: set[ModuleBackendFlag]
  syms*: seq[PackedSym]
  types*: seq[PackedType]
  strings*: BiTable[string]
  numbers*: BiTable[BiggestInt]
  cfg: PackedConfig

PackedModuleGraph = seq[LoadedModule]

RodIter = object
  decoder: PackedDecoder
  values: seq[PackedItemId]
  i, module: int

proc addCompilerProc(c: var PackedEncoder; m: var PackedModule; s: PSym) {.
    ...raises: [], tags: [].}

proc addConverter(c: var PackedEncoder; m: var PackedModule; s: PSym) {.
    ...raises: [], tags: [].}

proc addExported(c: var PackedEncoder; m: var PackedModule; s: PSym) {.
    ...raises: [], tags: [].}

proc addHidden(c: var PackedEncoder; m: var PackedModule; s: PSym) {....raises: [],
    tags: [].}

proc addImportFileDep(c: var PackedEncoder; m: var PackedModule; f: FileIndex) {.
    ...raises: [], tags: [].}

proc addIncludeFileDep(c: var PackedEncoder; m: var PackedModule; f: FileIndex) {.
    ...raises: [IOError], tags: [ReadIOEffect].}

proc addMethod(c: var PackedEncoder; m: var PackedModule; s: PSym) {....raises: [],
    tags: [].}

proc addPragmaComputation(c: var PackedEncoder; m: var PackedModule; n: PNode) {.
    ...raises: [], tags: [].}

proc addPureEnum(c: var PackedEncoder; m: var PackedModule; s: PSym) {.
    ...raises: [], tags: [].}

proc addReexport(c: var PackedEncoder; m: var PackedModule; s: PSym) {.
    ...raises: [], tags: [].}

proc addTrmacro(c: var PackedEncoder; m: var PackedModule; s: PSym) {.
    ...raises: [], tags: [].}

proc debug(tree: PackedTree; m: PackedModule) {....raises: [IOError],
    tags: [WriteIOEffect].}

proc idgenFromLoadedModule(m: LoadedModule): IdGenerator {....raises: [], tags: [].}

proc initEncoder(c: var PackedEncoder; m: var PackedModule; moduleSym: PSym;
                 config: ConfigRef; pc: PackedConfig) {....raises: [IOError],
    tags: [ReadIOEffect].}

proc initPackedDecoder(config: ConfigRef; cache: IdentCache): PackedDecoder {.
    ...raises: [], tags: [].}

proc initRodIter(it: var RodIter; config: ConfigRef; cache: IdentCache;
                 g: var PackedModuleGraph; module: FileIndex; name: PIdent;
                 importHidden: bool): PSym {....raises: [KeyError, Exception],
    tags: [ReadDirEffect, RootEffect].}

proc initRodIterAllSyms(it: var RodIter; config: ConfigRef; cache: IdentCache;
                        g: var PackedModuleGraph; module: FileIndex;
                        importHidden: bool): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc interfaceSymbol(config: ConfigRef; cache: IdentCache;
                     g: var PackedModuleGraph; module: FileIndex; name: PIdent;
                     importHidden: bool): PSym {....raises: [KeyError, Exception],
    tags: [ReadDirEffect, RootEffect].}

proc isActive(e: PackedEncoder): bool {....raises: [], tags: [].}

proc loadNodes(c: var PackedDecoder; g: var PackedModuleGraph; thisModule: int;
               tree: PackedTree; n: NodePos): PNode {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc loadProcBody(config: ConfigRef; cache: IdentCache;
                  g: var PackedModuleGraph; s: PSym): PNode {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc loadRodFile(filename: AbsoluteFile; m: var PackedModule; config: ConfigRef;
                 ignoreConfig = false): RodFileError {.
    ...raises: [IOError, KeyError, Exception],
    tags: [ReadIOEffect, ReadDirEffect, RootEffect].}

proc loadSymFromId(config: ConfigRef; cache: IdentCache;
                   g: var PackedModuleGraph; module: int; id: PackedItemId): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc loadTypeFromId(config: ConfigRef; cache: IdentCache;
                    g: var PackedModuleGraph; module: int; id: PackedItemId): PType {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc moduleFromRodFile(g: var PackedModuleGraph; conf: ConfigRef;
                       cache: IdentCache; fileIdx: FileIndex;
                       cachedModules: var seq[FileIndex]): PSym {....raises: [
    OSError, IOError, KeyError, Exception, ValueError, ERecoverableError], tags: [
    ReadEnvEffect, ReadIOEffect, WriteDirEffect, ReadDirEffect, RootEffect,
    WriteIOEffect].}

proc moduleIndex(c: var PackedDecoder; g: var PackedModuleGraph;
                 thisModule: int; s: PackedItemId): int32 {.inline,
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc nextRodIter(it: var RodIter; g: var PackedModuleGraph): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc rememberStartupConfig(dest: var PackedConfig; config: ConfigRef) {.
    ...raises: [], tags: [].}

proc rodViewer(rodfile: AbsoluteFile; config: ConfigRef; cache: IdentCache) {.
    ...raises: [IOError, KeyError, Exception],
    tags: [ReadIOEffect, ReadDirEffect, RootEffect].}

proc saveRodFile(filename: AbsoluteFile; encoder: var PackedEncoder;
                 m: var PackedModule) {....raises: [Exception, IOError, OSError], tags: [
    RootEffect, WriteIOEffect, WriteDirEffect].}

proc searchForCompilerproc(m: LoadedModule; name: string): int32 {....raises: [],
    tags: [].}

proc simulateLoadedModule(g: var PackedModuleGraph; conf: ConfigRef;
                          cache: IdentCache; moduleSym: PSym; m: PackedModule) {.
    ...raises: [KeyError, OSError, Exception], tags: [ReadDirEffect, RootEffect].}

proc storeExpansion(c: var PackedEncoder; m: var PackedModule; info: TLineInfo;
                    s: PSym) {....raises: [], tags: [].}

proc storeInstantiation(c: var PackedEncoder; m: var PackedModule; s: PSym;
                        i: PInstantiation) {....raises: [], tags: [].}

proc storeSym(s: PSym; c: var PackedEncoder; m: var PackedModule): PackedItemId {.
    ...raises: [Exception], tags: [RootEffect].}

proc storeTypeInst(c: var PackedEncoder; m: var PackedModule; s: PSym;
                   inst: PType) {....raises: [], tags: [].}

proc toFileIndex(x: LitId; m: PackedModule; config: ConfigRef): FileIndex {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc toFileIndexCached(c: var PackedDecoder; g: PackedModuleGraph;
                       thisModule: int; f: LitId): FileIndex {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc toPackedGeneratedProcDef(s: PSym; encoder: var PackedEncoder;
                              m: var PackedModule) {....raises: [], tags: [].}

proc toPackedNode(n: PNode; ir: var PackedTree; c: var PackedEncoder;
                  m: var PackedModule) {....raises: [], tags: [].}

proc toPackedNodeTopLevel(n: PNode; encoder: var PackedEncoder;
                          m: var PackedModule) {....raises: [Exception],
    tags: [RootEffect].}

proc toString(tree: PackedTree; n: NodePos; m: PackedModule): string {.
    ...raises: [], tags: [].}

proc toString(tree: PackedTree; n: NodePos; m: PackedModule; nesting: int;
              result: var string) {....raises: [], tags: [].}

proc translateId(id: PackedItemId; g: PackedModuleGraph; thisModule: int;
                 config: ConfigRef): ItemId {....raises: [KeyError, Exception],
    tags: [ReadDirEffect, RootEffect].}

iterator interfaceSymbols(config: ConfigRef; cache: IdentCache;
                          g: var PackedModuleGraph; module: FileIndex;
                          name: PIdent; importHidden: bool): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}