TOverloadIterMode = enum
  oimDone, oimNoQualifier, oimSelfModule, oimOtherModule, oimSymChoice,
  oimSymChoiceLocalLookup

TOverloadIter = object
  it*: TIdentIter
  m*: PSym
  mode*: TOverloadIterMode
  symChoiceIndex*: int
  scope*: PScope
  inSymChoice: IntSet

TLookupFlag = enum
  checkAmbiguity, checkUndeclared, checkModule, checkPureEnumFields

proc considerQuotedIdent(c: PContext; n: PNode; origin: PNode = nil): PIdent {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc addUniqueSym(scope: PScope; s: PSym): PSym {...}{.raises: [], tags: [].}

proc openScope(c: PContext): PScope {...}{.discardable, raises: [], tags: [].}

proc rawCloseScope(c: PContext) {...}{.raises: [], tags: [].}

proc closeScope(c: PContext) {...}{.raises: [Exception], tags: [RootEffect].}

proc skipAlias(s: PSym; n: PNode; conf: ConfigRef): PSym {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [ReadIOEffect, RootEffect, WriteIOEffect, ReadEnvEffect].}

proc isShadowScope(s: PScope): bool {...}{.inline, raises: [], tags: [].}

proc localSearchInScope(c: PContext; s: PIdent): PSym {...}{.raises: [], tags: [].}

proc searchInScopes(c: PContext; s: PIdent): PSym {...}{.raises: [], tags: [].}

proc debugScopes(c: PContext; limit = 0) {...}{.deprecated, raises: [], tags: [].}

proc searchInScopes(c: PContext; s: PIdent; filter: TSymKinds): PSym {...}{.
    raises: [], tags: [].}

proc errorSym(c: PContext; n: PNode): PSym {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc getSymRepr(conf: ConfigRef; s: PSym): string {...}{.raises: [Exception],
    tags: [RootEffect].}

proc wrongRedefinition(c: PContext; info: TLineInfo; s: string;
                       conflictsWith: TLineInfo) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc addDecl(c: PContext; sym: PSym; info: TLineInfo) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc addDecl(c: PContext; sym: PSym) {...}{.raises: [Exception, ValueError, IOError,
    ERecoverableError], tags: [RootEffect, WriteIOEffect, ReadIOEffect,
                               ReadEnvEffect].}

proc addPrelimDecl(c: PContext; sym: PSym) {...}{.raises: [], tags: [].}

proc addDeclAt(c: PContext; scope: PScope; sym: PSym) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc addInterfaceDeclAt(c: PContext; scope: PScope; sym: PSym) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc addOverloadableSymAt(c: PContext; scope: PScope; fn: PSym) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc addInterfaceDecl(c: PContext; sym: PSym) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc addInterfaceOverloadableSymAt(c: PContext; scope: PScope; sym: PSym) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc openShadowScope(c: PContext) {...}{.raises: [], tags: [].}

proc closeShadowScope(c: PContext) {...}{.raises: [Exception], tags: [RootEffect].}

proc mergeShadowScope(c: PContext) {...}{.raises: [Exception, ValueError, IOError,
    ERecoverableError], tags: [RootEffect, WriteIOEffect, ReadIOEffect,
                               ReadEnvEffect].}

proc errorUseQualifier(c: PContext; info: TLineInfo; s: PSym) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc errorUndeclaredIdentifier(c: PContext; info: TLineInfo; name: string) {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc lookUp(c: PContext; n: PNode): PSym {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [ReadIOEffect, RootEffect, WriteIOEffect, ReadEnvEffect].}

proc qualifiedLookUp(c: PContext; n: PNode; flags: set[TLookupFlag]): PSym {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc initOverloadIter(o: var TOverloadIter; c: PContext; n: PNode): PSym {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc lastOverloadScope(o: TOverloadIter): int {...}{.raises: [], tags: [].}

proc nextOverloadIter(o: var TOverloadIter; c: PContext; n: PNode): PSym {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [ReadIOEffect, RootEffect, WriteIOEffect, ReadEnvEffect].}

proc pickSym(c: PContext; n: PNode; kinds: set[TSymKind]; flags: TSymFlags = {}): PSym {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

iterator walkScopes(scope: PScope): PScope {...}{.raises: [], tags: [].}

template addSym(scope: PScope; s: PSym)