GccLocation = object
  caret*: GccPoint
  finish*: Option[GccPoint]

GccPoint = object
  byteColumn*: int
  displayColumn*: int
  line*: int
  file*: string
  column*: int

GccReport = object
  kind*: string
  columnOrigin*: int
  children*: seq[GccReportChild]
  locations*: seq[GccLocation]
  message*: string
  options*: seq[string]

NimError = enum
  neNone, neException, neCannotOpen, neOverloadFail, neInvalidIndentation,
  neAmbiguousCall, neLdFail, neGccFail

NimFixit = object
  file*: Option[AbsFile]
  line*: Option[int]
  column*: Option[int]
  message*: string

NimHint = enum
  nfSuccess = "Success", nfSuccessX = "SuccessX", nfCC = "CC",
  nfLineTooLong = "LineTooLong", nfXDeclaredButNotUsed = "XDeclaredButNotUsed",
  nfDuplicateModuleImport = "DuplicateModuleImport",
  nfXCannotRaiseY = "XCannotRaiseY",
  nfConvToBaseNotNeeded = "ConvToBaseNotNeeded",
  nfConvFromXtoItselfNotNeeded = "ConvFromXtoItselfNotNeeded",
  nfExprAlwaysX = "ExprAlwaysX", nfQuitCalled = "QuitCalled",
  nfProcessing = "Processing", nfProcessingStmt = "ProcessingStmt",
  nfCodeBegin = "CodeBegin", nfCodeEnd = "CodeEnd", nfConf = "Conf",
  nfPath = "Path", nfCondTrue = "CondTrue", nfCondFalse = "CondFalse",
  nfName = "Name", nfPattern = "Pattern", nfExec = "Exec", nfLink = "Link",
  nfDependency = "Dependency", nfSource = "Source",
  nfPerformance = "Performance", nfStackTrace = "StackTrace",
  nfGCStats = "GCStats", nfGlobalVar = "GlobalVar",
  nfExpandMacro = "ExpandMacro", nfUser = "User", nfUserRaw = "UserRaw",
  nfExtendedContext = "ExtendedContext", nfMsgOrigin = "MsgOrigin",
  nfDeclaredLoc = "DeclaredLoc"

NimOutputCheck = enum
  ocIgnore = "ignore", ocEqual = "equal", ocSubstr = "substr"

NimOverloadAlt = object
  signature*: string
  argumentFail*: string
  isOfType*: Option[string]

NimReport = object
  parts*: seq[NimReportPart]
  fixit*: seq[NimFixit]
  case kind*: NimReportKind
  of nrHint:
      hint*: NimHint

  of nrWarning:
      warning*: NimWarning

  of nrError:
      case error*: NimError
      of neAmbiguousCall:
          definedAlts*: seq[tuple[kind: string, name: string,
                                  definedIn: AbsFile, line: int, column: int]]
          matchFor*: string

      of neLdFail:
          ldReport*: tuple[message: string, compile: seq[string]]

      of neOverloadFail:
          overloadContext*: tuple[gotType: string, alts: seq[NimOverloadAlt],
                                  expression: string]

      of neGccFail:
          gccReport*: tuple[diags: seq[seq[GccReport]], compile: seq[string]]

      else:
          nil

    
  

NimReportKind = enum
  nrHint, nrWarning, nrError

NimReportPart = object
  file*: string
  line*: int
  column*: int
  text*: string
  case kind*: NimReportPartKind
  of nrpProcessingImports:
      imports*: string
      target*: AbsFile
      level*: int
      isInclude*: bool
      isToplevel*: bool

  else:
      nil

  

NimReportPartKind = enum
  nrpNone, nrpInstOf, nrpException, nrpTracePart, nrpProcessingImports,
  nrpLdFail

NimResultKind = enum
  reNimcCrash,              ## nim compiler seems to have crashed
  reMsgsDiffer,             ## error messages differ
  reFilesDiffer,            ## expected and given filenames differ
  reLinesDiffer,            ## expected and given line numbers differ
  reOutputsDiffer, reExitcodesDiffer, ## exit codes of program or of valgrind differ
  reTimeout, reInvalidPeg, reCodegenFailure, reCodeNotFound, reExeNotFound, reInstallFailed, ## package installation failed
  reBuildFailed,            ## package building failed
  reDisabled,               ## test is disabled
  reJoined,                 ## test is disabled because it was joined into the megatest
  reSuccess,                ## test was successful
  reInvalidSpec              ## test had problems to parse the spec

NimRun = object
  flags: set[NimFlag]
  gc: NimGc
  backend: NimBackend
  file: AbsFile
  outFile: AbsFile
  tmpDir: AbsDir
  spec: Option[NimTestSpec]

NimRunFailDesc = object
  run*: NimRun
  compileRes*: ShellResult
  msg*: string

NimState = object
  paths*: seq[AbsDir]
  hints*: set[NimWarning]
  flags*: seq[NimFlag]
  nimblePath*: AbsDir

NimTestAction = enum
  actionRun = "run", actionCompile = "compile", actionReject = "reject"

NimTestSpec = object
  action*: NimTestAction
  file*: AbsFile
  msg*: string
  exitCode*: int
  cmd*: string
  input*: string
  outputCheck*: NimOutputCheck
  sortoutput*: bool
  output*: string
  line*, column*: int
  ccodeCheck*: seq[string]
  maxCodeSize*: int
  err*: NimResultKind
  inCurrentBatch*: bool
  targets*: set[NimBackend]
  matrix*: seq[string]
  nimout*: string
  nimoutFull*: bool
  joinable*: bool
  unbatchable*: bool
  timeout*: float
  debugInfo*: string

NimWarning = enum
  nwCannotOpenFile = "CannotOpenFile", nwOctalEscape = "OctalEscape",
  nwXIsNeverRead = "XIsNeverRead", nwXmightNotBeenInit = "XmightNotBeenInit",
  nwDeprecated = "Deprecated", nwConfigDeprecated = "ConfigDeprecated",
  nwDotLikeOps = "DotLikeOps",
  nwSmallLshouldNotBeUsed = "SmallLshouldNotBeUsed",
  nwUnknownMagic = "UnknownMagic",
  nwRedefinitionOfLabel = "RedefinitionOfLabel",
  nwUnknownSubstitutionX = "UnknownSubstitutionX", nwBrokenLink = "BrokenLink",
  nwLanguageXNotSupported = "LanguageXNotSupported",
  nwFieldXNotSupported = "FieldXNotSupported", nwWarnRstStyle = "warnRstStyle",
  nwCommentXIgnored = "CommentXIgnored", nwTypelessParam = "TypelessParam",
  nwUseBase = "UseBase", nwWriteToForeignHeap = "WriteToForeignHeap",
  nwUnsafeCode = "UnsafeCode", nwUnusedImport = "UnusedImport",
  nwInheritFromException = "InheritFromException",
  nwEachIdentIsTuple = "EachIdentIsTuple", nwUnsafeSetLen = "UnsafeSetLen",
  nwUnsafeDefault = "UnsafeDefault", nwProveInit = "ProveInit",
  nwProveField = "ProveField", nwProveIndex = "ProveIndex",
  nwUnreachableElse = "UnreachableElse", nwUnreachableCode = "UnreachableCode",
  nwIndexCheck = "IndexCheck", nwGcUnsafe = "GcUnsafe",
  nwGcUnsafe2 = "GcUnsafe2", nwUninit = "Uninit", nwGcMem = "GcMem",
  nwDestructor = "Destructor", nwLockLevel = "LockLevel",
  nwResultShadowed = "ResultShadowed", nwSpacing = "Spacing",
  nwCaseTransition = "CaseTransition", nwCycleCreated = "CycleCreated",
  nwObservableStores = "ObservableStores", nwStrictNotNil = "StrictNotNil",
  nwResultUsed = "ResultUsed", nwCannotOpen = "CannotOpen",
  nwFileChanged = "FileChanged", nwEnumConv = "EnumConv",
  nwAnyEnumConv = "AnyEnumConv", nwHoleEnumConv = "HoleEnumConv",
  nwCStringConv = "CStringConv", nwEffect = "Effect", nwUser = "User"

func `$`(run: NimRun): string {....raises: [ValueError], tags: [].}

proc formatShellCmd(cmd: ShellCmd): ColoredText {....raises: [Exception],
    tags: [RootEffect].}

proc getCompileReportFor(file: AbsFile; dump: NimState; hints: bool = on): seq[
    NimReport] {....raises: [IOError, OSError, Exception, ValueError, ParseError,
                          LexcastError, ArgumentError, ShellError,
                          UnexpectedKindError, NilArgumentError, JsonError], tags: [
    ReadIOEffect, RootEffect, ReadEnvEffect, WriteIOEffect, WriteDirEffect,
    ReadDirEffect, ShellExecEffect, ExecIOEffect].}

proc getCwdNimDump(file: string = "-"): NimState {....raises: [IOError, OSError,
    JsonParsingError, ValueError, Exception, ArgumentError, ShellError, KeyError], tags: [
    ReadIOEffect, WriteIOEffect, ShellExecEffect, ExecIOEffect, ReadEnvEffect,
    RootEffect].}

proc getJoinable(runs: seq[NimRun]): tuple[joinable, standalone: seq[NimRun]] {.
    ...raises: [], tags: [].}

proc logLines(l: HLogger; part: NimReportPart) {.
    ...raises: [NilArgumentError, ValueError, IOError, KeyError],
    tags: [ReadEnvEffect, WriteIOEffect, ReadIOEffect].}

proc makeJoinedCode(runs: seq[NimRun]): string {....raises: [ValueError], tags: [].}

proc parseAmbiguousCall(text: string): NimReport {....raises: [IOError, OSError,
    UnexpectedCharError, NilArgumentError, Exception, ValueError],
    tags: [ReadIOEffect].}

proc parseNimReport(report: string): NimReport {....raises: [IOError, OSError,
    UnexpectedKindError, NilArgumentError, Exception, JsonError, ValueError,
    ParseError], tags: [ReadIOEffect].}

proc parseSpec(spec: string; file: AbsFile; skipFiles: seq[AbsFile] = @[]): NimTestSpec {....raises: [
    IOError, OSError, Exception, ValueError, ParseError, LexcastError],
    tags: [ReadIOEffect, RootEffect, ReadEnvEffect, WriteIOEffect].}

proc reportError(l: HLogger; report: NimReport; dump: NimState;
                 state: NimReportState = NimReportState()) {....raises: [
    NilArgumentError, ValueError, IOError, KeyError, ImplementKindError,
    ImplementError, ArgumentError, Exception, NoneArgumentError],
    tags: [ReadEnvEffect, WriteIOEffect, ReadIOEffect, RootEffect].}

proc runFromFile(file: AbsFile): NimRun {....raises: [IOError, OSError, Exception,
    ValueError, ParseError, LexcastError],
    tags: [ReadIOEffect, RootEffect, ReadEnvEffect, WriteIOEffect].}

proc runsFromDir(dir: AbsDir; first: seq[AbsFile] = @[]): seq[NimRun] {....raises: [
    PathError, ValueError, OSError, IOError, Exception, ParseError, LexcastError], tags: [
    ReadDirEffect, ReadIOEffect, RootEffect, ReadEnvEffect, WriteIOEffect].}

proc runTestDir(dir: AbsDir; dump: NimState; maxfail: int = high(int);
                first: seq[AbsFile] = @[]; l: HLogger = newTermLogger();
                parseRun: bool = true; hints: bool = true): bool {....raises: [
    PathError, ValueError, OSError, IOError, Exception, ParseError,
    LexcastError, NilArgumentError, UnexpectedKindError, JsonError, KeyError,
    ImplementKindError, ImplementError, ArgumentError, NoneArgumentError,
    ShellError], tags: [ReadDirEffect, ReadIOEffect, RootEffect, ReadEnvEffect,
                        WriteIOEffect, WriteDirEffect, ShellExecEffect,
                        ExecIOEffect].}

proc skipFileLineCol(str: var PosStr): tuple[file: AbsFile, line, column: int] {....raises: [
    NilArgumentError, IOError, OSError, Exception, UnexpectedCharError,
    ValueError], tags: [ReadIOEffect].}

proc skipKindDeclaredIn(str: var PosStr): tuple[kind: string, file: AbsFile,
    line, column: int] {....raises: [IOError, OSError, UnexpectedCharError,
                                  NilArgumentError, Exception, ValueError],
                         tags: [ReadIOEffect].}

proc skipKinds(reports: sink seq[NimReport];
               kind: set[NimReportKind] = {nrHint, nrWarning}): seq[NimReport] {.
    ...raises: [], tags: [].}