EffectsCompat = enum
  efCompat, efRaisesDiffer, efRaisesUnknown, efTagsDiffer, efTagsUnknown,
  efLockLevelsDiffer, efEffectsDelayed

OrdinalType = enum
  NoneLike, IntLike, FloatLike

ProcConvMismatch = enum
  pcmNoSideEffect, pcmNotGcSafe, pcmLockDifference, pcmNotIterator,
  pcmDifferentCallConv

TDistinctCompare = enum
  dcEq,                     ## a and b should be the same type
  dcEqIgnoreDistinct,       ## compare symmetrically: (distinct a) == b, a == b
                             ## or a == (distinct b)
  dcEqOrDistinctOf           ## a equals b or a is distinct of b

TParamsEquality = enum
  paramsNotEqual, paramsEqual, paramsIncompatible

TPreferedDesc = enum
  preferName, preferDesc, preferExported, preferModuleInfo, preferGenericArg,
  preferTypeName, preferResolved, preferMixed

TTypeCmpFlag = enum
  IgnoreTupleFields,        ## NOTE: Only set this flag for backends!
  IgnoreCC, ExactTypeDescValues, ExactGenericParams, ExactConstraints,
  ExactGcSafety, AllowCommonBase, PickyCAliases

TTypeCmpFlags = set[TTypeCmpFlag]

TTypeFieldResult = enum
  frNone, frHeader, frEmbedded

TTypeIter = proc (t: PType; closure: RootRef): bool {.nimcall.}

TTypeMutator = proc (t: PType; closure: RootRef): PType {.nimcall.}

TTypePredicate = proc (t: PType): bool {.nimcall.}

TTypeRelation = enum
  isNone, isConvertible, isIntConv, isSubtype, isSubrange,
  isBothMetaConvertible, isInferred, isInferredConvertible, isGeneric,
  isFromIntLit, isEqual

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

abstractPtrs = {tyVar, tyPtr, tyRef, tyGenericInst, tyDistinct, tyOrdinal,
                tyTypeDesc, tyAlias, tyInferred, tySink, tyLent, tyOwned}

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

abstractVar = {tyVar, tyGenericInst, tyDistinct, tyOrdinal, tyTypeDesc, tyAlias,
               tyInferred, tySink, tyLent, tyOwned}

skipPtrs = {tyVar, tyPtr, tyRef, tyGenericInst, tyTypeDesc, tyAlias, tyInferred,
            tySink, tyLent, tyOwned}

szIllegalRecursion = -2

szTooBigSize = -4

szUncomputedSize = -1

szUnknownSize = -3

typedescInst = {tyAlias, tyTypeDesc, tyGenericInst, tyDistinct, tyOrdinal,
                tyOwned..tySink, tyUserTypeClass, tyInferred}

typedescPtrs = {tyAlias, tyTypeDesc, tyGenericInst, tyDistinct, tyOrdinal,
                tyPtr..tyVar, tyOwned..tyLent, tyInferred}

proc addPragmaAndCallConvMismatch(message: var string; formal, actual: PType;
                                  conf: ConfigRef) {....raises: [ValueError],
    tags: [].}

proc addTypeDeclVerboseMaybe(result: var string; conf: ConfigRef; typ: PType) {.
    ...raises: [Exception, ValueError, KeyError, OSError],
    tags: [RootEffect, ReadDirEffect].}

proc addTypeHeader(result: var string; conf: ConfigRef; typ: PType;
                   prefer: TPreferedDesc = preferMixed;
                   getDeclarationPath = true) {.
    ...raises: [Exception, ValueError, KeyError, OSError],
    tags: [RootEffect, ReadDirEffect].}

proc analyseObjectWithTypeField(t: PType): TTypeFieldResult {.
    ...raises: [Exception], tags: [RootEffect].}

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

proc baseOfDistinct(t: PType; g: ModuleGraph; idgen: IdGenerator): PType {.
    ...raises: [], tags: [].}

proc canFormAcycle(typ: PType): bool {....raises: [Exception], tags: [RootEffect].}

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

proc commonSuperclass(a, b: PType): PType {....raises: [Exception],
    tags: [RootEffect].}

proc compareTypes(x, y: PType; cmp: TDistinctCompare = dcEq;
                  flags: TTypeCmpFlags = {}): bool {.
    ...raises: [KeyError, Exception, ERecoverableError], tags: [RootEffect].}

proc compatibleEffects(formal, actual: PType): EffectsCompat {.
    ...raises: [Exception], tags: [RootEffect].}

proc computeSize(conf: ConfigRef; typ: PType): BiggestInt {....raises: [Exception,
    ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

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

proc containsGarbageCollectedRef(typ: PType): bool {....raises: [Exception],
    tags: [RootEffect].}

proc containsGenericType(t: PType): bool {....raises: [Exception],
    tags: [RootEffect].}

proc containsHiddenPointer(typ: PType): bool {....raises: [Exception],
    tags: [RootEffect].}

proc containsManagedMemory(typ: PType): bool {....raises: [Exception],
    tags: [RootEffect].}

proc containsObject(t: PType): bool {....raises: [Exception], tags: [RootEffect].}

proc containsTyRef(typ: PType): bool {....raises: [Exception], tags: [RootEffect].}

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

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

proc equalParams(a, b: PNode): TParamsEquality {....raises: [Exception, KeyError],
    tags: [RootEffect].}

proc firstFloat(t: PType): BiggestFloat {....raises: [Exception, ValueError,
    KeyError, OSError, IOError, ERecoverableError], tags: [RootEffect,
    ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc firstOrd(conf: ConfigRef; t: PType): Int128 {....raises: [Exception,
    ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc floatRangeCheck(x: BiggestFloat; t: PType): bool {....raises: [Exception,
    ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc getAlign(conf: ConfigRef; typ: PType): BiggestInt {....raises: [Exception,
    ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

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

proc getOrdValue(n: PNode; onError = high(Int128)): Int128 {....raises: [],
    tags: [].}

proc getProcConvMismatch(c: ConfigRef; f, a: PType; rel = isNone): (
    set[ProcConvMismatch], TTypeRelation) {....raises: [], tags: [].}

proc getProcHeader(conf: ConfigRef; sym: PSym;
                   prefer: TPreferedDesc = preferName; getDeclarationPath = true): string {.
    ...raises: [Exception, KeyError, ValueError, OSError],
    tags: [RootEffect, ReadDirEffect].}

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

proc getSize(conf: ConfigRef; typ: PType): BiggestInt {....raises: [Exception,
    ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc inheritanceDiff(a, b: PType): int {....raises: [Exception], tags: [RootEffect].}

proc invalidGenericInst(f: PType): bool {....raises: [], tags: [].}

proc isCharArrayPtr(t: PType; allowPointerToChar: bool): bool {....raises: [
    Exception, ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

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

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

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

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

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

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

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

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

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

proc isOrdinalType(t: PType; allowEnumWithHoles: bool = false): bool {.
    ...raises: [], tags: [].}

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

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

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

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

proc iterOverType(t: PType; iter: TTypeIter; closure: RootRef): bool {.
    ...raises: [Exception], tags: [RootEffect].}

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

proc lastFloat(t: PType): BiggestFloat {....raises: [Exception, ValueError,
    KeyError, OSError, IOError, ERecoverableError], tags: [RootEffect,
    ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc lastOrd(conf: ConfigRef; t: PType): Int128 {....raises: [Exception,
    ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc lengthOrd(conf: ConfigRef; t: PType): Int128 {....raises: [Exception,
    ValueError, KeyError, OSError, IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc lookupFieldAgain(ty: PType; field: PSym): PSym {....raises: [], tags: [].}

proc matchType(a: PType; pattern: openArray[tuple[k: TTypeKind, i: int]];
               last: TTypeKind): bool {....raises: [], tags: [].}

proc mutateType(t: PType; iter: TTypeMutator; closure: RootRef): PType {.
    ...raises: [Exception, KeyError], tags: [RootEffect].}

proc safeInheritanceDiff(a, b: PType): int {....raises: [Exception],
    tags: [RootEffect].}

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

proc sameBackendType(x, y: PType): bool {.
    ...raises: [KeyError, Exception, ERecoverableError], tags: [RootEffect].}

proc sameDistinctTypes(a, b: PType): bool {.inline, ...raises: [Exception],
    tags: [RootEffect].}

proc sameEnumTypes(a, b: PType): bool {.inline, ...raises: [], tags: [].}

proc sameFlags(a, b: PType): bool {.inline, ...raises: [], tags: [].}

proc sameObjectTypes(a, b: PType): bool {....raises: [Exception],
    tags: [RootEffect].}

proc sameType(a, b: PType; flags: TTypeCmpFlags = {}): bool {.
    ...raises: [Exception], tags: [RootEffect].}

proc sameTypeOrNil(a, b: PType; flags: TTypeCmpFlags = {}): bool {.
    ...raises: [Exception], tags: [RootEffect].}

proc searchTypeFor(t: PType; predicate: TTypePredicate): bool {.
    ...raises: [Exception], tags: [RootEffect].}

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

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

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

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

proc skipHiddenSubConv(n: PNode; g: ModuleGraph; idgen: IdGenerator): PNode {.
    ...raises: [KeyError], tags: [].}

proc takeType(formal, arg: PType; g: ModuleGraph; idgen: IdGenerator): PType {.
    ...raises: [], tags: [].}

proc typeMismatch(conf: ConfigRef; info: TLineInfo; formal, actual: PType;
                  n: PNode) {....raises: [Exception, KeyError, ValueError, OSError,
                                       IOError, ERecoverableError], tags: [
    RootEffect, ReadDirEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc typeToString(typ: PType; prefer: TPreferedDesc = preferName): string {.
    ...raises: [Exception, KeyError, ValueError], tags: [RootEffect].}

template `$`(typ: PType): string

template bindConcreteTypeToUserTypeClass(tc, concrete: PType)

template foldAlignOf(conf: ConfigRef; n: PNode; fallback: PNode): PNode

template foldOffsetOf(conf: ConfigRef; n: PNode; fallback: PNode): PNode

template foldSizeOf(conf: ConfigRef; n: PNode; fallback: PNode): PNode

template isResolvedUserTypeClass(t: PType): bool