BackendConfig = object
  tconfig*: TranslationConfig ## passed on to ``mirgen``. See ``mirgen.generateCode`` for more
                              ## details
  noImported*: bool ## if ``true``, indicates that a procedure with a body should not be
                    ## treated as imported, even if it's marked as such
  

BackendEvent = object
  module*: FileIndex ## the module in whose context the processing happens. For actions
                     ## related to .inline procedures, this is not necessarily the module
                     ## the symbol is attached to
  case kind*: BackendEventKind
  of bekDiscovered:
      entity*: MirNode       ## a reference to the discovered entity
    
  of bekModule:
      nil

  of bekConstant:
      cnst*: ConstId         ## the ID of the constant
    
  of bekPartial, bekProcedure, bekImported:
      id*: ProcedureId       ## the ID of the procedure
      sym*: PSym             ## the symbol of the procedure the event is about
                             ## XXX: only here for convenience, remove it once feasible
      body*: MirBody

  

BackendEventKind = enum
  bekDiscovered, ## a new entity was discovered during MIR processing. This
                  ## 
                  ## event is meant to be used for pre-processing of symbols
                  ## and 
                  ## registration with the code generators -- the
                  ## environment must not be modified during processing of
                  ## this event
  bekModule,                ## the initial set of alive entities for a module was
                             ## discovered
  bekConstant,              ## a complete constant was processed and transformed
  bekPartial, ## a fragment of a procedure that's generated incrementally
               ## became 
               ## available
  bekProcedure,             ## a complete procedure was processed and transformed
  bekImported                ## an alive runtime-imported procedure finished processing

DiscoveryData = object
  progress: EnvCheckpoint ## tracks how much of the environment was already processed (e.g.,
                          ## translated, scanned, etc.)
  libs*: seq[LibId]          ## all dynamic libraries that the alive graph depends on
  overrides: Table[ProcedureId, FileIndex] ## maps a procedure to the module it needs to be queued with.
                                           ## If not overriden, a procedure is queued with the module it's
                                           ## discovered from.
  

func discoverFrom(env: var MirEnv; decl: PNode) {....raises: [], tags: [].}

proc generateIR(graph: ModuleGraph; idgen: IdGenerator; env: var MirEnv;
                owner: PSym; body: sink MirBody): Body {.
    ...raises: [Exception, KeyError, ValueError, ERecoverableError],
    tags: [RootEffect, ReadDirEffect].}

proc generateMain(graph: ModuleGraph; modules: ModuleList; result: PNode) {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc generateMainProcedure(graph: ModuleGraph; idgen: IdGenerator;
                           modules: ModuleList): PSym {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc generateTeardown(graph: ModuleGraph; modules: ModuleList; result: PNode) {.
    ...raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc generateThreadTeardown(graph: ModuleGraph; modules: ModuleList;
                            result: PNode) {....raises: [KeyError, Exception],
    tags: [ReadDirEffect, RootEffect].}

func isEmpty(f: MirBody): bool {.inline, ...raises: [], tags: [].}

func isEmpty(tree: MirTree): bool {....raises: [], tags: [].}

func moduleId(o: PIdObj): int32 {.inline, ...raises: [], tags: [].}

proc preprocess(queue: var WorkQueue; graph: ModuleGraph; idgen: IdGenerator;
                env: MirEnv; id: ProcedureId; module: FileIndex) {.
    ...raises: [KeyError, Exception, ERecoverableError, ValueError],
    tags: [ReadDirEffect, RootEffect].}

func setModuleOverride(discovery: var DiscoveryData; id: ProcedureId;
                       module: FileIndex) {....raises: [], tags: [].}

proc translate(id: ProcedureId; body: PNode; graph: ModuleGraph;
               config: BackendConfig; idgen: IdGenerator; env: var MirEnv): MirBody {.
    ...raises: [Exception, ERecoverableError, KeyError, ValueError, IOError],
    tags: [RootEffect, ReadDirEffect, WriteIOEffect].}

iterator deps(tree: MirTree): lent MirNode {....raises: [], tags: [].}

iterator discover(env: var MirEnv; progress: EnvCheckpoint): tuple[s: PSym,
    n: MirNode] {....raises: [Exception, ERecoverableError, KeyError],
                  tags: [RootEffect, ReadDirEffect].}

iterator process(graph: ModuleGraph; modules: var ModuleList; env: var MirEnv;
                 discovery: var DiscoveryData; conf: BackendConfig): BackendEvent {.
    ...raises: [Exception, KeyError, ERecoverableError, ValueError, IOError],
    tags: [RootEffect, ReadDirEffect, WriteIOEffect].}