TOptionEntry = object
  options*: TOptions
  defaultCC*: TCallingConvention
  dynlib*: PLib
  notes*: TNoteKinds
  features*: set[Feature]
  otherPragmas*: PNode
  warningAsErrors*: TNoteKinds

POptionEntry = ref TOptionEntry

PProcCon = ref TProcCon

TProcCon {...}{.acyclic.} = object
  owner*: PSym
  resultSym*: PSym
  selfSym*: PSym
  nestedLoopCounter*: int
  nestedBlockCounter*: int
  inTryStmt*: int
  next*: PProcCon
  mappingExists*: bool
  mapping*: TIdTable
  caseContext*: seq[tuple[n: PNode, idx: int]]
  localBindStmts*: seq[PNode]

TMatchedConcept = object
  candidateType*: PType
  prev*: ptr TMatchedConcept
  depth*: int

TInstantiationPair = object
  genericSym*: PSym
  inst*: PInstantiation

TExprFlag = enum
  efLValue, efWantIterator, efInTypeof, efNeedStatic, efPreferStatic,
  efPreferNilResult, efWantStmt, efAllowStmt, efDetermineType, efExplain,
  efAllowDestructor, efWantValue, efOperand, efNoSemCheck, efNoEvaluateGeneric,
  efInCall, efFromHlo, efNoSem2Check, efNoUndeclared

TExprFlags = set[TExprFlag]

PContext = ref TContext

TContext = object of TPassContext
  enforceVoidContext*: PType
  module*: PSym
  currentScope*: PScope
  importTable*: PScope
  topLevelScope*: PScope
  p*: PProcCon
  matchedConcept*: ptr TMatchedConcept
  friendModules*: seq[PSym]
  instCounter*: int
  templInstCounter*: ref int
  ambiguousSymbols*: IntSet
  inGenericContext*: int
  inStaticContext*: int
  inUnrolledContext*: int
  compilesContextId*: int
  compilesContextIdGenerator*: int
  inGenericInst*: int
  converters*: seq[PSym]
  patterns*: seq[PSym]
  optionStack*: seq[POptionEntry]
  symMapping*: TIdTable
  libs*: seq[PLib]
  semConstExpr*: proc (c: PContext; n: PNode): PNode {...}{.nimcall.}
  semExpr*: proc (c: PContext; n: PNode; flags: TExprFlags = {}): PNode {...}{.
      nimcall.}
  semTryExpr*: proc (c: PContext; n: PNode; flags: TExprFlags = {}): PNode {...}{.
      nimcall.}
  semTryConstExpr*: proc (c: PContext; n: PNode): PNode {...}{.nimcall.}
  computeRequiresInit*: proc (c: PContext; t: PType): bool {...}{.nimcall.}
  hasUnresolvedArgs*: proc (c: PContext; n: PNode): bool
  semOperand*: proc (c: PContext; n: PNode; flags: TExprFlags = {}): PNode {...}{.
      nimcall.}
  semConstBoolExpr*: proc (c: PContext; n: PNode): PNode {...}{.nimcall.}
  semOverloadedCall*: proc (c: PContext; n, nOrig: PNode; filter: TSymKinds;
                            flags: TExprFlags): PNode {...}{.nimcall.}
  semTypeNode*: proc (c: PContext; n: PNode; prev: PType): PType {...}{.nimcall.}
  semInferredLambda*: proc (c: PContext; pt: TIdTable; n: PNode): PNode
  semGenerateInstance*: proc (c: PContext; fn: PSym; pt: TIdTable;
                              info: TLineInfo): PSym
  includedFiles*: IntSet
  pureEnumFields*: TStrTable
  userPragmas*: TStrTable
  evalContext*: PEvalContext
  unknownIdents*: IntSet
  generics*: seq[TInstantiationPair]
  topStmts*: int
  lastGenericIdx*: int
  hloLoopDetector*: int
  inParallelStmt*: int
  instTypeBoundOp*: proc (c: PContext; dc: PSym; t: PType; info: TLineInfo;
                          op: TTypeAttachedOp; col: int): PSym {...}{.nimcall.}
  selfName*: PIdent
  cache*: IdentCache
  graph*: ModuleGraph
  signatures*: TStrTable
  recursiveDep*: string
  suggestionsMade*: bool
  features*: set[Feature]
  inTypeContext*: int
  typesWithOps*: seq[(PType, PType)]
  unusedImports*: seq[(PSym, TLineInfo)]
  exportIndirections*: HashSet[(int, int)]
  lastTLineInfo*: TLineInfo

proc makeInstPair(s: PSym; inst: PInstantiation): TInstantiationPair {...}{.
    raises: [], tags: [].}

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

proc scopeDepth(c: PContext): int {...}{.inline, raises: [], tags: [].}

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

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

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

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

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

proc put(p: PProcCon; key, val: PSym) {...}{.raises: [], tags: [].}

proc get(p: PProcCon; key: PSym): PSym {...}{.raises: [], tags: [].}

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

proc considerGenSyms(c: PContext; n: PNode) {...}{.raises: [], tags: [].}

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

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

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

proc newContext(graph: ModuleGraph; module: PSym): PContext {...}{.raises: [],
    tags: [].}

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

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

proc newLib(kind: TLibKind): PLib {...}{.raises: [], tags: [].}

proc addToLib(lib: PLib; sym: PSym) {...}{.raises: [], tags: [].}

proc newTypeS(kind: TTypeKind; c: PContext): PType {...}{.raises: [], tags: [].}

proc makePtrType(owner: PSym; baseType: PType): PType {...}{.raises: [], tags: [].}

proc makePtrType(c: PContext; baseType: PType): PType {...}{.raises: [], tags: [].}

proc makeTypeWithModifier(c: PContext; modifier: TTypeKind; baseType: PType): PType {...}{.
    raises: [], tags: [].}

proc makeVarType(c: PContext; baseType: PType; kind = tyVar): PType {...}{.
    raises: [], tags: [].}

proc makeVarType(owner: PSym; baseType: PType; kind = tyVar): PType {...}{.
    raises: [], tags: [].}

proc makeTypeDesc(c: PContext; typ: PType): PType {...}{.raises: [], tags: [].}

proc makeTypeSymNode(c: PContext; typ: PType; info: TLineInfo): PNode {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc makeTypeFromExpr(c: PContext; n: PNode): PType {...}{.raises: [], tags: [].}

proc newTypeWithSons(owner: PSym; kind: TTypeKind; sons: seq[PType]): PType {...}{.
    raises: [], tags: [].}

proc newTypeWithSons(c: PContext; kind: TTypeKind; sons: seq[PType]): PType {...}{.
    raises: [], tags: [].}

proc makeStaticExpr(c: PContext; n: PNode): PNode {...}{.raises: [], tags: [].}

proc makeAndType(c: PContext; t1, t2: PType): PType {...}{.raises: [], tags: [].}

proc makeOrType(c: PContext; t1, t2: PType): PType {...}{.raises: [], tags: [].}

proc makeNotType(c: PContext; t1: PType): PType {...}{.raises: [], tags: [].}

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

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

proc errorNode(c: PContext; n: PNode): PNode {...}{.raises: [], tags: [].}

proc fillTypeS(dest: PType; kind: TTypeKind; c: PContext) {...}{.raises: [], tags: [].}

proc makeRangeType(c: PContext; first, last: BiggestInt; info: TLineInfo;
                   intType: PType = nil): PType {...}{.
    raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

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

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

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

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

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

proc isTopLevel(c: PContext): bool {...}{.inline, raises: [], tags: [].}

proc pushCaseContext(c: PContext; caseNode: PNode) {...}{.raises: [], tags: [].}

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

proc setCaseContextIdx(c: PContext; idx: int) {...}{.raises: [], tags: [].}

template config(c: PContext): ConfigRef

template rangeHasUnresolvedStatic(t: PType): bool