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

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

TNodeKinds = set[TNodeKind]

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, sfCompileTime,
  sfConstructor, sfDispatcher, sfBorrow, sfInfixCall, sfNamedParamCall,
  sfDiscardable, sfOverriden, sfCallsite, sfGenSym, sfNonReloadable,
  sfGeneratedOp, sfTemplateParam, sfCursor, sfInjectDestructors, sfNeverRaises,
  sfUsedInFinallyOrExcept, sfSingleUsedTemp, sfNoalias

TSymFlags = set[TSymFlag]

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, tyOptDeprecated, tyVoid

TTypeKinds = set[TTypeKind]

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

TNodeFlags = set[TNodeFlag]

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

TTypeFlags = set[TTypeFlag]

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]

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,
  mDefault, mUnown, mIsolate, mAccessEnv, mReset, mArray, mOpenArray, mRange,
  mSet, mSeq, mVarargs, mRef, mPtr, mVar, mDistinct, mVoid, mTuple, mOrdinal,
  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

PNode = ref TNode

TNodeSeq = seq[PNode]

PType = ref TType

PSym = ref TSym

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

  comment*: string

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

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

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

TStorageLoc = enum
  OnUnknown, OnStatic, OnStack, OnHeap

TLocFlags = set[TLocFlag]

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

TLibKind = enum
  libHeader, libDynamic

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

CompilesId = int

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

PInstantiation = ref TInstantiation

TScope = object
  depthLevel*: int
  symbols*: TStrTable
  parent*: PScope

PScope = ref TScope

PLib = ref TLib

TSym {...}{.acyclic.} = object of TIdObj
  case kind*: TSymKind
  of skType, skGenericParam:
      typeInstCache*: seq[PType]

  of routineKinds:
      procInstCache*: seq[PInstantiation]
      gcUnsafetyReason*: PSym
      transformedBody*: PNode

  of skModule, skPackage:
      usedGenerics*: seq[PInstantiation]
      tab*: TStrTable

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

  else:
    nil
  magic*: TMagic
  typ*: PType
  name*: PIdent
  info*: 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]

  

TTypeSeq = seq[PType]

TLockLevel = distinct int16

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

TType {...}{.acyclic.} = object of TIdObj
  kind*: TTypeKind
  callConv*: TCallingConvention
  flags*: TTypeFlags
  sons*: TTypeSeq
  n*: PNode
  owner*: PSym
  sym*: PSym
  attachedOps*: array[TTypeAttachedOp, PSym]
  methods*: seq[(int, PSym)]
  size*: BiggestInt
  align*: int16
  paddingAtEnd*: int16
  lockLevel*: TLockLevel
  loc*: TLoc
  typeInst*: PType
  uniqueId*: int

TPair = object
  key*, val*: RootRef

TPairSeq = seq[TPair]

TIdPair = object
  key*: PIdObj
  val*: RootRef

TIdPairSeq = seq[TIdPair]

TIdTable = object
  counter*: int
  data*: TIdPairSeq

TIdNodePair = object
  key*: PIdObj
  val*: PNode

TIdNodePairSeq = seq[TIdNodePair]

TIdNodeTable = object
  counter*: int
  data*: TIdNodePairSeq

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

TNodePairSeq = seq[TNodePair]

TNodeTable = object
  counter*: int
  data*: TNodePairSeq

TObjectSeq = seq[RootRef]

TObjectSet = object
  counter*: int
  data*: TObjectSeq

TImplication = enum
  impUnknown, impNo, impYes

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

ggDebug: bool

sfNoInit = sfMainModule

sfAllUntyped = sfVolatile

sfDirty = sfPure

sfAnon = sfDiscardable

sfNoForward = sfRegister

sfReorder = sfForward

sfCompileToCpp = sfInfixCall

sfCompileToObjc = sfNamedParamCall

sfExperimental = sfOverriden

sfGoto = sfOverriden

sfWrittenTo = sfBorrow

sfEscapes = sfProcvar

sfBase = sfDiscriminant

sfIsSelf = sfOverriden

sfCustomPragma = sfRegister

nkWhen = nkWhenStmt

nkWhenExpr = nkWhenStmt

nkEffectList = nkArgList

exceptionEffects = 0

requiresEffects = 1

ensuresEffects = 2

tagEffects = 3

pragmasEffects = 4

effectListLen = 5

nkLastBlockStmts = {nkRaiseStmt, nkReturnStmt, nkBreakStmt, nkContinueStmt}

tyPureObject = tyTuple

GcTypeKinds = {tyRef, tySequence, tyString}

tyError = tyProxy

tyUnknown = tyFromExpr

tyUnknownTypes = {tyProxy, tyFromExpr}

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

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

tyUserTypeClasses = {tyUserTypeClass, tyUserTypeClassInst}

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

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

tfUnion = tfNoSideEffect

tfGcSafe = tfThread

tfObjHasKids = tfEnumHasHoles

tfReturnsNew = tfInheritable

skError = skUnknown

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}

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

GenericTypes: TTypeKinds = {tyGenericInvocation, tyGenericBody, tyGenericParam}

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

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}

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

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

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

PtrLikeKinds: TTypeKinds = {tyPointer, tyPtr}

ExportableSymKinds = {skVar, skConst, skProc, skFunc, skMethod, skType,
                      skIterator, skMacro, skTemplate, skConverter, skEnumField,
                      skLet, skStub, skAlias}

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

namePos = 0

patternPos = 1

genericParamsPos = 2

paramsPos = 3

pragmasPos = 4

miscPos = 5

bodyPos = 6

resultPos = 7

dispatcherPos = 8

nfAllFieldsSet = nfBase2

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

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

nkPragmaCallKinds = {nkExprColonExpr, nkCall, nkCallStrLit}

nkLiterals = {nkCharLit..nkTripleStrLit}

nkFloatLiterals = {nkFloatLit..nkFloat128Lit}

nkLambdaKinds = {nkLambda, nkDo}

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

routineDefs = {nkProcDef..nkIteratorDef, nkFuncDef}

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

nkSymChoices = {nkClosedSymChoice, nkOpenSymChoice}

nkStrKinds = {nkStrLit..nkTripleStrLit}

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

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

GrowthFactor = 2

StartSize = 8

UnspecifiedLockLevel = -1'i16

MaxLockLevel = 1000'i16

UnknownLockLevel = 1001'i16

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

proc getnimblePkg(a: PSym): PSym {...}{.raises: [], tags: [].}

proc getnimblePkgId(a: PSym): int {...}{.raises: [], tags: [].}

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

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

proc safeLen(n: PNode): int {...}{.inline, raises: [], tags: [].}

proc safeArrLen(n: PNode): int {...}{.inline, raises: [], tags: [].}

proc add(father, son: Indexable)

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 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 newSym(symKind: TSymKind; name: PIdent; owner: PSym; info: TLineInfo;
            options: TOptions = {}): PSym {...}{.raises: [], tags: [].}

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

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

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

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

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

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

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

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

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

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

proc withInfo(n: PNode; info: TLineInfo): PNode {...}{.raises: [], tags: [].}

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

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

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

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

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

proc lastSon(n: Indexable): Indexable

proc skipTypes(t: PType; kinds: TTypeKinds): PType {...}{.raises: [], tags: [].}

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

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

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

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

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

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

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

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

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

proc newSons(father: Indexable; length: int)

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

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

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

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

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

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

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

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

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

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

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

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

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

proc skipTypes(t: PType; kinds: TTypeKinds; maxIters: int): PType {...}{.raises: [],
    tags: [].}

proc skipTypesOrNil(t: PType; kinds: TTypeKinds): PType {...}{.raises: [], tags: [].}

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

proc propagateToOwner(owner, elem: PType; propagateHasAsgn = true) {...}{.raises: [],
    tags: [].}

proc rawAddSon(father, son: PType; propagateHasAsgn = true) {...}{.raises: [],
    tags: [].}

proc rawAddSonNoPropagationOfTypeFlags(father, son: PType) {...}{.raises: [],
    tags: [].}

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

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

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

proc transitionSonsKind(n: PNode; kind: range[nkComesFrom .. nkTupleConstr]) {...}{.
    raises: [], tags: [].}

proc transitionIntKind(n: PNode; kind: range[nkCharLit .. nkUInt64Lit]) {...}{.
    raises: [], tags: [].}

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

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

proc transitionRoutineSymKind(s: PSym; kind: range[skProc .. skTemplate]) {...}{.
    raises: [], tags: [].}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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