ParseDiag = object
  instLoc*: InstantiationInfo
  location*: TLineInfo
  case kind*: ParseDiagKind
  of pdkInvalidIndentationWithForgotEqualSignHint:
      eqLineInfo*: TLineInfo

  of pdkUnexpectedToken:
      expected*: TokType
      actual*: Token

  of pdkMissingToken:
      missedToks*: seq[TokType]

  of pdkIdentExpected, pdkExprExpected, pdkAsmStmtExpectsStrLit,
     pdkInconsistentSpacing:
      found*: Token

  of pdkWithoutExtraData:
      nil

  

ParseDiagKind = enum
  pdkInvalidIndentation, pdkInvalidIndentationWithForgotEqualSignHint,
  pdkNestableRequiresIndentation, pdkIdentExpected,
  pdkIdentExpectedEmptyAccQuote, pdkExprExpected, pdkMissingToken,
  pdkUnexpectedToken, pdkAsmStmtExpectsStrLit, pdkFuncNotAllowed,
  pdkTupleTypeWithPar, pdkMisplacedParameterVar, pdkConceptNotInType,
  pdkMisplacedExport, pdkPragmaBeforeGenericParameters, pdkInconsistentSpacing,
  pdkPragmaDoesNotFollowTypeName, pdkEnablePreviewDotOps

ParsedKindBracket = range[pnkPar .. pnkCurly]

ParsedKindLiteral = range[pnkCharLit .. pnkCustomLit]

ParsedKindWithSons = range[pnkCall .. pnkUsingStmt]

ParsedNode = ref ParsedNodeData

ParsedNodeData {.final, acyclic.} = object
  comment*: string
  fileIndex*: FileIndex
  case kind*: ParsedNodeKind
  of pnkError:
      diag*: ParseDiag

  of pnkEmpty:
      line*: uint16
      col*: int16

  of pnkIdent:
      startToken*: ParsedToken

  of pnkCharLit .. pnkUInt64Lit, pnkFloatLit .. pnkFloat64Lit,
     pnkStrLit .. pnkTripleStrLit, pnkNilLit, pnkCustomLit:
      lit*: ParsedToken

  of pnkAccQuoted:
      quote*: ParsedToken
      idents*: seq[tuple[ident: PIdent, line: uint16, col: int16]]

  of pnkCall .. pnkUsingStmt:
      token*: ParsedToken
      sons*: seq[ParsedNode]

  

ParsedNodeKind = enum
  pnkError,                 ## currently we don't produce error nodes
  pnkEmpty, pnkIdent, pnkCharLit, pnkIntLit, pnkInt8Lit, pnkInt16Lit,
  pnkInt32Lit, pnkInt64Lit, pnkUIntLit, pnkUInt8Lit, pnkUInt16Lit, pnkUInt32Lit,
  pnkUInt64Lit, pnkFloatLit, pnkFloat32Lit, pnkFloat64Lit, pnkStrLit,
  pnkRStrLit, pnkTripleStrLit, pnkNilLit, pnkCustomLit, pnkAccQuoted, pnkCall,
  pnkCommand, pnkCallStrLit, pnkInfix, pnkPrefix, pnkPostfix, pnkExprEqExpr,
  pnkExprColonExpr, pnkPar, pnkSqrBracket, pnkCurly, pnkTupleConstr,
  pnkObjConstr, pnkTableConstr, pnkSqrBracketExpr, pnkCurlyExpr, pnkPragmaExpr,
  pnkPragma, pnkPragmaBlock, pnkDotExpr, pnkIfExpr, pnkIfStmt, pnkElifBranch,
  pnkElifExpr, pnkElse, pnkElseExpr, pnkCaseStmt, pnkOfBranch, pnkWhenExpr,
  pnkWhenStmt, pnkForStmt, pnkWhileStmt, pnkBlockExpr, pnkBlockStmt,
  pnkDiscardStmt, pnkContinueStmt, pnkBreakStmt, pnkReturnStmt, pnkRaiseStmt,
  pnkYieldStmt, pnkTryStmt, pnkExceptBranch, pnkFinally, pnkDefer, pnkLambda,
  pnkDo, pnkBind, pnkBindStmt, pnkMixinStmt, pnkCast, pnkStaticStmt, pnkAsgn,
  pnkGenericParams, pnkFormalParams, pnkStmtList, pnkStmtListExpr,
  pnkImportStmt, pnkImportExceptStmt, pnkFromStmt, pnkIncludeStmt,
  pnkExportStmt, pnkExportExceptStmt, pnkTypeSection, pnkConstSection,
  pnkLetSection, pnkVarSection, pnkProcDef, pnkFuncDef, pnkMethodDef,
  pnkConverterDef, pnkIteratorDef, pnkMacroDef, pnkTemplateDef, pnkIdentDefs,
  pnkConstDef, pnkTypeDef, pnkVarTuple, pnkEnumTy, pnkEnumFieldDef, pnkObjectTy,
  pnkTupleTy, pnkProcTy, pnkIteratorTy, pnkRecList, pnkRecCase, pnkRecWhen,
  pnkTypeOfExpr, pnkRefTy, pnkVarTy, pnkPtrTy, pnkStaticTy, pnkDistinctTy,
  pnkMutableTy, pnkTupleClassTy, pnkTypeClassTy, pnkOfInherit, pnkArgList,
  pnkWith, pnkWithout, pnkAsmStmt, pnkCommentStmt, pnkUsingStmt

ParsedToken = object
  line*: uint16
  col*: int16
  tokType*: TokType
  ident*: PIdent
  iNumber*: BiggestInt
  fNumber*: BiggestFloat
  base*: NumericalBase
  literal*: string

pdkWithExtraData = {pdkInvalidIndentationWithForgotEqualSignHint,
                    pdkUnexpectedToken, pdkMissingToken, pdkIdentExpected,
                    pdkExprExpected, pdkAsmStmtExpectsStrLit,
                    pdkInconsistentSpacing}

pdkWithoutExtraData = {pdkInvalidIndentation, pdkNestableRequiresIndentation,
                       pdkIdentExpectedEmptyAccQuote,
                       pdkFuncNotAllowed..pdkPragmaBeforeGenericParameters,
                       pdkPragmaDoesNotFollowTypeName..pdkEnablePreviewDotOps}

pnkCallKinds = {pnkCall, pnkInfix, pnkPrefix, pnkPostfix, pnkCommand,
                pnkCallStrLit}

pnkDeclarativeDefs = {pnkProcDef, pnkFuncDef, pnkMethodDef, pnkIteratorDef,
                      pnkConverterDef}

pnkFloatKinds = {pnkFloatLit..pnkFloat64Lit}

pnkIntKinds = {pnkCharLit..pnkUInt64Lit}

pnkParsedKindsWithSons = {pnkCall..pnkUsingStmt}

pnkRoutineDefs = {pnkProcDef..pnkTemplateDef}

pnkStrKinds = {pnkStrLit..pnkTripleStrLit}

proc `[]=`(node: ParsedNode; idx: int | BackwardsIndex; other: ParsedNode)

proc `[]`(node: ParsedNode; idx: int | BackwardsIndex): ParsedNode

proc add(node: ParsedNode; other: ParsedNode) {....raises: [], tags: [].}

proc getToken(n: ParsedNode): ParsedToken {....raises: [], tags: [].}

func info(p: ParsedNode): TLineInfo {.inline, ...raises: [], tags: [].}

func len(node: ParsedNode): int {....raises: [], tags: [].}

func newEmptyParsedNode(fileIndex: FileIndex; line = unknownLineInfo.line;
                        col = unknownLineInfo.col): ParsedNode {....raises: [],
    tags: [].}

func newParsedLitNode(kind: ParsedKindLiteral; fileIndex: FileIndex;
                      token: ParsedToken): ParsedNode {....raises: [], tags: [].}

func newParsedNode(kind: ParsedKindWithSons; fileIndex: FileIndex;
                   token: ParsedToken; sons: seq[ParsedNode] = @[]): ParsedNode {.
    ...raises: [], tags: [].}

func newParsedNodeIdent(fileIndex: FileIndex; token: ParsedToken): ParsedNode {.
    ...raises: [], tags: [].}

proc newProcNode(kind: ParsedNodeKind; fileIndex: FileIndex; token: ParsedToken;
    body, params, name, pattern, genericParams, pragmas, exceptions: ParsedNode): ParsedNode {.
    ...raises: [], tags: [].}

func safeLen(node: ParsedNode): int {....raises: [], tags: [].}

proc toParsedToken(t: Token): ParsedToken {.inline, ...raises: [], tags: [].}

proc transitionSonsKind(n: ParsedNode; kind: ParsedNodeKind) {....raises: [],
    tags: [].}

iterator items(node: ParsedNode): ParsedNode {....raises: [], tags: [].}

iterator pairs(node: ParsedNode): (int, ParsedNode) {....raises: [], tags: [].}