CompilesId = int

ItemId = object
  module*: int32
  item*: int32

ItemState = enum
  Complete, Partial, Sealed

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", ccMember = "member"

TIdPair[T] = object
  key*: ItemId
  val*: T

TIdPairSeq[T] = seq[TIdPair[T]]

TIdTable[T] = object
  counter*: int
  data*: TIdPairSeq[T]

TImplication = enum
  impUnknown, impNo, impYes

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

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

TLibKind = enum
  libHeader, libDynamic

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

TLocFlag = enum
  lfIndirect, 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

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, mCStrToStr, mStrToStr, mEnumToStr, mAnd, mOr, mImplies, mIff,
  mExists, mForall, mOld, mEqStr, mLeStr, mLtStr, mEqSet, mLeSet, mLtSet,
  mMulSet, mPlusSet, mMinusSet, mXorSet, mConStrStr, mSlice, mDotDot, mFields,
  mFieldPairs, mOmpParFor, mAppendStrCh, mAppendStrStr, mAppendSeqElem, mInSet,
  mRepr, mExit, mSetLengthStr, mSetLengthSeq, mSetLengthSeqUninit, mIsPartOf,
  mAstToStr, mParallel, mSwap, mIsNil, mArrToSeq, mOpenArrayToSeq, mNewString,
  mNewStringOfCap, mParseBiggestFloat, mMove, mEnsureMove, mWasMoved, mDup,
  mDestroy, mTrace, mDefault, mUnown, mFinished, mIsolate, mAccessEnv,
  mAccessTypeField, 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,
  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, mGenericDefine, mRunnableExamples, mException,
  mBuiltinType, mSymOwner, mUncheckedArray, mGetImplTransf,
  mSymIsInstantiationOf, mNodeId, mPrivateAccess, mZeroDefault

TNode {.final, acyclic.} = object
  when defined(useNodeIds):
    id*: int
  typField*: 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,
  nfSkipFieldChecking, nfDisabledOpenSym

TNodeFlags = set[TNodeFlag]

TNodeKinds = set[TNodeKind]

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

TNodePairSeq = seq[TNodePair]

TNodeSeq = seq[PNode]

TNodeTable = object
  counter*: int
  data*: TNodePairSeq
  ignoreTypes*: bool

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]
  optionStackLen*: int

TStorageLoc = enum
  OnUnknown, OnStatic, OnStack, OnHeap

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

TSym {.acyclic.} = object
  itemId*: ItemId
  state*: ItemState
  case kindImpl*: TSymKind
  of routineKinds:
    gcUnsafetyReasonImpl*: PSym
    transformedBodyImpl*: PNode
  of skLet, skVar, skField, skForVar:
    guardImpl*: PSym
    bitsizeImpl*: int
    alignmentImpl*: int
  else:
    nil
  magicImpl*: TMagic
  typImpl*: PType
  name*: PIdent
  infoImpl*: TLineInfo
  when defined(nimsuggest):
    endInfoImpl*: TLineInfo
    hasUserSpecifiedTypeImpl*: bool
  ownerFieldImpl*: PSym
  flagsImpl*: TSymFlags
  astImpl*: PNode
  optionsImpl*: TOptions
  positionImpl*: int
  offsetImpl*: int32
  disamb*: int32
  locImpl*: TLoc
  annexImpl*: PLib
  when hasFFI:
    cnameImpl*: string
  constraintImpl*: PNode
  instantiatedFromImpl*: PSym
  when defined(nimsuggest):
    allUsagesImpl*: seq[TLineInfo]

TSymFlag = enum
  sfUsed, sfExported, sfFromGeneric, sfGlobal, sfForward, sfWasForwarded,
  sfImportc, sfExportc, sfMangleCpp, sfVolatile, sfRegister, sfPure,
  sfNoSideEffect, sfSideEffect, sfMainModule, sfSystemModule, sfNoReturn,
  sfAddrTaken, sfCompilerProc, sfEscapes, sfDiscriminant, sfRequiresInit,
  sfDeprecated, sfExplain, sfError, sfShadowed, sfThread, sfCppNonPod,
  sfCompileTime, sfConstructor, sfDispatcher, sfBorrow, sfInfixCall,
  sfNamedParamCall, sfDiscardable, sfOverridden, sfCallsite, sfGenSym,
  sfNonReloadable, sfGeneratedOp, sfTemplateParam, sfCursor,
  sfInjectDestructors, sfNeverRaises, sfSystemRaisesDefect,
  sfUsedInFinallyOrExcept, sfSingleUsedTemp, sfNoalias, sfEffectsDelayed,
  sfGeneratedType, sfVirtual, sfByCopy, sfMember, sfCodegenDecl, sfWasGenSym,
  sfForceLift, sfDirty, sfCustomPragma, sfBase, sfGoto, sfAnon, sfAllUntyped,
  sfTemplateRedefinition

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

TSymKinds = set[TSymKind]

TType {.acyclic.} = object
  itemId*: ItemId
  kind*: TTypeKind
  state*: ItemState
  uniqueId*: ItemId
  callConvImpl*: TCallingConvention
  flagsImpl*: TTypeFlags
  sonsImpl*: TTypeSeq
  nImpl*: PNode
  ownerFieldImpl*: PSym
  symImpl*: PSym
  sizeImpl*: BiggestInt
  alignImpl*: int16
  paddingAtEndImpl*: int16
  locImpl*: TLoc
  typeInstImpl*: PType

TTypeAttachedOp = enum
  attachedWasMoved, attachedDestructor, attachedAsgn, attachedDup, 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, tfIsOutParam, tfSendable, tfImplicitStatic

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, tyError,
  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,
               tfIsOutParam}

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

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

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, mCStrToStr, mStrToStr, mEnumToStr, mAnd, mOr,
                 mEqStr, mLeStr, mLtStr, mEqSet, mLeSet, mLtSet, mMulSet,
                 mPlusSet, mMinusSet, mXorSet, mConStrStr, mAppendStrCh,
                 mAppendStrStr, mAppendSeqElem, mInSet, mRepr, mOpenArrayToSeq}

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

defaultAlignment = -1

defaultOffset = -1

defaultSize = -1

dispatcherPos = 8

effectListLen = 6

ensuresEffects = 2

exceptionEffects = 0

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

forbiddenEffects = 5

GcTypeKinds = {tyRef, tySequence, tyString}

generatedMagics = {mNone, mIsolate, mFinished, mOpenArrayToSeq}

genericParamsPos = 2

GenericTypes: TTypeKinds = {tyGenericInvocation, tyGenericBody, tyGenericParam}

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

miscPos = 5

namePos = 0

nfAllFieldsSet = nfBase2

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

nkEffectList = nkArgList

nkFloatLiterals = {nkFloatLit..nkFloat128Lit}

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

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

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

paramsPos = 3

patternPos = 1

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

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}

sfCompileToCpp = sfInfixCall

sfCompileToObjc = sfNamedParamCall

sfCppMember = {sfVirtual, sfMember, sfConstructor}

sfExperimental = sfOverridden

sfNoForward = sfRegister

sfNoInit = sfMainModule

sfReorder = sfForward

sfWrittenTo = sfBorrow

skError = skUnknown

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

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

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

tagEffects = 3

tfGcSafe = tfThread

tfGenericHasDestructor = tfExplicitCallConv

tfNonConstExpr = tfExplicitCallConv

tfObjHasKids = tfEnumHasHoles

tfReturnsNew = tfInheritable

tfUnion = tfNoSideEffect

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

tyPureObject = tyTuple

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

tyUserTypeClasses = {tyUserTypeClass, tyUserTypeClassInst}