ModuleId = distinct int32

NodeId = distinct int32

NodePos = distinct int

PackedInstantiation = object
  key*, sym*: PackedItemId
  concreteTypes*: seq[PackedItemId]

PackedItemId = object
  module*: LitId
  item*: int32

PackedLib = object
  kind*: TLibKind
  generated*: bool
  isOverriden*: bool
  name*: LitId
  path*: NodeId

PackedLineInfo = object
  line*: uint16
  col*: int16
  file*: LitId

PackedNode = object
  kind*: TNodeKind
  flags*: TNodeFlags
  operand*: int32
  typeId*: PackedItemId
  info*: PackedLineInfo

PackedSym = object
  kind*: TSymKind
  name*: LitId
  typ*: PackedItemId
  flags*: TSymFlags
  magic*: TMagic
  info*: PackedLineInfo
  ast*: NodeId
  owner*: PackedItemId
  guard*: PackedItemId
  bitsize*: int
  alignment*: int
  options*: TOptions
  position*: int
  offset*: int
  externalName*: LitId
  locFlags*: TLocFlags
  annex*: PackedLib
  when hasFFI:
      cname*: LitId

  constraint*: NodeId

PackedTree = object
  nodes*: seq[PackedNode]

PackedType = object
  kind*: TTypeKind
  callConv*: TCallingConvention
  flags*: TTypeFlags
  types*: seq[PackedItemId]
  n*: NodeId
  sym*: PackedItemId
  owner*: PackedItemId
  size*: BiggestInt
  align*: int16
  paddingAtEnd*: int16
  lockLevel*: TLockLevel
  typeInst*: PackedItemId
  nonUniqueId*: int32

SymId = distinct int32

directIntLit = nkInt32Lit

emptyNodeId = -1'i32

externIntLit = {nkCharLit, nkIntLit, nkInt8Lit, nkInt16Lit, nkInt64Lit,
                nkUIntLit, nkUInt8Lit, nkUInt16Lit, nkUInt32Lit, nkUInt64Lit}

externSIntLit = {nkIntLit, nkInt8Lit, nkInt16Lit, nkInt64Lit}

externUIntLit = {nkUIntLit, nkUInt8Lit, nkUInt16Lit, nkUInt32Lit, nkUInt64Lit}

nilItemId = (module: 0'u, item: -1)

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

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

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

proc `[]`(tree: PackedTree; i: int): lent PackedNode {.inline, ...raises: [],
    tags: [].}

proc addIdent(tree: var PackedTree; s: LitId; info: PackedLineInfo) {.
    ...raises: [], tags: [].}

proc addModuleId(tree: var PackedTree; s: ModuleId; info: PackedLineInfo) {.
    ...raises: [], tags: [].}

proc addSym(tree: var PackedTree; s: int32; info: PackedLineInfo) {....raises: [],
    tags: [].}

proc addSymDef(tree: var PackedTree; s: SymId; info: PackedLineInfo) {.
    ...raises: [], tags: [].}

proc copyTree(dest: var PackedTree; tree: PackedTree; n: NodePos) {....raises: [],
    tags: [].}

proc firstSon(n: NodePos): NodePos {.inline, ...raises: [], tags: [].}

proc firstSon(tree: PackedTree; n: NodePos): NodePos {.inline, ...raises: [],
    tags: [].}

proc getNodeId(tree: PackedTree): NodeId {.inline, ...raises: [], tags: [].}

proc hasAtLeastXsons(tree: PackedTree; n: NodePos; x: int): bool {....raises: [],
    tags: [].}

proc hash(a: SymId): Hash {.borrow, ...raises: [], tags: [].}

proc hasXsons(tree: PackedTree; n: NodePos; x: int): bool {....raises: [], tags: [].}

proc info(tree: PackedTree; n: NodePos): PackedLineInfo {.inline, ...raises: [],
    tags: [].}

proc isAtom(tree: PackedTree; pos: int): bool {.inline, ...raises: [], tags: [].}

proc ithSon(tree: PackedTree; n: NodePos; i: int): NodePos {....raises: [],
    tags: [].}

proc kind(tree: PackedTree; n: NodePos): TNodeKind {.inline, ...raises: [],
    tags: [].}

proc len(tree: PackedTree): int {.inline, ...raises: [], tags: [].}

proc litId(tree: PackedTree; n: NodePos): LitId {.inline, ...raises: [], tags: [].}

proc newTreeFrom(old: PackedTree): PackedTree {....raises: [], tags: [].}

proc patch(tree: var PackedTree; pos: PatchPos) {....raises: [], tags: [].}

proc prepare(dest: var PackedTree; source: PackedTree; sourcePos: NodePos): PatchPos {.
    ...raises: [], tags: [].}

proc prepare(tree: var PackedTree; kind: TNodeKind; flags: TNodeFlags;
             typeId: PackedItemId; info: PackedLineInfo): PatchPos {....raises: [],
    tags: [].}

proc sons2(tree: PackedTree; n: NodePos): (NodePos, NodePos) {....raises: [],
    tags: [].}

proc sons3(tree: PackedTree; n: NodePos): (NodePos, NodePos, NodePos) {.
    ...raises: [], tags: [].}

proc span(tree: PackedTree; pos: int): int {.inline, ...raises: [], tags: [].}

proc throwAwayLastNode(tree: var PackedTree) {....raises: [], tags: [].}

proc toPackedItemId(item: int32): PackedItemId {.inline, ...raises: [], tags: [].}

iterator allNodes(tree: PackedTree): NodePos {....raises: [], tags: [].}

iterator isons(dest: var PackedTree; tree: PackedTree; n: NodePos): (int,
    NodePos) {....raises: [], tags: [].}

iterator sons(dest: var PackedTree; tree: PackedTree; n: NodePos): NodePos {.
    ...raises: [], tags: [].}

iterator sonsFrom1(tree: PackedTree; n: NodePos): NodePos {....raises: [], tags: [].}

iterator sonsReadonly(tree: PackedTree; n: NodePos): NodePos {....raises: [],
    tags: [].}

iterator sonsWithoutLast2(tree: PackedTree; n: NodePos): NodePos {....raises: [],
    tags: [].}

template copyInto(dest, n, body)

template copyIntoKind(dest, kind, info, body)

template flags(n: NodePos): TNodeFlags

template info(n: NodePos): PackedLineInfo

template kind(n: NodePos): TNodeKind

template litId(n: NodePos): LitId

template operand(n: NodePos): int32

template parent(n: NodePos): NodePos

template symId(n: NodePos): SymId

template typ(n: NodePos): PackedItemId