InstantiationInfo = typeof(instantiationInfo())

FilenameOption = enum
  foAbs, foRelProject, foMagicSauce, foName, foStacktrace

MsgFlag = enum
  msgStdout,                ## force writing to stdout, even stderr is default
  msgSkipHook                ## skip message hook even if it is present

MsgFlags = set[MsgFlag]

TErrorHandling = enum
  doNothing, doAbort, doRaise

gCmdLineInfo = (line: 1'u, col: 1, fileIndex: -3)

ColOffset = 1

commandLineDesc = "command line"

proc toCChar(c: char; result: var string) {...}{.raises: [], tags: [].}

proc makeCString(s: string): Rope {...}{.raises: [], tags: [].}

proc fileInfoKnown(conf: ConfigRef; filename: AbsoluteFile): bool {...}{.raises: [],
    tags: [ReadDirEffect].}

proc fileInfoIdx(conf: ConfigRef; filename: AbsoluteFile; isKnownFile: var bool): FileIndex {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc fileInfoIdx(conf: ConfigRef; filename: AbsoluteFile): FileIndex {...}{.
    raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc newLineInfo(fileInfoIdx: FileIndex; line, col: int): TLineInfo {...}{.
    raises: [], tags: [].}

proc newLineInfo(conf: ConfigRef; filename: AbsoluteFile; line, col: int): TLineInfo {...}{.
    inline, raises: [KeyError, Exception], tags: [ReadDirEffect, RootEffect].}

proc suggestWriteln(conf: ConfigRef; s: string) {...}{.raises: [IOError, Exception],
    tags: [WriteIOEffect, RootEffect].}

proc msgQuit(x: int8) {...}{.raises: [], tags: [].}

proc msgQuit(x: string) {...}{.raises: [], tags: [].}

proc suggestQuit() {...}{.raises: [ESuggestDone], tags: [].}

proc getInfoContextLen(conf: ConfigRef): int {...}{.raises: [], tags: [].}

proc setInfoContextLen(conf: ConfigRef; L: int) {...}{.raises: [], tags: [].}

proc pushInfoContext(conf: ConfigRef; info: TLineInfo; detail: string = "") {...}{.
    raises: [], tags: [].}

proc popInfoContext(conf: ConfigRef) {...}{.raises: [], tags: [].}

proc getInfoContext(conf: ConfigRef; index: int): TLineInfo {...}{.raises: [],
    tags: [].}

proc toProjPath(conf: ConfigRef; fileIdx: FileIndex): string {...}{.raises: [],
    tags: [].}

proc toFullPath(conf: ConfigRef; fileIdx: FileIndex): string {...}{.raises: [],
    tags: [].}

proc setDirtyFile(conf: ConfigRef; fileIdx: FileIndex; filename: AbsoluteFile) {...}{.
    raises: [], tags: [].}

proc setHash(conf: ConfigRef; fileIdx: FileIndex; hash: string) {...}{.raises: [],
    tags: [].}

proc getHash(conf: ConfigRef; fileIdx: FileIndex): string {...}{.raises: [], tags: [].}

proc toFullPathConsiderDirty(conf: ConfigRef; fileIdx: FileIndex): AbsoluteFile {...}{.
    raises: [], tags: [].}

proc toFilenameOption(conf: ConfigRef; fileIdx: FileIndex; opt: FilenameOption): string {...}{.
    raises: [], tags: [].}

proc toMsgFilename(conf: ConfigRef; info: FileIndex): string {...}{.raises: [],
    tags: [].}

proc toLinenumber(info: TLineInfo): int {...}{.inline, raises: [], tags: [].}

proc toColumn(info: TLineInfo): int {...}{.inline, raises: [], tags: [].}

proc toFileLineCol(conf: ConfigRef; info: TLineInfo): string {...}{.inline,
    raises: [], tags: [].}

proc `$`(conf: ConfigRef; info: TLineInfo): string {...}{.raises: [], tags: [].}

proc `$`(info: TLineInfo): string {...}{.error.}

proc `??`(conf: ConfigRef; info: TLineInfo; filename: string): bool {...}{.
    raises: [], tags: [].}

proc msgWriteln(conf: ConfigRef; s: string; flags: MsgFlags = {}) {...}{.
    raises: [Exception, IOError], tags: [RootEffect, WriteIOEffect].}

proc msgKindToString(kind: TMsgKind): string {...}{.raises: [], tags: [].}

proc log(s: string) {...}{.raises: [IOError],
                      tags: [ReadEnvEffect, ReadIOEffect, WriteIOEffect].}

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

proc exactEquals(a, b: TLineInfo): bool {...}{.raises: [], tags: [].}

proc numLines(conf: ConfigRef; fileIdx: FileIndex): int {...}{.raises: [],
    tags: [ReadIOEffect].}

proc sourceLine(conf: ConfigRef; i: TLineInfo): string {...}{.raises: [],
    tags: [ReadIOEffect].}

proc formatMsg(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg: string): string {...}{.
    raises: [ValueError], tags: [].}

proc liMessage(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg: string;
               eh: TErrorHandling; info2: InstantiationInfo; isRaw = false) {...}{.
    noinline, raises: [Exception, ValueError, IOError, ERecoverableError],
    tags: [RootEffect, WriteIOEffect, ReadIOEffect, ReadEnvEffect].}

proc quotedFilename(conf: ConfigRef; i: TLineInfo): Rope {...}{.raises: [], tags: [].}

proc listWarnings(conf: ConfigRef) {...}{.raises: [Exception, IOError, ValueError],
                                     tags: [RootEffect, WriteIOEffect].}

proc listHints(conf: ConfigRef) {...}{.raises: [Exception, IOError, ValueError],
                                  tags: [RootEffect, WriteIOEffect].}

template toFilename(conf: ConfigRef; fileIdx: FileIndex): string

template toFilename(conf: ConfigRef; info: TLineInfo): string

template toProjPath(conf: ConfigRef; info: TLineInfo): string

template toFullPath(conf: ConfigRef; info: TLineInfo): string

template toFullPathConsiderDirty(conf: ConfigRef; info: TLineInfo): string

template toMsgFilename(conf: ConfigRef; info: TLineInfo): string

template styledMsgWriteln(args: varargs[typed])

template rawMessage(conf: ConfigRef; msg: TMsgKind; args: openArray[string])

template rawMessage(conf: ConfigRef; msg: TMsgKind; arg: string)

template fatal(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg = "")

template globalAssert(conf: ConfigRef; cond: untyped;
                      info: TLineInfo = unknownLineInfo; arg = "")

template globalError(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg = "")

template globalError(conf: ConfigRef; info: TLineInfo; arg: string)

template localError(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg = "")

template localError(conf: ConfigRef; info: TLineInfo; arg: string)

template localError(conf: ConfigRef; info: TLineInfo; format: string;
                    params: openArray[string])

template message(conf: ConfigRef; info: TLineInfo; msg: TMsgKind; arg = "")

template internalError(conf: ConfigRef; info: TLineInfo; errMsg: string)

template internalError(conf: ConfigRef; errMsg: string)

template internalAssert(conf: ConfigRef; e: bool)

template lintReport(conf: ConfigRef; info: TLineInfo; beau, got: string)