FullId = object
  module*: int
  packed*: PackedItemId

Iface = object
  module*: PSym              ## module this "Iface" belongs to
  converters*: seq[LazySym]
  patterns*: seq[LazySym]
  pureEnums*: seq[LazySym]
  interf: TStrTable
  interfHidden: TStrTable
  uniqueName*: Rope

LazyInstantiation = object
  module*: int
  sym*: FullId
  concreteTypes*: seq[FullId]
  inst*: PInstantiation

LazySym = object
  id*: FullId
  sym*: PSym

LazyType = object
  id*: FullId
  typ*: PType

ModuleGraph {.acyclic.} = ref object
  ifaces*: seq[Iface]        ## indexed by int32 fileIdx
  packed*: PackedModuleGraph
  encoders*: seq[PackedEncoder]
  typeInstCache*: Table[ItemId, seq[LazyType]]
  procInstCache*: Table[ItemId, seq[LazyInstantiation]]
  attachedOps*: array[TTypeAttachedOp, Table[ItemId, PSym]]
  methodsPerType*: Table[ItemId, seq[(int, LazySym)]]
  enumToStringProcs*: Table[ItemId, LazySym]
  emittedTypeInfo*: Table[string, FileIndex]
  startupPackedConfig*: PackedConfig
  packageSyms*: TStrTable
  modulesPerPackage*: Table[ItemId, TStrTable]
  deps*: IntSet
  importDeps*: Table[FileIndex, seq[FileIndex]]
  suggestMode*: bool
  invalidTransitiveClosure: bool
  inclToMod*: Table[FileIndex, FileIndex]
  importStack*: seq[FileIndex]
  backend*: RootRef
  config*: ConfigRef
  cache*: IdentCache
  vm*: RootRef
  doStopCompile*: proc (): bool {.closure.}
  usageSym*: PSym
  owners*: seq[PSym]
  methods*: seq[tuple[methods: seq[PSym], dispatcher: PSym]]
  systemModule*: PSym
  sysTypes*: array[TTypeKind, PType]
  compilerprocs*: TStrTable
  exposed*: TStrTable
  packageTypes*: TStrTable
  emptyNode*: PNode
  canonTypes*: Table[SigHash, PType]
  symBodyHashes*: Table[int, SigHash]
  importModuleCallback*: proc (graph: ModuleGraph; m: PSym; fileIdx: FileIndex): PSym {.
      nimcall.}
  includeFileCallback*: proc (graph: ModuleGraph; m: PSym; fileIdx: FileIndex): PNode {.
      nimcall.}
  cacheSeqs*: Table[string, PNode]
  cacheCounters*: Table[string, BiggestInt]
  cacheTables*: Table[string, BTree[string, PNode]]
  passes*: seq[TPass]
  onDefinition*: proc (graph: ModuleGraph; s: PSym; info: TLineInfo) {.nimcall.}
  onDefinitionResolveForward*: proc (graph: ModuleGraph; s: PSym;
                                     info: TLineInfo) {.nimcall.}
  onUsage*: proc (graph: ModuleGraph; s: PSym; info: TLineInfo) {.nimcall.}
  globalDestructors*: seq[PNode]
  strongSemCheck*: proc (graph: ModuleGraph; owner: PSym; body: PNode) {.nimcall.}
  compatibleProps*: proc (graph: ModuleGraph; formal, actual: PType): bool {.
      nimcall.}
  idgen*: IdGenerator
  operators*: Operators

ModuleIter = object
  fromRod: bool
  modIndex: int
  ti: TIdentIter
  rodIt: RodIter
  importHidden: bool

Operators = object
  opNot*, opContains*, opLe*, opLt*, opAnd*, opOr*, opIsNil*, opEq*: PSym
  opAdd*, opSub*, opMul*, opDiv*, opLen*: PSym

PPassContext = ref TPassContext

SigHash = distinct MD5Digest

TPass = tuple[open: TPassOpen, process: TPassProcess, close: TPassClose,
              isFrontend: bool]

TPassClose = proc (graph: ModuleGraph; p: PPassContext; n: PNode): PNode {.
    nimcall.}

TPassContext = object of RootObj
  idgen*: IdGenerator

TPassOpen = proc (graph: ModuleGraph; module: PSym; idgen: IdGenerator): PPassContext {.
    nimcall.}

TPassProcess = proc (p: PPassContext; topLevelStmt: PNode): PNode {.nimcall.}

proc `$`(u: SigHash): string {....raises: [], tags: [].}

proc `==`(a, b: SigHash): bool {....raises: [], tags: [].}

proc addDep(g: ModuleGraph; m: PSym; dep: FileIndex) {....raises: [], tags: [].}

proc addIncludeDep(g: ModuleGraph; module, includeFile: FileIndex) {....raises: [],
    tags: [].}

proc addMethodToGeneric(g: ModuleGraph; module: int; t: PType; col: int; m: PSym) {.
    ...raises: [], tags: [].}

proc closeRodFile(g: ModuleGraph; m: PSym) {.
    ...raises: [Exception, IOError, OSError, KeyError], tags: [RootEffect,
    WriteIOEffect, WriteDirEffect, ReadEnvEffect, ReadIOEffect, ReadDirEffect].}

proc completePartialOp(g: ModuleGraph; module: int; t: PType;
                       op: TTypeAttachedOp; value: PSym) {....raises: [], tags: [].}

proc configComplete(g: ModuleGraph) {....raises: [], tags: [].}

proc copyTypeProps(g: ModuleGraph; module: int; dest, src: PType) {....raises: [],
    tags: [].}

proc createMagic(g: ModuleGraph; idgen: IdGenerator; name: string; m: TMagic): PSym {.
    ...raises: [], tags: [].}

proc getAttachedOp(g: ModuleGraph; t: PType; op: TTypeAttachedOp): PSym {.
    ...raises: [], tags: [].}

proc getBody(g: ModuleGraph; s: PSym): PNode {.inline,
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc getModule(g: ModuleGraph; fileIdx: FileIndex): PSym {....raises: [], tags: [].}

proc getToStringProc(g: ModuleGraph; t: PType): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc hasDisabledAsgn(g: ModuleGraph; t: PType): bool {....raises: [], tags: [].}

proc hash(u: SigHash): Hash {....raises: [], tags: [].}

proc hash(x: FileIndex): Hash {.borrow, ...raises: [], tags: [].}

proc initEncoder(g: ModuleGraph; module: PSym) {....raises: [IOError],
    tags: [ReadIOEffect].}

proc initModuleIter(mi: var ModuleIter; g: ModuleGraph; m: PSym; name: PIdent): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc initOperators(g: ModuleGraph): Operators {....raises: [], tags: [].}

proc initStrTables(g: ModuleGraph; m: PSym) {....raises: [], tags: [].}

proc isDirty(g: ModuleGraph; m: PSym): bool {....raises: [], tags: [].}

proc loadCompilerProc(g: ModuleGraph; name: string): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc loadPackedSym(g: ModuleGraph; s: var LazySym) {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc markClientsDirty(g: ModuleGraph; fileIdx: FileIndex) {....raises: [], tags: [].}

proc markDirty(g: ModuleGraph; fileIdx: FileIndex) {....raises: [], tags: [].}

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

proc moduleOpenForCodegen(g: ModuleGraph; m: FileIndex): bool {.inline,
    ...raises: [], tags: [].}

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

proc nextModuleIter(mi: var ModuleIter; g: ModuleGraph): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc onProcessing(graph: ModuleGraph; fileIdx: FileIndex; moduleStatus: string;
                  fromModule: PSym) {....raises: [Exception, KeyError, OSError,
    ValueError, IOError, ERecoverableError], tags: [RootEffect, ReadDirEffect,
    WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc parentModule(g: ModuleGraph; fileIdx: FileIndex): FileIndex {....raises: [],
    tags: [].}

proc registerModule(g: ModuleGraph; m: PSym) {....raises: [Exception],
    tags: [RootEffect].}

proc registerModuleById(g: ModuleGraph; m: FileIndex) {....raises: [Exception],
    tags: [RootEffect].}

proc rememberEmittedTypeInfo(g: ModuleGraph; m: FileIndex; ti: string) {.
    ...raises: [], tags: [].}

proc rememberFlag(g: ModuleGraph; m: PSym; flag: ModuleBackendFlag) {.
    ...raises: [], tags: [].}

proc resetAllModules(g: ModuleGraph) {....raises: [], tags: [].}

proc resetForBackend(g: ModuleGraph) {....raises: [], tags: [].}

proc setAttachedOp(g: ModuleGraph; module: int; t: PType; op: TTypeAttachedOp;
                   value: PSym) {....raises: [], tags: [].}

proc setAttachedOpPartial(g: ModuleGraph; module: int; t: PType;
                          op: TTypeAttachedOp; value: PSym) {....raises: [],
    tags: [].}

proc setToStringProc(g: ModuleGraph; t: PType; value: PSym) {....raises: [],
    tags: [].}

proc simulateCachedModule(g: ModuleGraph; moduleSym: PSym; m: PackedModule) {.
    ...raises: [KeyError, OSError, Exception], tags: [ReadDirEffect, RootEffect].}

proc someSym(g: ModuleGraph; m: PSym; name: PIdent): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc stopCompile(g: ModuleGraph): bool {.inline, ...raises: [Exception],
    tags: [RootEffect].}

proc strTableAdds(g: ModuleGraph; m: PSym; s: PSym) {....raises: [], tags: [].}

proc systemModuleSym(g: ModuleGraph; name: PIdent): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

iterator allSyms(g: ModuleGraph; m: PSym): PSym {....raises: [KeyError, Exception],
    tags: [ReadDirEffect, RootEffect].}

iterator methodsForGeneric(g: ModuleGraph; t: PType): (int, PSym) {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

iterator procInstCacheItems(g: ModuleGraph; s: PSym): PInstantiation {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

iterator systemModuleSyms(g: ModuleGraph; name: PIdent): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

iterator typeInstCacheItems(g: ModuleGraph; s: PSym): PType {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

template onDef(info: TLineInfo; s: PSym)

template onDefResolveForward(info: TLineInfo; s: PSym)

template onUse(info: TLineInfo; s: PSym)

template semtabAll(g: ModuleGraph; m: PSym): TStrTable