CompilesId = int

IdGenerator = ref object
  module*: int32
  symId*: int32
  typeId*: int32
  sealed*: bool
  disambTable*: CountTable[PIdent]

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
  isOverridden*: bool
  name*: Rope
  path*: PNode

TLibKind = enum
  libHeader, libDynamic

TLoc = object
  k*: TLocKind
  storage*: TStorageLoc
  flags*: TLocFlags
  lode*: PNode
  r*: 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, 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,
  mOpenArrayToSeq, mNewString, mNewStringOfCap, mParseBiggestFloat, mMove,
  mEnsureMove, mWasMoved, mDup, 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, 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

  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, nfSkipFieldChecking

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, nkOutTy, nkDistinctTy, nkProcTy, nkIteratorTy, nkSinkAsgn,
  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*: int32
  disamb*: int32
  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, 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, sfCodegenDecl

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 of TIdObj
  kind*: TTypeKind
  callConv*: TCallingConvention
  flags*: TTypeFlags
  sons*: TTypeSeq
  n*: PNode
  owner*: PSym
  sym*: PSym
  size*: BiggestInt
  align*: int16
  paddingAtEnd*: int16
  loc*: TLoc
  typeInst*: PType
  uniqueId*: ItemId

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

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

ggDebug {....deprecated.}: 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] = ["=wasMoved", "=destroy",
    "=copy", "=dup", "=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, mOpenArrayToSeq}

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

defaultOffset = -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}

GrowthFactor = 2

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

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,
                                   nfSkipFieldChecking}

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

sfExperimental = sfOverridden

sfGoto = sfOverridden

sfNoForward = sfRegister

sfNoInit = sfMainModule

sfReorder = sfForward

sfTemplateRedefinition = sfExportc

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}