CompilesId = int

IdGenerator = ref object
  module*: int32
  symId*: int32
  typeId*: int32
  sealed*: bool

ItemId = object
  module*: int32
  item*: int32

PIdObj = ref TIdObj

PInstantiation = ref TInstantiation

PLib = ref TLib

PNode = ref TNode

PScope = ref TScope

PSym = ref TSym

PType = ref TType

TCallingConvention = enum
  ccNimCall = "nimcall", ccStdCall = "stdcall", ccCDecl = "cdecl",
  ccSafeCall = "safecall", ccSysCall = "syscall", ccInline = "inline",
  ccNoInline = "noinline", ccFastCall = "fastcall", ccThisCall = "thiscall",
  ccClosure = "closure", ccNoConvention = "noconv"

TIdNodePair = object
  key*: PIdObj
  val*: PNode

TIdNodePairSeq = seq[TIdNodePair]

TIdNodeTable = object
  counter*: int
  data*: TIdNodePairSeq

TIdObj {.acyclic.} = object of RootObj
  itemId*: ItemId

TIdPair = object
  key*: PIdObj
  val*: RootRef

TIdPairSeq = seq[TIdPair]

TIdTable = object
  counter*: int
  data*: TIdPairSeq

TImplication = enum
  impUnknown, impNo, impYes

TInstantiation = object
  sym*: PSym
  concreteTypes*: seq[PType]
  compilesId*: CompilesId

TLib = object
  kind*: TLibKind
  generated*: bool
  isOverriden*: bool
  name*: Rope
  path*: PNode

TLibKind = enum
  libHeader, libDynamic

TLoc = object
  k*: TLocKind
  storage*: TStorageLoc
  flags*: TLocFlags
  lode*: PNode
  r*: Rope

TLocFlag = enum
  lfIndirect, lfFullExternalName, lfNoDeepCopy, lfNoDecl, lfDynamicLib,
  lfExportLib, lfHeader, lfImportCompilerProc, lfSingleUse, lfEnforceDeref,
  lfPrepareForMutation

TLocFlags = set[TLocFlag]

TLocKind = enum
  locNone, locTemp, locLocalVar, locGlobalVar, locParam, locField, locExpr,
  locProc, locData, locCall, locOther

TLockLevel = distinct int16

TMagic = enum
  mNone, mDefined, mDeclared, mDeclaredInScope, mCompiles, mArrGet, mArrPut,
  mAsgn, mLow, mHigh, mSizeOf, mAlignOf, mOffsetOf, mTypeTrait, mIs, mOf, mAddr,
  mType, mTypeOf, mPlugin, mEcho, mShallowCopy, mSlurp, mStaticExec, mStatic,
  mParseExprToAst, mParseStmtToAst, mExpandToAst, mQuoteAst, mInc, mDec, mOrd,
  mNew, mNewFinalize, mNewSeq, mNewSeqOfCap, mLengthOpenArray, mLengthStr,
  mLengthArray, mLengthSeq, mIncl, mExcl, mCard, mChr, mGCref, mGCunref, mAddI,
  mSubI, mMulI, mDivI, mModI, mSucc, mPred, mAddF64, mSubF64, mMulF64, mDivF64,
  mShrI, mShlI, mAshrI, mBitandI, mBitorI, mBitxorI, mMinI, mMaxI, mAddU, mSubU,
  mMulU, mDivU, mModU, mEqI, mLeI, mLtI, mEqF64, mLeF64, mLtF64, mLeU, mLtU,
  mEqEnum, mLeEnum, mLtEnum, mEqCh, mLeCh, mLtCh, mEqB, mLeB, mLtB, mEqRef,
  mLePtr, mLtPtr, mXor, mEqCString, mEqProc, mUnaryMinusI, mUnaryMinusI64,
  mAbsI, mNot, mUnaryPlusI, mBitnotI, mUnaryPlusF64, mUnaryMinusF64, mCharToStr,
  mBoolToStr, mIntToStr, mInt64ToStr, mFloatToStr, mCStrToStr, mStrToStr,
  mEnumToStr, mAnd, mOr, mImplies, mIff, mExists, mForall, mOld, mEqStr, mLeStr,
  mLtStr, mEqSet, mLeSet, mLtSet, mMulSet, mPlusSet, mMinusSet, mConStrStr,
  mSlice, mDotDot, mFields, mFieldPairs, mOmpParFor, mAppendStrCh,
  mAppendStrStr, mAppendSeqElem, mInSet, mRepr, mExit, mSetLengthStr,
  mSetLengthSeq, mIsPartOf, mAstToStr, mParallel, mSwap, mIsNil, mArrToSeq,
  mNewString, mNewStringOfCap, mParseBiggestFloat, mMove, mWasMoved, mDestroy,
  mTrace, mDefault, mUnown, mFinished, mIsolate, mAccessEnv, mAccessTypeField,
  mReset, mArray, mOpenArray, mRange, mSet, mSeq, mVarargs, mRef, mPtr, mVar,
  mDistinct, mVoid, mTuple, mOrdinal, mIterableType, mInt, mInt8, mInt16,
  mInt32, mInt64, mUInt, mUInt8, mUInt16, mUInt32, mUInt64, mFloat, mFloat32,
  mFloat64, mFloat128, mBool, mChar, mString, mCstring, mPointer, mNil, mExpr,
  mStmt, mTypeDesc, mVoidType, mPNimrodNode, mSpawn, mDeepCopy, mIsMainModule,
  mCompileDate, mCompileTime, mProcCall, mCpuEndian, mHostOS, mHostCPU,
  mBuildOS, mBuildCPU, mAppType, mCompileOption, mCompileOptionArg, mNLen,
  mNChild, mNSetChild, mNAdd, mNAddMultiple, mNDel, mNKind, mNSymKind,
  mNccValue, mNccInc, mNcsAdd, mNcsIncl, mNcsLen, mNcsAt, mNctPut, mNctLen,
  mNctGet, mNctHasNext, mNctNext, mNIntVal, mNFloatVal, mNSymbol, mNIdent,
  mNGetType, mNStrVal, mNSetIntVal, mNSetFloatVal, mNSetSymbol, mNSetIdent,
  mNSetType, mNSetStrVal, mNLineInfo, mNNewNimNode, mNCopyNimNode,
  mNCopyNimTree, mStrToIdent, mNSigHash, mNSizeOf, mNBindSym, mNCallSite,
  mEqIdent, mEqNimrodNode, mSameNodeType, mGetImpl, mNGenSym, mNHint, mNWarning,
  mNError, mInstantiationInfo, mGetTypeInfo, mGetTypeInfoV2, mNimvm, mIntDefine,
  mStrDefine, mBoolDefine, mRunnableExamples, mException, mBuiltinType,
  mSymOwner, mUncheckedArray, mGetImplTransf, mSymIsInstantiationOf, mNodeId,
  mPrivateAccess

TNode {.final, acyclic.} = object
  when defined(useNodeIds):
      id*: int

  typ*: PType
  info*: TLineInfo
  flags*: TNodeFlags
  case kind*: TNodeKind
  of nkCharLit .. nkUInt64Lit:
      intVal*: BiggestInt

  of nkFloatLit .. nkFloat128Lit:
      floatVal*: BiggestFloat

  of nkStrLit .. nkTripleStrLit:
      strVal*: string

  of nkSym:
      sym*: PSym

  of nkIdent:
      ident*: PIdent

  else:
      sons*: TNodeSeq

  when defined(nimsuggest):
      endInfo*: TLineInfo

  

TNodeFlag = enum
  nfNone, nfBase2, nfBase8, nfBase16, nfAllConst, nfTransf, nfNoRewrite, nfSem,
  nfLL, nfDotField, nfDotSetter, nfExplicitCall, nfExprCall, nfIsRef, nfIsPtr,
  nfPreventCg, nfBlockArg, nfFromTemplate, nfDefaultParam, nfDefaultRefsParam,
  nfExecuteOnReload, nfLastRead, nfFirstWrite, nfHasComment

TNodeFlags = set[TNodeFlag]

TNodeKind = enum
  nkNone, nkEmpty, nkIdent, nkSym, nkType, nkCharLit, nkIntLit, nkInt8Lit,
  nkInt16Lit, nkInt32Lit, nkInt64Lit, nkUIntLit, nkUInt8Lit, nkUInt16Lit,
  nkUInt32Lit, nkUInt64Lit, nkFloatLit, nkFloat32Lit, nkFloat64Lit,
  nkFloat128Lit, nkStrLit, nkRStrLit, nkTripleStrLit, nkNilLit, nkComesFrom,
  nkDotCall, nkCommand, nkCall, nkCallStrLit, nkInfix, nkPrefix, nkPostfix,
  nkHiddenCallConv, nkExprEqExpr, nkExprColonExpr, nkIdentDefs, nkVarTuple,
  nkPar, nkObjConstr, nkCurly, nkCurlyExpr, nkBracket, nkBracketExpr,
  nkPragmaExpr, nkRange, nkDotExpr, nkCheckedFieldExpr, nkDerefExpr, nkIfExpr,
  nkElifExpr, nkElseExpr, nkLambda, nkDo, nkAccQuoted, nkTableConstr, nkBind,
  nkClosedSymChoice, nkOpenSymChoice, nkHiddenStdConv, nkHiddenSubConv, nkConv,
  nkCast, nkStaticExpr, nkAddr, nkHiddenAddr, nkHiddenDeref, nkObjDownConv,
  nkObjUpConv, nkChckRangeF, nkChckRange64, nkChckRange, nkStringToCString,
  nkCStringToString, nkAsgn, nkFastAsgn, nkGenericParams, nkFormalParams,
  nkOfInherit, nkImportAs, nkProcDef, nkMethodDef, nkConverterDef, nkMacroDef,
  nkTemplateDef, nkIteratorDef, nkOfBranch, nkElifBranch, nkExceptBranch,
  nkElse, nkAsmStmt, nkPragma, nkPragmaBlock, nkIfStmt, nkWhenStmt, nkForStmt,
  nkParForStmt, nkWhileStmt, nkCaseStmt, nkTypeSection, nkVarSection,
  nkLetSection, nkConstSection, nkConstDef, nkTypeDef, nkYieldStmt, nkDefer,
  nkTryStmt, nkFinally, nkRaiseStmt, nkReturnStmt, nkBreakStmt, nkContinueStmt,
  nkBlockStmt, nkStaticStmt, nkDiscardStmt, nkStmtList, nkImportStmt,
  nkImportExceptStmt, nkExportStmt, nkExportExceptStmt, nkFromStmt,
  nkIncludeStmt, nkBindStmt, nkMixinStmt, nkUsingStmt, nkCommentStmt,
  nkStmtListExpr, nkBlockExpr, nkStmtListType, nkBlockType, nkWith, nkWithout,
  nkTypeOfExpr, nkObjectTy, nkTupleTy, nkTupleClassTy, nkTypeClassTy,
  nkStaticTy, nkRecList, nkRecCase, nkRecWhen, nkRefTy, nkPtrTy, nkVarTy,
  nkConstTy, nkMutableTy, nkDistinctTy, nkProcTy, nkIteratorTy, nkSharedTy,
  nkEnumTy, nkEnumFieldDef, nkArgList, nkPattern, nkHiddenTryStmt, nkClosure,
  nkGotoState, nkState, nkBreakState, nkFuncDef, nkTupleConstr, nkError,
  nkModuleRef, nkReplayAction, nkNilRodNode

TNodeKinds = set[TNodeKind]

TNodePair = object
  h*: Hash
  key*: PNode
  val*: int

TNodePairSeq = seq[TNodePair]

TNodeSeq = seq[PNode]

TNodeTable = object
  counter*: int
  data*: TNodePairSeq

TObjectSeq = seq[RootRef]

TObjectSet = object
  counter*: int
  data*: TObjectSeq

TPair = object
  key*, val*: RootRef

TPairSeq = seq[TPair]

TScope {.acyclic.} = object
  depthLevel*: int
  symbols*: TStrTable
  parent*: PScope
  allowPrivateAccess*: seq[PSym]

TStorageLoc = enum
  OnUnknown, OnStatic, OnStack, OnHeap

TStrTable = object
  counter*: int
  data*: seq[PSym]

TSym {.acyclic.} = object of TIdObj
  case kind*: TSymKind
  of routineKinds:
      gcUnsafetyReason*: PSym
      transformedBody*: PNode

  of skLet, skVar, skField, skForVar:
      guard*: PSym
      bitsize*: int
      alignment*: int

  else:
    nil
  magic*: TMagic
  typ*: PType
  name*: PIdent
  info*: TLineInfo
  when defined(nimsuggest):
      endInfo*: TLineInfo

  owner*: PSym
  flags*: TSymFlags
  ast*: PNode
  options*: TOptions
  position*: int
  offset*: int
  loc*: TLoc
  annex*: PLib
  when hasFFI:
      cname*: string

  constraint*: PNode
  when defined(nimsuggest):
      allUsages*: seq[TLineInfo]

  

TSymFlag = enum
  sfUsed, sfExported, sfFromGeneric, sfGlobal, sfForward, sfWasForwarded,
  sfImportc, sfExportc, sfMangleCpp, sfVolatile, sfRegister, sfPure,
  sfNoSideEffect, sfSideEffect, sfMainModule, sfSystemModule, sfNoReturn,
  sfAddrTaken, sfCompilerProc, sfProcvar, sfDiscriminant, sfRequiresInit,
  sfDeprecated, sfExplain, sfError, sfShadowed, sfThread, sfCppNonPod,
  sfCompileTime, sfConstructor, sfDispatcher, sfBorrow, sfInfixCall,
  sfNamedParamCall, sfDiscardable, sfOverriden, sfCallsite, sfGenSym,
  sfNonReloadable, sfGeneratedOp, sfTemplateParam, sfCursor,
  sfInjectDestructors, sfNeverRaises, sfUsedInFinallyOrExcept, sfSingleUsedTemp,
  sfNoalias, sfEffectsDelayed

TSymFlags = set[TSymFlag]

TSymKind = enum
  skUnknown, skConditional, skDynLib, skParam, skGenericParam, skTemp, skModule,
  skType, skVar, skLet, skConst, skResult, skProc, skFunc, skMethod, skIterator,
  skConverter, skMacro, skTemplate, skField, skEnumField, skForVar, skLabel,
  skStub, skPackage, skAlias

TSymKinds = set[TSymKind]

TType {.acyclic.} = object of TIdObj
  kind*: TTypeKind
  callConv*: TCallingConvention
  flags*: TTypeFlags
  sons*: TTypeSeq
  n*: PNode
  owner*: PSym
  sym*: PSym
  size*: BiggestInt
  align*: int16
  paddingAtEnd*: int16
  lockLevel*: TLockLevel
  loc*: TLoc
  typeInst*: PType
  uniqueId*: ItemId

TTypeAttachedOp = enum
  attachedDestructor, attachedAsgn, attachedSink, attachedTrace,
  attachedDeepCopy

TTypeFlag = enum
  tfVarargs, tfNoSideEffect, tfFinal, tfInheritable, tfHasOwned, tfEnumHasHoles,
  tfShallow, tfThread, tfFromGeneric, tfUnresolved, tfResolved, tfRetType,
  tfCapturesEnv, tfByCopy, tfByRef, tfIterator, tfPartial, tfNotNil,
  tfRequiresInit, tfNeedsFullInit, tfVarIsPtr, tfHasMeta, tfHasGCedMem,
  tfPacked, tfHasStatic, tfGenericTypeParam, tfImplicitTypeParam,
  tfInferrableStatic, tfConceptMatchedTypeSym, tfExplicit, tfWildcard,
  tfHasAsgn, tfBorrowDot, tfTriggersCompileTime, tfRefsAnonObj, tfCovariant,
  tfWeakCovariant, tfContravariant, tfCheckedForDestructor, tfAcyclic,
  tfIncompleteStruct, tfCompleteStruct, tfExplicitCallConv, tfIsConstructor,
  tfEffectSystemWorkaround

TTypeFlags = set[TTypeFlag]

TTypeKind = enum
  tyNone, tyBool, tyChar, tyEmpty, tyAlias, tyNil, tyUntyped, tyTyped,
  tyTypeDesc, tyGenericInvocation, tyGenericBody, tyGenericInst, tyGenericParam,
  tyDistinct, tyEnum, tyOrdinal, tyArray, tyObject, tyTuple, tySet, tyRange,
  tyPtr, tyRef, tyVar, tySequence, tyProc, tyPointer, tyOpenArray, tyString,
  tyCstring, tyForward, tyInt, tyInt8, tyInt16, tyInt32, tyInt64, tyFloat,
  tyFloat32, tyFloat64, tyFloat128, tyUInt, tyUInt8, tyUInt16, tyUInt32,
  tyUInt64, tyOwned, tySink, tyLent, tyVarargs, tyUncheckedArray, tyProxy,
  tyBuiltInTypeClass, tyUserTypeClass, tyUserTypeClassInst,
  tyCompositeTypeClass, tyInferred, tyAnd, tyOr, tyNot, tyAnything, tyStatic,
  tyFromExpr, tyConcept, tyVoid, tyIterable

TTypeKinds = set[TTypeKind]

TTypeSeq = seq[PType]

eqTypeFlags = {tfIterator, tfNotNil, tfVarIsPtr, tfGcSafe, tfNoSideEffect}

ggDebug: bool

abstractInst = {tyGenericInst, tyDistinct, tyOrdinal, tyTypeDesc, tyAlias,
                tyInferred, tySink, tyOwned}

abstractVarRange = {tyGenericInst, tyRange, tyVar, tyDistinct, tyOrdinal,
                    tyTypeDesc, tyAlias, tyInferred, tySink, tyOwned}

AttachedOpToStr: array[TTypeAttachedOp, string] = ["=destroy", "=copy", "=sink",
    "=trace", "=deepcopy"]

bodyPos = 6

callableDefs = {nkLambda..nkDo, nkProcDef..nkIteratorDef, nkFuncDef}

ConcreteTypes: TTypeKinds = {tyBool, tyChar, tyEnum, tyArray, tyObject, tySet,
                             tyTuple, tyRange, tyPtr, tyRef, tyVar, tyLent,
                             tySequence, tyProc, tyPointer, tyOpenArray,
                             tyString, tyCstring, tyInt..tyInt64,
                             tyFloat..tyFloat128, tyUInt..tyUInt64}

ConstantDataTypes: TTypeKinds = {tyArray, tySet, tyTuple, tySequence}

ctfeWhitelist = {mNone, mSucc, mPred, mInc, mDec, mOrd, mLengthOpenArray,
                 mLengthStr, mLengthArray, mLengthSeq, mArrGet, mArrPut, mAsgn,
                 mDestroy, mIncl, mExcl, mCard, mChr, mAddI, mSubI, mMulI,
                 mDivI, mModI, mAddF64, mSubF64, mMulF64, mDivF64, mShrI, mShlI,
                 mBitandI, mBitorI, mBitxorI, mMinI, mMaxI, mAddU, mSubU, mMulU,
                 mDivU, mModU, mEqI, mLeI, mLtI, mEqF64, mLeF64, mLtF64, mLeU,
                 mLtU, mEqEnum, mLeEnum, mLtEnum, mEqCh, mLeCh, mLtCh, mEqB,
                 mLeB, mLtB, mEqRef, mEqProc, mLePtr, mLtPtr, mEqCString, mXor,
                 mUnaryMinusI, mUnaryMinusI64, mAbsI, mNot, mUnaryPlusI,
                 mBitnotI, mUnaryPlusF64, mUnaryMinusF64, mCharToStr,
                 mBoolToStr, mIntToStr, mInt64ToStr, mFloatToStr, mCStrToStr,
                 mStrToStr, mEnumToStr, mAnd, mOr, mEqStr, mLeStr, mLtStr,
                 mEqSet, mLeSet, mLtSet, mMulSet, mPlusSet, mMinusSet,
                 mConStrStr, mAppendStrCh, mAppendStrStr, mAppendSeqElem,
                 mInSet, mRepr}

declarativeDefs = {nkProcDef, nkFuncDef, nkMethodDef, nkIteratorDef,
                   nkConverterDef}

defaultOffset = -1

dispatcherPos = 8

effectListLen = 5

ensuresEffects = 2

exceptionEffects = 0

ExportableSymKinds = {skType..skConst, skProc..skTemplate, skEnumField, skStub,
                      skAlias}

GcTypeKinds = {tyRef, tySequence, tyString}

genericParamsPos = 2

GenericTypes: TTypeKinds = {tyGenericInvocation, tyGenericBody, tyGenericParam}

GrowthFactor = 2

IntegralTypes = {tyBool, tyChar, tyEnum, tyInt..tyInt64, tyFloat..tyFloat128,
                 tyUInt..tyUInt64}

MaxLockLevel = 1000'i16

miscPos = 5

namePos = 0

nfAllFieldsSet = nfBase2

NilableTypes: TTypeKinds = {tyPointer, tyCstring, tyRef, tyPtr, tyProc, tyProxy}

nkCallKinds = {nkCall, nkInfix, nkPrefix, nkPostfix, nkCommand, nkCallStrLit,
               nkHiddenCallConv}

nkEffectList = nkArgList

nkFloatLiterals = {nkFloatLit..nkFloat128Lit}

nkIdentKinds = {nkIdent, nkSym, nkAccQuoted, nkOpenSymChoice, nkClosedSymChoice}

nkLambdaKinds = {nkLambda, nkDo}

nkLastBlockStmts = {nkRaiseStmt, nkReturnStmt, nkBreakStmt, nkContinueStmt}

nkLiterals = {nkCharLit..nkTripleStrLit}

nkPragmaCallKinds = {nkExprColonExpr, nkCall, nkCallStrLit}

nkStrKinds = {nkStrLit..nkTripleStrLit}

nkSymChoices = {nkClosedSymChoice, nkOpenSymChoice}

nkWhen = nkWhenStmt

nkWhenExpr = nkWhenStmt

nodesToIgnoreSet = {nkNone..nkIdent, nkType..nkNilLit, nkTypeSection, nkProcDef,
                    nkConverterDef, nkMethodDef, nkIteratorDef, nkMacroDef,
                    nkTemplateDef, nkLambda, nkDo, nkFuncDef, nkConstSection,
                    nkConstDef, nkIncludeStmt, nkImportStmt, nkExportStmt,
                    nkPragma, nkCommentStmt, nkBreakState, nkTypeOfExpr,
                    nkMixinStmt, nkBindStmt}

OverloadableSyms = {skProc, skFunc, skMethod, skIterator, skConverter, skModule,
                    skTemplate, skMacro, skEnumField}

PackageModuleId = -3'i32

paramsPos = 3

patternPos = 1

PersistentNodeFlags: TNodeFlags = {nfBase2, nfBase8, nfBase16, nfDotSetter,
                                   nfDotField, nfIsRef, nfIsPtr, nfPreventCg,
                                   nfLL, nfFromTemplate, nfDefaultRefsParam,
                                   nfExecuteOnReload, nfLastRead, nfFirstWrite}

pragmasEffects = 4

pragmasPos = 4

procDefs = {nkLambda..nkDo, nkProcDef..nkConverterDef, nkIteratorDef, nkFuncDef}

PtrLikeKinds: TTypeKinds = {tyPointer, tyPtr}

requiresEffects = 1

resultPos = 7

routineDefs = {nkProcDef..nkIteratorDef, nkFuncDef}

routineKinds = {skProc, skFunc, skMethod, skIterator, skConverter, skMacro,
                skTemplate}

sfAllUntyped = sfVolatile

sfAnon = sfDiscardable

sfBase = sfDiscriminant

sfCompileToCpp = sfInfixCall

sfCompileToObjc = sfNamedParamCall

sfCustomPragma = sfRegister

sfDirty = sfPure

sfEscapes = sfProcvar

sfExperimental = sfOverriden

sfGoto = sfOverriden

sfIsSelf = sfOverriden

sfNoForward = sfRegister

sfNoInit = sfMainModule

sfReorder = sfForward

sfWrittenTo = sfBorrow

skError = skUnknown

skLocalVars = {skVar, skLet, skForVar, skParam, skResult}

skProcKinds = {skProc, skFunc, skTemplate, skMacro, skIterator, skMethod,
               skConverter}

StartSize = 8

StructuralEquivTypes: TTypeKinds = {tyNil, tyTuple, tyArray, tySet, tyRange,
                                    tyPtr, tyRef, tyVar, tyLent, tySequence,
                                    tyProc, tyOpenArray, tyVarargs}

tagEffects = 3

tfGcSafe = tfThread

tfObjHasKids = tfEnumHasHoles

tfReturnsNew = tfInheritable

tfUnion = tfNoSideEffect

tyError = tyProxy

tyMetaTypes = {tyUntyped, tyTypeDesc, tyGenericParam,
               tyBuiltInTypeClass..tyCompositeTypeClass, tyAnd..tyAnything}

tyPureObject = tyTuple

tyTypeClasses = {tyBuiltInTypeClass, tyCompositeTypeClass, tyUserTypeClass,
                 tyUserTypeClassInst, tyAnd, tyOr, tyNot, tyAnything}

tyUnknown = tyFromExpr

tyUnknownTypes = {tyProxy, tyFromExpr}

tyUserTypeClasses = {tyUserTypeClass, tyUserTypeClassInst}

UnknownLockLevel = 1001'i16

UnspecifiedLockLevel = -1'i16

proc `$`(s: PSym): string {....raises: [], tags: [].}

proc `$`(x: TLockLevel): string {....raises: [], tags: [].}

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

proc add(father, son: Indexable)

proc addAllowNil(father, son: Indexable) {.inline.}

proc addParam(procType: PType; param: PSym) {....raises: [], tags: [].}

proc addSonNilAllowed(father, son: PNode) {....raises: [], tags: [].}

proc appendToModule(m: PSym; n: PNode) {....raises: [], tags: [].}

proc assignType(dest, src: PType) {....raises: [], tags: [].}

proc astdef(s: PSym): PNode {....raises: [], tags: [].}

proc canRaise(fn: PNode): bool {....raises: [], tags: [].}

proc canRaiseConservative(fn: PNode): bool {....raises: [], tags: [].}

proc comment(n: PNode): string {....raises: [KeyError], tags: [].}

proc comment=(n: PNode; a: string) {....raises: [], tags: [].}

proc containsNode(n: PNode; kinds: TNodeKinds): bool {....raises: [], tags: [].}

proc copyIdTable(dest: var TIdTable; src: TIdTable) {....raises: [], tags: [].}

proc copyNode(src: PNode): PNode {....raises: [KeyError], tags: [].}

proc copyObjectSet(dest: var TObjectSet; src: TObjectSet) {....raises: [], tags: [].}

proc copyStrTable(dest: var TStrTable; src: TStrTable) {....raises: [], tags: [].}

proc copySym(s: PSym; id: ItemId): PSym {....raises: [], tags: [].}

proc copyTree(src: PNode): PNode {....raises: [KeyError], tags: [].}

proc copyTreeWithoutNode(src, skippedNode: PNode): PNode {....raises: [KeyError],
    tags: [].}

proc copyType(t: PType; id: ItemId; owner: PSym): PType {....raises: [], tags: [].}

proc createModuleAlias(s: PSym; id: ItemId; newIdent: PIdent; info: TLineInfo;
                       options: TOptions): PSym {....raises: [], tags: [].}

proc delSon(father: PNode; idx: int) {....raises: [], tags: [].}

proc discardSons(father: PNode) {....raises: [], tags: [].}

proc exactReplica(t: PType): PType {....raises: [], tags: [].}

proc findUnresolvedStatic(n: PNode): PNode {....raises: [], tags: [].}

proc getDeclPragma(n: PNode): PNode {....raises: [], tags: [].}

proc getFloat(a: PNode): BiggestFloat {....raises: [ERecoverableError], tags: [].}

proc getInt(a: PNode): Int128 {....raises: [ERecoverableError], tags: [].}

proc getInt64(a: PNode): int64 {....deprecated: "use getInt",
                                 raises: [ERecoverableError], tags: [].}

proc getPIdent(a: PNode): PIdent {.inline, ...raises: [], tags: [].}

proc getStr(a: PNode): string {....raises: [ERecoverableError], tags: [].}

proc getStrOrChar(a: PNode): string {....raises: [ERecoverableError], tags: [].}

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

proc hasNilSon(n: PNode): bool {....raises: [], tags: [].}

proc hasPattern(s: PSym): bool {.inline, ...raises: [], tags: [].}

proc hasSonWith(n: PNode; kind: TNodeKind): bool {....raises: [], tags: [].}

proc hasSubnodeWith(n: PNode; kind: TNodeKind): bool {....raises: [], tags: [].}

proc idGeneratorFromModule(m: PSym): IdGenerator {....raises: [], tags: [].}

proc initIdNodeTable(x: var TIdNodeTable) {....raises: [], tags: [].}

proc initIdTable(x: var TIdTable) {....raises: [], tags: [].}

proc initNodeTable(x: var TNodeTable) {....raises: [], tags: [].}

proc initObjectSet(x: var TObjectSet) {....raises: [], tags: [].}

proc initStrTable(x: var TStrTable) {....raises: [], tags: [].}

proc isAtom(n: PNode): bool {.inline, ...raises: [], tags: [].}

proc isCallExpr(n: PNode): bool {....raises: [], tags: [].}

proc isClosure(typ: PType): bool {.inline, ...raises: [], tags: [].}

proc isClosureIterator(typ: PType): bool {.inline, ...raises: [], tags: [].}

proc isCompileTimeProc(s: PSym): bool {.inline, ...raises: [], tags: [].}

proc isEmptyType(t: PType): bool {.inline, ...raises: [], tags: [].}

proc isGCedMem(t: PType): bool {.inline, ...raises: [], tags: [].}

proc isGenericParams(n: PNode): bool {.inline, ...raises: [], tags: [].}

proc isGenericRoutine(n: PNode): bool {.inline, ...raises: [], tags: [].}

proc isGenericRoutine(s: PSym): bool {.inline, ...raises: [], tags: [].}

proc isGenericRoutineStrict(s: PSym): bool {.inline, ...raises: [], tags: [].}

proc isImportedException(t: PType; conf: ConfigRef): bool {....raises: [], tags: [].}

proc isInfixAs(n: PNode): bool {....raises: [], tags: [].}

proc isInlineIterator(typ: PType): bool {.inline, ...raises: [], tags: [].}

proc isMetaType(t: PType): bool {....raises: [], tags: [].}

proc isNewStyleConcept(n: PNode): bool {.inline, ...raises: [], tags: [].}

proc isRoutine(s: PSym): bool {.inline, ...raises: [], tags: [].}

proc isRunnableExamples(n: PNode): bool {....raises: [], tags: [].}

proc isSinkParam(s: PSym): bool {.inline, ...raises: [], tags: [].}

proc isSinkType(t: PType): bool {.inline, ...raises: [], tags: [].}

proc isUnresolvedStatic(t: PType): bool {....raises: [], tags: [].}

proc lastSon(n: Indexable): Indexable

proc len(n: Indexable): int {.inline.}

proc linkTo(s: PSym; t: PType): PSym {.discardable, ...raises: [], tags: [].}

proc linkTo(t: PType; s: PSym): PType {.discardable, ...raises: [], tags: [].}

proc makeStmtList(n: PNode): PNode {....raises: [], tags: [].}

proc newFloatNode(kind: TNodeKind; floatVal: BiggestFloat): PNode {....raises: [],
    tags: [].}

proc newIdentNode(ident: PIdent; info: TLineInfo): PNode {....raises: [], tags: [].}

proc newIdTable(): TIdTable {....raises: [], tags: [].}

proc newIntNode(kind: TNodeKind; intVal: BiggestInt): PNode {....raises: [],
    tags: [].}

proc newIntNode(kind: TNodeKind; intVal: Int128): PNode {....raises: [], tags: [].}

proc newIntTypeNode(intVal: BiggestInt; typ: PType): PNode {....raises: [],
    tags: [].}

proc newIntTypeNode(intVal: Int128; typ: PType): PNode {....raises: [], tags: [].}

proc newNode(kind: TNodeKind): PNode {....raises: [], tags: [].}

proc newNodeI(kind: TNodeKind; info: TLineInfo): PNode {....raises: [], tags: [].}

proc newNodeI(kind: TNodeKind; info: TLineInfo; children: int): PNode {.
    ...raises: [], tags: [].}

proc newNodeIT(kind: TNodeKind; info: TLineInfo; typ: PType): PNode {.
    ...raises: [], tags: [].}

proc newProcNode(kind: TNodeKind; info: TLineInfo; body: PNode; params, name,
    pattern, genericParams, pragmas, exceptions: PNode): PNode {....raises: [],
    tags: [].}

proc newProcType(info: TLineInfo; id: ItemId; owner: PSym): PType {....raises: [],
    tags: [].}

proc newSons(father: Indexable; length: int)

proc newStrNode(kind: TNodeKind; strVal: string): PNode {....raises: [], tags: [].}

proc newStrNode(strVal: string; info: TLineInfo): PNode {....raises: [], tags: [].}

proc newStrTable(): TStrTable {....raises: [], tags: [].}

proc newSym(symKind: TSymKind; name: PIdent; id: ItemId; owner: PSym;
            info: TLineInfo; options: TOptions = {}): PSym {....raises: [],
    tags: [].}

proc newSymNode(sym: PSym): PNode {....raises: [], tags: [].}

proc newSymNode(sym: PSym; info: TLineInfo): PNode {....raises: [], tags: [].}

proc newTree(kind: TNodeKind; children: varargs[PNode]): PNode {....raises: [],
    tags: [].}

proc newTreeI(kind: TNodeKind; info: TLineInfo; children: varargs[PNode]): PNode {.
    ...raises: [], tags: [].}

proc newTreeIT(kind: TNodeKind; info: TLineInfo; typ: PType;
               children: varargs[PNode]): PNode {....raises: [], tags: [].}

proc newType(kind: TTypeKind; id: ItemId; owner: PSym): PType {....raises: [],
    tags: [].}

proc nextSymId(x: IdGenerator): ItemId {.inline, ...raises: [], tags: [].}