//===--- DiagnosticVerifier.cpp - Diagnostic Verifier (-verify) -----------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
//  This file implements the DiagnosticVerifier class.
//
//===----------------------------------------------------------------------===//

#include "swift/Frontend/DiagnosticVerifier.h"
#include "swift/AST/DiagnosticConsumer.h"
#include "swift/AST/DiagnosticsFrontend.h"
#include "swift/Basic/Assertions.h"
#include "swift/Basic/ColorUtils.h"
#include "swift/Basic/SourceManager.h"
#include "swift/Parse/Lexer.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
#include <optional>

using namespace swift;

const DiagnosticKind DiagnosticKindExpansion = DiagnosticKind((int)DiagnosticKind::Note + 1);

namespace {

struct ExpectedCheckMatchStartParser {
  StringRef MatchStart;
  const char *ClassificationStartLoc = nullptr;
  std::optional<DiagnosticKind> ExpectedClassification;

  ExpectedCheckMatchStartParser(StringRef MatchStart)
      : MatchStart(MatchStart) {}

  bool tryParseClassification() {
    if (MatchStart.starts_with("note")) {
      ClassificationStartLoc = MatchStart.data();
      ExpectedClassification = DiagnosticKind::Note;
      MatchStart = MatchStart.substr(strlen("note"));
      return true;
    }

    if (MatchStart.starts_with("warning")) {
      ClassificationStartLoc = MatchStart.data();
      ExpectedClassification = DiagnosticKind::Warning;
      MatchStart = MatchStart.substr(strlen("warning"));
      return true;
    }

    if (MatchStart.starts_with("error")) {
      ClassificationStartLoc = MatchStart.data();
      ExpectedClassification = DiagnosticKind::Error;
      MatchStart = MatchStart.substr(strlen("error"));
      return true;
    }

    if (MatchStart.starts_with("remark")) {
      ClassificationStartLoc = MatchStart.data();
      ExpectedClassification = DiagnosticKind::Remark;
      MatchStart = MatchStart.substr(strlen("remark"));
      return true;
    }

    if (MatchStart.starts_with("expansion")) {
      ClassificationStartLoc = MatchStart.data();
      ExpectedClassification = DiagnosticKindExpansion;
      MatchStart = MatchStart.substr(strlen("expansion"));
      return true;
    }

    return false;
  }

  bool parse(ArrayRef<std::string> prefixes) {
    // First try to parse as if we did not have a prefix. We always parse at
    // least expected-*.
    if (tryParseClassification())
      return true;

    // Otherwise, walk our prefixes until we find one that matches and attempt
    // to check for a note, warning, error, or remark.
    //
    // TODO: We could make this more flexible, but this should work in the
    // short term.
    for (auto &p : prefixes) {
      if (MatchStart.starts_with(p)) {
        MatchStart = MatchStart.substr(p.size());
        return tryParseClassification();
      }
    }

    return false;
  }
};

} // anonymous namespace

namespace swift {

struct ExpectedFixIt {
  const char *StartLoc, *EndLoc; // The loc of the {{ and }}'s.
  LineColumnRange Range;

  std::string Text;
};

struct DiagLoc {
  std::optional<unsigned> bufferID;
  unsigned line;
  unsigned column;
  SourceLoc sourceLoc;

  DiagLoc(SourceManager &diagSM, SourceManager &verifierSM,
          SourceLoc initialSourceLoc, bool wantEnd = false)
      : bufferID(std::nullopt), line(0), column(0), sourceLoc(initialSourceLoc)
  {
    if (sourceLoc.isInvalid())
      return;

    // Walk out of generated code for macros in default arguments so that we
    // register diagnostics emitted in them at the call site instead.
    while (true) {
      bufferID = diagSM.findBufferContainingLoc(sourceLoc);
      ASSERT(bufferID.has_value());

      auto generatedInfo = diagSM.getGeneratedSourceInfo(*bufferID);
      if (!generatedInfo || generatedInfo->originalSourceRange.isInvalid()
            || generatedInfo->kind != GeneratedSourceInfo::DefaultArgument)
        break;

      if (wantEnd)
        sourceLoc = generatedInfo->originalSourceRange.getEnd();
      else
        sourceLoc = generatedInfo->originalSourceRange.getStart();

      ASSERT(sourceLoc.isValid());
    }

    // If this diagnostic came from a different SourceManager (as can happen
    // while compiling a module interface), translate its SourceLoc to match the
    // verifier's SourceManager.
    if (&diagSM != &verifierSM) {
      sourceLoc = verifierSM.getLocForForeignLoc(sourceLoc, diagSM);
      bufferID = verifierSM.findBufferContainingLoc(sourceLoc);
    }

    // At this point, `bufferID` is filled in and `sourceLoc` is a location in
    // that buffer.
    if (sourceLoc.isValid())
      std::tie(line, column) = verifierSM.getLineAndColumnInBuffer(sourceLoc);
  }
};

} // end namespace swift

const LineColumnRange &
CapturedFixItInfo::getLineColumnRange(SourceManager &SM) const {
  if (LineColRange.StartLine != 0) {
    // Already computed.
    return LineColRange;
  }

  auto SrcRange = FixIt.getRange();

  DiagLoc startLoc(*diagSM, SM, SrcRange.getStart());
  LineColRange.StartLine = startLoc.line;
  LineColRange.StartCol = startLoc.column;

  DiagLoc endLoc(*diagSM, SM, SrcRange.getEnd(), /*wantEnd=*/true);
  LineColRange.EndLine = endLoc.line;
  LineColRange.EndCol = endLoc.column;

  return LineColRange;
}

namespace {

static constexpr StringLiteral fixitExpectationNoneString("none");
static constexpr StringLiteral categoryDocFileSpecifier("documentation-file=");
static constexpr StringLiteral groupNameSpecifier("group-name=");

struct ExpectedDiagnosticInfo {
  // This specifies the full range of the "expected-foo {{}}" specifier.
  const char *ExpectedStart, *ExpectedEnd = nullptr;

  // This specifies the full range of the classification string.
  const char *ClassificationStart, *ClassificationEnd = nullptr;

  DiagnosticKind Classification;

  // This is true if a '*' constraint is present to say that the diagnostic
  // may appear (or not) an uncounted number of times.
  bool mayAppear = false;

  // This is true if a '{{none}}' is present to mark that there should be no
  // extra fixits.
  bool noExtraFixitsMayAppear() const { return noneMarkerStartLoc != nullptr; };

  // This is the raw input buffer for the message text, the part in the
  // {{...}}
  StringRef MessageRange;

  // This is the message string with escapes expanded.
  std::string MessageStr;
  unsigned LineNo = ~0U;
  std::optional<unsigned> ColumnNo;
  std::optional<unsigned> TargetBufferID;

  using AlternativeExpectedFixIts = std::vector<ExpectedFixIt>;
  std::vector<AlternativeExpectedFixIts> Fixits = {};

  // Loc of {{none}}
  const char *noneMarkerStartLoc = nullptr;

  /// Represents a specifier of the form '{{documentation-file=note1}}'.
  struct ExpectedDocumentationFile {
    const char *StartLoc, *EndLoc; // The loc of the {{ and }}'s.
    StringRef Name; // Name of expected documentation file.

    ExpectedDocumentationFile(const char *StartLoc, const char *EndLoc,
                              StringRef Name)
        : StartLoc(StartLoc), EndLoc(EndLoc), Name(Name) {}
  };
  std::optional<ExpectedDocumentationFile> DocumentationFile;

  /// Represents a specifier of the form '{{group-name=GroupName}}'. Multiple
  /// of these are allowed per expected diagnostic; the diagnostic must belong
  /// to each named group.
  struct ExpectedGroupName {
    const char *StartLoc, *EndLoc; // The loc of the {{ and }}'s.
    StringRef Name; // Name of expected diagnostic group.

    ExpectedGroupName(const char *StartLoc, const char *EndLoc, StringRef Name)
        : StartLoc(StartLoc), EndLoc(EndLoc), Name(Name) {}
  };
  std::vector<ExpectedGroupName> GroupNames;

  std::vector<ExpectedDiagnosticInfo> NestedDiags = {};

  std::vector<ExpectedDiagnosticInfo> ExpectedChildNotes = {};
  // Locs of {{children: and }}
  const char *ChildrenMarkerStartLoc = nullptr;
  const char *ChildrenMarkerEndLoc = nullptr;
  // This diagnostic has been matched, but contains unmatched child notes
  bool HasBeenFound = false;

  ExpectedDiagnosticInfo(const char *ExpectedStart,
                         const char *ClassificationStart,
                         const char *ClassificationEnd,
                         DiagnosticKind Classification)
      : ExpectedStart(ExpectedStart), ClassificationStart(ClassificationStart),
        ClassificationEnd(ClassificationEnd), Classification(Classification) {}
};

static std::string getDiagKindString(DiagnosticKind Kind) {
  switch (Kind) {
  case DiagnosticKind::Error:
    return "error";
  case DiagnosticKind::Warning:
    return "warning";
  case DiagnosticKind::Note:
    return "note";
  case DiagnosticKind::Remark:
    return "remark";
  case DiagnosticKindExpansion:
    return "expansion";
  }

  llvm_unreachable("Unhandled DiagKind in switch.");
}

[[deprecated("only for use in the debugger")]] LLVM_ATTRIBUTE_USED
static llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                                     const CapturedDiagnosticInfo &D) {
      OS << "[id=" << D.ID;
  if (D.ParentID)
    OS << " parent=" << *D.ParentID;
  OS << " " << getDiagKindString(D.Classification);
  OS << " " << D.Line << ":" << D.Column;
  OS << " \"" << D.Message << "\"";
  if (!D.FixIts.empty())
    OS << " fixit-count=" << D.FixIts.size();
  if (!D.CategoryDocFile.empty())
    OS << " doc=" << D.CategoryDocFile;
  OS << "]";
  return OS;
}

/// Render the verifier syntax for a given documentation file.
static std::string
renderDocumentationFile(const std::string &documentationFile) {
  std::string Result;
  llvm::raw_string_ostream OS(Result);
  OS << "{{" << categoryDocFileSpecifier << documentationFile << "}}";
  return OS.str();
}

/// Render the verifier syntax for a given diagnostic group name.
static std::string renderGroupName(StringRef groupName) {
  std::string Result;
  llvm::raw_string_ostream OS(Result);
  OS << "{{" << groupNameSpecifier << groupName << "}}";
  return OS.str();
}

/// If we find the specified diagnostic in the list, return it with \c true .
/// If we find a near-match that varies only in classification, return it with
/// \c false.
/// Otherwise return \c CapturedDiagnostics.end() with \c false.
static std::tuple<std::vector<CapturedDiagnosticInfo>::iterator, bool>
findDiagnostic(std::vector<CapturedDiagnosticInfo> &CapturedDiagnostics,
               const ExpectedDiagnosticInfo &Expected, unsigned BufferID,
               SourceManager &SM, std::optional<size_t> ParentID) {
  auto fallbackI = CapturedDiagnostics.end();

  for (auto I = CapturedDiagnostics.begin(), E = CapturedDiagnostics.end();
       I != E; ++I) {
    // Verify the file and line of the diagnostic.
    if (I->Line != Expected.LineNo || I->SourceBufferID != BufferID)
      continue;

    // If a specific column was expected, verify it.
    if (Expected.ColumnNo.has_value() && I->Column != *Expected.ColumnNo)
      continue;

    // Verify the classification and string.
    if (I->Message.find(Expected.MessageStr) == StringRef::npos)
      continue;

    // Verify the parent.
    if (ParentID && I->ParentID != ParentID) {
      continue;
    }

    // Verify the classification and, if incorrect, remember as a second choice.
    if (I->Classification != Expected.Classification) {
      if (fallbackI == E && !Expected.MessageStr.empty())
        fallbackI = I;
      continue;
    }

    // Okay, we found a match, hurray!
    return { I, true };
  }

  // No perfect match; we'll return the fallback or `end()` instead.
  return { fallbackI, false };
}

/// If there are any -verify errors (e.g. differences between expectations
/// and actual diagnostics produced), apply fixits to the original source
/// file and drop it back in place.
static void autoApplyFixes(SourceManager &SM, unsigned BufferID,
                           ArrayRef<SMDiagnosticWithNotes> diags) {
  // Walk the list of diagnostics, pulling out any fixits into an array of just
  // them.
  SmallVector<llvm::SMFixIt, 4> FixIts;
  for (auto &diag : diags)
    FixIts.append(diag.Diag.getFixIts().begin(), diag.Diag.getFixIts().end());

  // If we have no fixits to apply, avoid touching the file.
  if (FixIts.empty())
    return;

  // Sort the fixits by their start location.
  std::sort(FixIts.begin(), FixIts.end(),
            [&](const llvm::SMFixIt &lhs, const llvm::SMFixIt &rhs) -> bool {
              return lhs.getRange().Start.getPointer() <
                     rhs.getRange().Start.getPointer();
            });
  // Coalesce identical fix-its. This happens most often with "expected-error 2"
  // syntax.
  FixIts.erase(std::unique(FixIts.begin(), FixIts.end(),
                           [](const llvm::SMFixIt &lhs,
                              const llvm::SMFixIt &rhs) -> bool {
                             return lhs.getRange().Start ==
                                        rhs.getRange().Start &&
                                    lhs.getRange().End == rhs.getRange().End &&
                                    lhs.getText() == rhs.getText();
                           }),
               FixIts.end());
  // Filter out overlapping fix-its. This allows the compiler to apply changes
  // to the easy parts of the file, and leave in the tricky cases for the
  // developer to handle manually.
  FixIts.erase(swift::removeAdjacentIf(
                   FixIts.begin(), FixIts.end(),
                   [](const llvm::SMFixIt &lhs, const llvm::SMFixIt &rhs) {
                     return lhs.getRange().End.getPointer() >
                            rhs.getRange().Start.getPointer();
                   }),
               FixIts.end());

  // Get the contents of the original source file.
  auto memBuffer = SM.getLLVMSourceMgr().getMemoryBuffer(BufferID);
  auto bufferRange = memBuffer->getBuffer();

  // Apply the fixes, building up a new buffer as an std::string.
  const char *LastPos = bufferRange.begin();
  std::string Result;

  for (auto &fix : FixIts) {
    // We cannot handle overlapping fixits, so assert that they don't happen.
    assert(LastPos <= fix.getRange().Start.getPointer() &&
           "Cannot handle overlapping fixits");

    // Keep anything from the last spot we've checked to the start of the fixit.
    Result.append(LastPos, fix.getRange().Start.getPointer());

    // Replace the content covered by the fixit with the replacement text.
    Result.append(fix.getText().begin(), fix.getText().end());

    // Next character to consider is at the end of the fixit.
    LastPos = fix.getRange().End.getPointer();
  }

  // Retain the end of the file.
  Result.append(LastPos, bufferRange.end());

  std::error_code error;
  llvm::raw_fd_ostream outs(memBuffer->getBufferIdentifier(), error,
                            llvm::sys::fs::OpenFlags::OF_None);
  if (!error)
    outs << Result;
}
} // end anonymous namespace

/// diagnostics for '<unknown>:0' should be considered as unexpected.
bool DiagnosticVerifier::verifyUnknown(
    std::vector<CapturedDiagnosticInfo> &CapturedDiagnostics) const {
  bool HadError = false;
  auto CapturedDiagIter = CapturedDiagnostics.begin();
  while (CapturedDiagIter != CapturedDiagnostics.end()) {
    if (CapturedDiagIter->Loc.isValid()) {
      ++CapturedDiagIter;
      continue;
    }

    HadError = true;
    std::string Message =
        ("unexpected " +
         getDiagKindString(CapturedDiagIter->Classification) +
         " produced: " + CapturedDiagIter->Message)
            .str();

    auto diag = SM.GetMessage({}, llvm::SourceMgr::DK_Error, Message, {}, {});
    printDiagnostic(diag);
    CapturedDiagIter = CapturedDiagnostics.erase(CapturedDiagIter);
  }

  if (HadError) {
    auto NoteMessage = "use '-verify-ignore-unknown' to "
                       "ignore diagnostics at this location";
    auto noteDiag =
        SM.GetMessage({}, llvm::SourceMgr::DK_Note, NoteMessage, {}, {});
    printDiagnostic(noteDiag);
  }
  return HadError;
}

bool DiagnosticVerifier::verifyUnrelated(
    std::vector<CapturedDiagnosticInfo> &CapturedDiagnostics) const {
  bool HadError = false;
  auto CapturedDiagIter = CapturedDiagnostics.begin();
  while (CapturedDiagIter != CapturedDiagnostics.end()) {
    SourceLoc Loc = CapturedDiagIter->Loc;
    if (!Loc.isValid()) {
      ++CapturedDiagIter;
      // checked by verifyUnknown
      continue;
    }

    HadError = true;
    std::string Message =
        ("unexpected " +
         getDiagKindString(CapturedDiagIter->Classification) +
         " produced: " + CapturedDiagIter->Message)
            .str();

    auto diag = SM.GetMessage(Loc, llvm::SourceMgr::DK_Error, Message, {}, {});
    printDiagnostic(diag);

    unsigned TopmostBufferID = SM.findBufferContainingLoc(Loc);
    while (const GeneratedSourceInfo *GSI =
               SM.getGeneratedSourceInfo(TopmostBufferID)) {
      SourceLoc ParentLoc = GSI->originalSourceRange.getStart();
      if (ParentLoc.isInvalid())
        break;
      TopmostBufferID = SM.findBufferContainingLoc(ParentLoc);
      Loc = ParentLoc;
    }
    auto FileName = SM.getIdentifierForBuffer(TopmostBufferID);
    auto noteDiag =
        SM.GetMessage(Loc, llvm::SourceMgr::DK_Note,
                      ("file '" + FileName +
                       "' is not parsed for 'expected' statements. Use "
                       "'-verify-additional-file " +
                       FileName +
                       "' to enable, or '-verify-ignore-unrelated' to "
                       "ignore diagnostics in this file"),
                      {}, {});
    printDiagnostic(noteDiag);
    CapturedDiagIter = CapturedDiagnostics.erase(CapturedDiagIter);
  }

  return HadError;
}

/// Return true if the given \p ExpectedFixIt is in the fix-its emitted by
/// diagnostic \p D.
bool DiagnosticVerifier::checkForFixIt(
    const ExpectedDiagnosticInfo::AlternativeExpectedFixIts &ExpectedAlts,
    const CapturedDiagnosticInfo &D, unsigned BufferID) const {
  for (auto &ActualFixIt : D.FixIts) {
    for (auto &Expected : ExpectedAlts) {
      if (ActualFixIt.getText() != Expected.Text)
        continue;

      auto &ActualRange = ActualFixIt.getLineColumnRange(SM);

      if (Expected.Range.StartCol != ActualRange.StartCol ||
          Expected.Range.EndCol != ActualRange.EndCol ||
          Expected.Range.StartLine != ActualRange.StartLine ||
          Expected.Range.EndLine != ActualRange.EndLine) {
        continue;
      }
      return true;
    }
  }

  return false;
}

void DiagnosticVerifier::printDiagnostic(const SMDiagnosticWithNotes &Diag) const {
  printDiagnostic(Diag.Diag);
  for (const auto &Note : Diag.Notes)
    printDiagnostic(Note);
}

void DiagnosticVerifier::printDiagnostic(const llvm::SMDiagnostic &Diag) const {
  raw_ostream &stream = llvm::errs();
  ColoredStream coloredStream{stream};
  raw_ostream &out = UseColor ? coloredStream : stream;
  llvm::SourceMgr &Underlying = SM.getLLVMSourceMgr();
  if (Diag.getFilename().empty()) {
    llvm::SMDiagnostic SubstDiag(
        *Diag.getSourceMgr(), Diag.getLoc(), "<empty-filename>",
        Diag.getLineNo(), Diag.getColumnNo(), Diag.getKind(), Diag.getMessage(),
        Diag.getLineContents(), Diag.getRanges(), Diag.getFixIts());
    Underlying.PrintMessage(out, SubstDiag);
  } else
    Underlying.PrintMessage(out, Diag);

  SourceLoc Loc = SourceLoc::getFromPointer(Diag.getLoc().getPointer());
  if (Loc.isInvalid())
    return;
  unsigned BufferID = SM.findBufferContainingLoc(Loc);
  if (const GeneratedSourceInfo *GSI = SM.getGeneratedSourceInfo(BufferID)) {
    SourceLoc ParentLoc = GSI->originalSourceRange.getStart();
    if (ParentLoc.isInvalid())
      return;
    printDiagnostic(SM.GetMessage(ParentLoc, llvm::SourceMgr::DK_Note,
                                  "in expansion from here", {}, {}));
  }
}

std::string
DiagnosticVerifier::renderFixits(ArrayRef<CapturedFixItInfo> ActualFixIts,
                                 unsigned BufferID,
                                 unsigned DiagnosticLineNo) const {
  std::string Result;
  llvm::raw_string_ostream OS(Result);
  interleave(
      ActualFixIts,
      [&](const CapturedFixItInfo &ActualFixIt) {
        auto &ActualRange = ActualFixIt.getLineColumnRange(SM);
        OS << "{{";

        if (ActualRange.StartLine != DiagnosticLineNo)
          OS << ActualRange.StartLine << ':';
        OS << ActualRange.StartCol;

        OS << '-';

        if (ActualRange.EndLine != ActualRange.StartLine)
          OS << ActualRange.EndLine << ':';
        OS << ActualRange.EndCol;

        OS << '=';

        for (auto C : ActualFixIt.getText()) {
          if (C == '\n')
            OS << "\\n";
          else if (C == '}' || C == '\\')
            OS << '\\' << C;
          else
            OS << C;
        }
        OS << "}}";
      },
      [&] { OS << ' '; });
  return OS.str();
}

/// Parse the introductory line-column range of an expected fix-it by consuming
/// the given input string. The range format is \c ([+-]?N:)?N-([+-]?N:)?N
/// where \c 'N' is \c [0-9]+.
///
/// \param DiagnosticLineNo The line number of the associated expected
/// diagnostic; used to turn line offsets into line numbers.
std::optional<LineColumnRange>
DiagnosticVerifier::parseExpectedFixItRange(StringRef &Str,
                                            unsigned DiagnosticLineNo) {
  assert(!Str.empty());

  struct ParsedLineAndColumn {
    std::optional<unsigned> Line;
    unsigned Column;
  };

  const auto parseLineAndColumn = [&]() -> std::optional<ParsedLineAndColumn> {
    enum class OffsetKind : uint8_t { None, Plus, Minus };

    OffsetKind LineOffsetKind = OffsetKind::None;
    if (!Str.empty()) {
      switch (Str.front()) {
      case '+':
        LineOffsetKind = OffsetKind::Plus;
        Str = Str.drop_front();
        break;
      case '-':
        LineOffsetKind = OffsetKind::Minus;
        Str = Str.drop_front();
        break;
      default:
        break;
      }
    }

    unsigned FirstVal = 0;
    if (Str.consumeInteger(10, FirstVal)) {
      if (LineOffsetKind == OffsetKind::None) {
        addError(Str.data(),
                      "expected line or column number in fix-it verification");
      } else {
        addError(Str.data(),
                      "expected line offset after leading '+' or '-' in fix-it "
                      "verification");
      }
      return std::nullopt;
    }

    // If the first value is not followed by a colon, it is either a column or a
    // line offset that is missing a column.
    if (Str.empty() || Str.front() != ':') {
      if (LineOffsetKind == OffsetKind::None) {
        return ParsedLineAndColumn{std::nullopt, FirstVal};
      }

      addError(Str.data(),
                    "expected colon-separated column number after line offset "
                    "in fix-it verification");
      return std::nullopt;
    }

    unsigned Column = 0;
    Str = Str.drop_front();
    if (Str.consumeInteger(10, Column)) {
      addError(Str.data(),
                    "expected column number after ':' in fix-it verification");
      return std::nullopt;
    }

    // Apply the offset relative to the line of the expected diagnostic.
    switch (LineOffsetKind) {
    case OffsetKind::None:
      break;
    case OffsetKind::Plus:
      FirstVal += DiagnosticLineNo;
      break;
    case OffsetKind::Minus:
      FirstVal = DiagnosticLineNo - FirstVal;
      break;
    }

    return ParsedLineAndColumn{FirstVal, Column};
  };

  LineColumnRange Range;

  if (const auto LineAndCol = parseLineAndColumn()) {
    // The start line defaults to the line of the expected diagnostic.
    Range.StartLine = LineAndCol->Line.value_or(DiagnosticLineNo);
    Range.StartCol = LineAndCol->Column;
  } else {
    return std::nullopt;
  }

  if (!Str.empty() && Str.front() == '-') {
    Str = Str.drop_front();
  } else {
    addError(Str.data(),
                  "expected '-' range separator in fix-it verification");
    return std::nullopt;
  }

  if (const auto LineAndCol = parseLineAndColumn()) {
    // The end line defaults to the start line.
    Range.EndLine = LineAndCol->Line.value_or(Range.StartLine);
    Range.EndCol = LineAndCol->Column;
  } else {
    return std::nullopt;
  }

  return Range;
}

/// Before we do anything, check if any of our prefixes are prefixes of later
/// prefixes. In such a case, we will never actually pattern match the later
/// prefix. In such a case, crash with a nice error message.
static void validatePrefixList(ArrayRef<std::string> prefixes) {
  // Work backwards through the prefix list.
  while (!prefixes.empty()) {
    auto target = StringRef(prefixes.front());
    prefixes = prefixes.drop_front();

    for (auto &p : prefixes) {
      if (StringRef(p).starts_with(target)) {
        llvm::errs() << "Error! Found a verifier diagnostic additional prefix "
                        "that is a prefix of a later prefix. The later prefix "
                        "will never be pattern matched!\n"
                     << "First Prefix: " << target << '\n'
                     << "Second Prefix: " << p << '\n';
        llvm::report_fatal_error("Standard compiler error!\n");
      }
    }
  }
}

bool DiagnosticVerifier::parseTargetBufferName(StringRef &MatchStart,
                                               StringRef &Out,
                                               size_t &TextStartIdx) {
  StringRef Offs = MatchStart.slice(0, TextStartIdx);

  if (Offs.starts_with("@'")) {
    // Windows paths may start with something like T:\, so they need to be quoted
    // to prevent the colon from seeming like the end of the path.
    Offs = Offs.substr(2);
    size_t QuoteEndIndex = Offs.find("'");
    if (QuoteEndIndex == StringRef::npos) {
      addError(
          MatchStart.data(),
          "no closing \"'\" found to match opening \"'\" for file path here");
      return false;
    }
    if (!Offs.substr(QuoteEndIndex + 1).starts_with(":")) {
      addError(MatchStart.data(), "expected ':' after buffer name");
      return false;
    }
    Out = Offs.slice(0, QuoteEndIndex);
    MatchStart = MatchStart.substr(QuoteEndIndex + 3);
    TextStartIdx -= (QuoteEndIndex + 3);
    return true;
  }

  size_t LineIndex = Offs.find(':');
  if (LineIndex == 0 || LineIndex == StringRef::npos)
    return false;
  Out = Offs.slice(1, LineIndex);
  MatchStart = MatchStart.substr(LineIndex);
  TextStartIdx -= LineIndex;
  return true;
}

void DiagnosticVerifier::parseNestedExpectedDiagInfoBlock(
    unsigned BufferID, StringRef MatchStartIn,
    unsigned &PrevExpectedContinuationLine,
    std::vector<ExpectedDiagnosticInfo> &NestedDiagsOut, size_t &End) {
  size_t NestedMatch = MatchStartIn.find("expected-");
  // Scan the memory buffer looking for expected-note/warning/error.
  while (NestedMatch != StringRef::npos) {
    StringRef NestedMatchStartIn = MatchStartIn.substr(NestedMatch);
    ExpectedDiagnosticInfo NestedExpected(nullptr, nullptr, nullptr,
                                          DiagnosticKind(-1));
    unsigned NestedCount =
        parseExpectedDiagInfo(BufferID, NestedMatchStartIn,
                              PrevExpectedContinuationLine, NestedExpected);

    size_t PrevMatchEnd = NestedMatch + 1;
    if (NestedCount > 0) {
      // Add the diagnostic the expected number of times.
      for (; NestedCount; --NestedCount)
        NestedDiagsOut.push_back(NestedExpected);
      size_t NestedMatchEnd =
          NestedExpected.ExpectedEnd - NestedMatchStartIn.data();
      assert(NestedMatchEnd > 0);
      PrevMatchEnd = NestedMatch + NestedMatchEnd;
    } else {
      // Skip line if this an expected diagnostic with a prefix this invocation
      // ignores, otherwise its }} will close the expansion.
      PrevMatchEnd = MatchStartIn.find("\n", PrevMatchEnd);
    }

    size_t NextEnd = MatchStartIn.find("}}", PrevMatchEnd);
    NestedMatch = MatchStartIn.find("expected-", PrevMatchEnd);
    if (NextEnd < NestedMatch) {
      End = NextEnd;
      break;
    }
  }
}

unsigned DiagnosticVerifier::parseExpectedDiagInfo(
    unsigned BufferID, StringRef MatchStartIn,
    unsigned &PrevExpectedContinuationLine,
    ExpectedDiagnosticInfo &Expected) {
  const SourceLoc BufferStartLoc = SM.getLocForBufferStart(BufferID);
  StringRef InputFile = SM.getEntireTextForBuffer(BufferID);

  StringRef MatchStart = MatchStartIn;
  const char *DiagnosticLoc = MatchStart.data();
  MatchStart = MatchStart.substr(strlen("expected-"));

  const char *ClassificationStartLoc = nullptr;
  std::optional<DiagnosticKind> ExpectedClassification;
  {
    ExpectedCheckMatchStartParser parser(MatchStart);
    // If we fail to parse... continue.
    if (!parser.parse(AdditionalExpectedPrefixes)) {
      return 0;
    }
    MatchStart = parser.MatchStart;
    ClassificationStartLoc = parser.ClassificationStartLoc;
    ExpectedClassification = parser.ExpectedClassification;
  }
  assert(ClassificationStartLoc);
  assert(bool(ExpectedClassification));

  // Skip any whitespace before the {{.
  MatchStart = MatchStart.substr(MatchStart.find_first_not_of(" \t"));

  size_t TextStartIdx = MatchStart.find("{{");
  if (TextStartIdx >=
      MatchStart.find("\n")) { // Either not found, or found beyond next \n
    addError(MatchStart.data(),
             "expected {{ in expected-warning/note/error/expansion line");
    return 0;
  }

  Expected = ExpectedDiagnosticInfo(DiagnosticLoc, ClassificationStartLoc,
                                  /*ClassificationEndLoc=*/MatchStart.data(),
                                  *ExpectedClassification);
  int LineOffset = 0;
  bool AbsoluteLine = false;

  if (TextStartIdx > 0 && MatchStart[0] == '@') {
    if (MatchStart[1] != '#' && MatchStart[1] != '+' && MatchStart[1] != '-' && MatchStart[1] != ':' && (MatchStart[1] < '0' || MatchStart[1] > '9')) {
      StringRef TargetBufferName;
      if (!parseTargetBufferName(MatchStart, TargetBufferName, TextStartIdx)) {
        addError(MatchStart.data(), "expected '+'/'-' for line offset, ':' "
                                    "for column, or a buffer name");
        return 0;
      }
      Expected.TargetBufferID = SM.getIDForBufferIdentifier(TargetBufferName);
      if (!Expected.TargetBufferID) {
        addError(MatchStart.data(),
                 "no buffer with name '" + TargetBufferName + "' found");
        return 0;
      }
      if (MatchStart[0] != ':' || MatchStart[1] < '0' || MatchStart[1] > '9') {
        addError(MatchStart.data(),
                 "expected absolute line number for diagnostic in other buffer");
        return 0;
      }
    }

    // Location marker reference: @#markerName or @#markerName:col
    StringRef Offs;
    if (MatchStart[0] == '@' && MatchStart[1] == '#') {
      size_t NameStart = 2;
      size_t NameEnd = NameStart;
      while (NameEnd < TextStartIdx &&
             (isalnum(MatchStart[NameEnd]) ||
              MatchStart[NameEnd] == '_' || MatchStart[NameEnd] == '-'))
        ++NameEnd;

      if (NameEnd == NameStart) {
        addError(MatchStart.data() + 1,
                 "expected marker name after '#'");
        return 0;
      }

      StringRef MarkerName = MatchStart.slice(NameStart, NameEnd);
      auto It = LocationMarkers.find(MarkerName);
      if (It == LocationMarkers.end()) {
        addError(MatchStart.data() + 1,
                 "use of undefined location marker '#" + MarkerName + "'");
        return 0;
      }

      LineOffset = It->second.Line;
      AbsoluteLine = true;
      if (It->second.BufferID != BufferID)
        Expected.TargetBufferID = It->second.BufferID;

      // Extract the remainder after the marker name (e.g. ":col" or empty)
      // and let the shared column-parsing code below handle it.
      Offs = MatchStart.slice(NameEnd, TextStartIdx).rtrim();
    } else if (MatchStart[1] == '+') {
      Offs = MatchStart.slice(2, TextStartIdx).rtrim();
    } else {
      Offs = MatchStart.slice(1, TextStartIdx).rtrim();
      if (Offs[0] >= '0' && Offs[0] <= '9')
        AbsoluteLine = true;
    }

    size_t SpaceIndex = Offs.find(' ');
    if (SpaceIndex != StringRef::npos && SpaceIndex < TextStartIdx) {
      size_t Delta = Offs.size() - SpaceIndex;
      MatchStart = MatchStart.substr(TextStartIdx - Delta);
      TextStartIdx = Delta;
      Offs = Offs.slice(0, SpaceIndex);
    } else {
      MatchStart = MatchStart.substr(TextStartIdx);
      TextStartIdx = 0;
    }

    size_t ColonIndex = Offs.find(':');
    // Check whether a line offset was provided (not applicable for markers).
    if (!LineOffset && ColonIndex != 0) {
      StringRef LineOffs = Offs.slice(0, ColonIndex);
      if (LineOffs.getAsInteger(10, LineOffset)) {
        addError(MatchStart.data(), "expected line offset before '{{'");
        return 0;
      }
    }

    // Check whether a column was provided
    if (ColonIndex != StringRef::npos) {
      Offs = Offs.slice(ColonIndex + 1, Offs.size());
      int Column = 0;
      if (Offs.getAsInteger(10, Column)) {
        addError(MatchStart.data(), "expected column before '{{'");
        return 0;
      }
      Expected.ColumnNo = Column;
    }
  }

  if (Expected.Classification == DiagnosticKindExpansion && !Expected.ColumnNo.has_value()) {
    addError(DiagnosticLoc, "expected-expansion requires column location");
    return 0;
  }

  unsigned Count = 1;
  if (TextStartIdx > 0) {
    StringRef CountStr = MatchStart.substr(0, TextStartIdx).trim(" \t");
    if (CountStr == "*") {
      Expected.mayAppear = true;
    } else {
      if (CountStr.getAsInteger(10, Count)) {
        addError(MatchStart.data(), "expected match count before '{{'");
        return 0;
      }
      if (Count == 0) {
        addError(MatchStart.data(),
                 "expected positive match count before '{{'");
        return 0;
      }
    }

    // Resync up to the '{{'.
    MatchStart = MatchStart.substr(TextStartIdx);
  }

  size_t End = StringRef::npos;
  if (Expected.Classification == DiagnosticKindExpansion) {
    parseNestedExpectedDiagInfoBlock(BufferID, MatchStart,
                                     PrevExpectedContinuationLine,
                                     Expected.NestedDiags, End);

    if (End == StringRef::npos) {
      addError(DiagnosticLoc,
               "didn't find '}}' to match '{{' in expected-expansion");
      return 0;
    }
    if (Expected.NestedDiags.size() == 0) {
      addError(DiagnosticLoc, "expected-expansion block is empty");
      // Keep going
    }
  } else {
    End = MatchStart.find("}}");
    if (End == StringRef::npos) {
      addError(
          MatchStart.data(),
          "didn't find '}}' to match '{{' in expected-warning/note/error line");
      return 0;
    }
  }

  llvm::SmallString<256> Buf;
  Expected.MessageRange = MatchStart.slice(2, End);
  Expected.MessageStr =
      Lexer::getEncodedStringSegment(Expected.MessageRange, Buf).str();
  if (AbsoluteLine)
    Expected.LineNo = 0;
  else if (PrevExpectedContinuationLine)
    Expected.LineNo = PrevExpectedContinuationLine;
  else
    Expected.LineNo =
        SM.getLineAndColumnInBuffer(BufferStartLoc.getAdvancedLoc(
                                        MatchStart.data() - InputFile.data()),
                                    BufferID)
            .first;
  Expected.LineNo += LineOffset;

  // Check if the next expected diagnostic should be in the same line.
  StringRef AfterEnd = MatchStart.substr(End + strlen("}}"));
  AfterEnd = AfterEnd.substr(AfterEnd.find_first_not_of(" \t"));
  if (AfterEnd.starts_with("\\"))
    PrevExpectedContinuationLine = Expected.LineNo;
  else
    PrevExpectedContinuationLine = 0;

  // Scan for fix-its: {{10-14=replacement text}}
  bool startNewAlternatives = true;
  StringRef ExtraChecks = MatchStart.substr(End + 2).ltrim(" \t");
  while (ExtraChecks.starts_with("{{") &&
         !ExtraChecks.starts_with("{{children:")) {
    // First make sure we have a closing "}}".
    size_t EndIndex = ExtraChecks.find("}}");
    if (EndIndex == StringRef::npos) {
      addError(ExtraChecks.data(),
               "didn't find '}}' to match '{{' in diagnostic verification");
      break;
    }

    // Allow for close braces to appear in the replacement text.
    while (EndIndex + 2 < ExtraChecks.size() &&
           ExtraChecks[EndIndex + 2] == '}')
      ++EndIndex;

    const char *OpenLoc = ExtraChecks.data(); // Beginning of opening '{{'.
    const char *CloseLoc =
        ExtraChecks.data() + EndIndex + 2; // End of closing '}}'.

    StringRef CheckStr = ExtraChecks.slice(2, EndIndex);
    // Check for matching a later "}}" on a different line.
    if (CheckStr.find_first_of("\r\n") != StringRef::npos) {
      addError(ExtraChecks.data(), "didn't find '}}' to match '{{' in "
                                   "diagnostic verification");
      break;
    }

    // Prepare for the next round of checks.
    ExtraChecks = ExtraChecks.substr(EndIndex + 2).ltrim(" \t");

    // Handle fix-it alternation.
    // If two fix-its are separated by `||`, we can match either of the two.
    // This is represented by putting them in the same subarray of `Fixits`.
    // If they are not separated by `||`, we must match both of them.
    // This is represented by putting them in separate subarrays of `Fixits`.
    if (startNewAlternatives &&
        (Expected.Fixits.empty() || !Expected.Fixits.back().empty()))
      Expected.Fixits.push_back({});

    if (ExtraChecks.starts_with("||")) {
      startNewAlternatives = false;
      ExtraChecks = ExtraChecks.substr(2).ltrim(" \t");
    } else {
      startNewAlternatives = true;
    }

    // If this check starts with 'documentation-file=', check for a
    // documentation file name instead of a fix-it.
    if (CheckStr.starts_with(categoryDocFileSpecifier)) {
      if (Expected.DocumentationFile.has_value()) {
        addError(CheckStr.data(),
                 "each verified diagnostic may only have one "
                 "{{documentation-file=<#notes#>}} declaration");
        continue;
      }

      // Trim 'documentation-file='.
      StringRef name = CheckStr.substr(categoryDocFileSpecifier.size());
      Expected.DocumentationFile = {OpenLoc, CloseLoc, name};
      continue;
    }

    // If this check starts with 'group-name=', check for a diagnostic group
    // name instead of a fix-it. Multiple group-name specifiers are allowed.
    if (CheckStr.starts_with(groupNameSpecifier)) {
      // Trim 'group-name='.
      StringRef name = CheckStr.substr(groupNameSpecifier.size());
      Expected.GroupNames.push_back({OpenLoc, CloseLoc, name});
      continue;
    }

    // This wasn't a documentation file specifier, so it must be a fix-it.
    // Special case for specifying no fixits should appear.
    if (CheckStr == fixitExpectationNoneString) {
      if (Expected.noneMarkerStartLoc) {
        addError(
            CheckStr.data() - 2,
            Twine("A second {{") + fixitExpectationNoneString +
                "}} was found. It may only appear once in an expectation.");
        break;
      }

      Expected.noneMarkerStartLoc = CheckStr.data() - 2;
      continue;
    }

    if (Expected.noneMarkerStartLoc) {
      addError(Expected.noneMarkerStartLoc, Twine("{{") +
                                                fixitExpectationNoneString +
                                                "}} must be at the end.");
      break;
    }

    if (CheckStr.empty()) {
      addError(CheckStr.data(), Twine("expected fix-it verification within "
                                      "braces; example: '1-2=text' or '") +
                                    fixitExpectationNoneString + Twine("'"));
      continue;
    }

    // Parse the pieces of the fix-it.
    ExpectedFixIt FixIt;
    FixIt.StartLoc = OpenLoc;
    FixIt.EndLoc = CloseLoc;

    if (const auto range =
            parseExpectedFixItRange(CheckStr, Expected.LineNo)) {
      FixIt.Range = range.value();
    } else {
      continue;
    }

    if (!CheckStr.empty() && CheckStr.front() == '=') {
      CheckStr = CheckStr.drop_front();
    } else {
      addError(CheckStr.data(),
               "expected '=' after range in fix-it verification");
      continue;
    }

    // Translate literal "\\n" into '\n', inefficiently.
    for (const char *current = CheckStr.begin(), *end = CheckStr.end();
         current != end;
         /* in loop */) {
      if (*current == '\\' && current + 1 < end) {
        if (current[1] == 'n') {
          FixIt.Text += '\n';
          current += 2;
        } else { // Handle \}, \\, etc.
          FixIt.Text += current[1];
          current += 2;
        }

      } else {
        FixIt.Text += *current++;
      }
    }

    if (Expected.Classification == DiagnosticKindExpansion) {
      addError(OpenLoc, "expected-expansion cannot have fixits");
    }
    Expected.Fixits.back().push_back(FixIt);
  }

  if (ExtraChecks.starts_with("{{children:")) {
    Expected.ChildrenMarkerStartLoc = ExtraChecks.data();
    ExtraChecks = ExtraChecks.substr(StringRef("{{children:").size());
    parseNestedExpectedDiagInfoBlock(
        BufferID, ExtraChecks, PrevExpectedContinuationLine, Expected.ExpectedChildNotes, End);

    if (End == StringRef::npos) {
      addError(Expected.ChildrenMarkerStartLoc,
               "didn't find '}}' to match '{{children:'");
      return 0;
    }
    Expected.ChildrenMarkerEndLoc = ExtraChecks.substr(End).data();

    if (!VerifyChildNotes) {
      addError(Expected.ChildrenMarkerStartLoc,
               "child diagnostics block requires -verify-child-notes");
      Expected.ExpectedChildNotes.clear();
    } else if (Expected.ExpectedChildNotes.size() == 0) {
      addError(DiagnosticLoc, "child diagnostics block is empty");
    }

    auto ChildNote = Expected.ExpectedChildNotes.begin();
    while (ChildNote != Expected.ExpectedChildNotes.end()) {
      if (ChildNote->Classification != DiagnosticKind::Note) {
        addError(ChildNote->ClassificationStart,
                 "only notes allowed in child diagnostics block");
        ChildNote = Expected.ExpectedChildNotes.erase(ChildNote);
      } else {
        ++ChildNote;
      }
    }
    ExtraChecks = ExtraChecks.substr(End + 2).ltrim(" \t");

    if (ExtraChecks.starts_with("{{")) {
      addError(ExtraChecks.data(),
               "fix-it, documentation, and group-name matchers must come "
               "before child notes");
    }
  }

  // If there's a trailing empty alternation, remove it.
  if (!Expected.Fixits.empty() && Expected.Fixits.back().empty())
    Expected.Fixits.pop_back();

  Expected.ExpectedEnd = ExtraChecks.data();

  // Don't include trailing whitespace in the expected-foo{{}} range.
  while (isspace(Expected.ExpectedEnd[-1]))
    --Expected.ExpectedEnd;

  return Count;
}

void DiagnosticVerifier::verifyDiagnostics(
    std::vector<ExpectedDiagnosticInfo> &ExpectedDiagnostics, unsigned BufferID,
    std::optional<size_t> ParentID) {
  // Make sure all the expected diagnostics appeared.
  std::reverse(ExpectedDiagnostics.begin(), ExpectedDiagnostics.end());

  for (unsigned i = ExpectedDiagnostics.size(); i != 0; ) {
    --i;
    auto &expected = ExpectedDiagnostics[i];

    unsigned ID = expected.TargetBufferID.value_or(BufferID);
    // Check to see if we had this expected diagnostic.
    if (expected.Classification == DiagnosticKindExpansion) {
      SourceLoc Loc = SM.getLocForLineCol(BufferID, expected.LineNo, *expected.ColumnNo);
      if (Expansions.count(Loc) == 0) {
        addError(expected.ExpectedStart,
                 "no expansion with diagnostics starting at " +
                     std::to_string(expected.LineNo) + ":" + std::to_string(*expected.ColumnNo));
        continue;
      }
      unsigned ExpansionBufferID = Expansions[Loc];
      verifyDiagnostics(expected.NestedDiags, ExpansionBufferID,
                        /*ParentDiagnostic=*/std::nullopt);
      if (expected.NestedDiags.empty())
        ExpectedDiagnostics.erase(ExpectedDiagnostics.begin()+i);
      continue;
    }
    auto FoundDiagnosticInfo =
        findDiagnostic(CapturedDiagnostics, expected, ID, SM, ParentID);
    auto FoundDiagnosticIter = std::get<0>(FoundDiagnosticInfo);
    if (FoundDiagnosticIter == CapturedDiagnostics.end()) {
      // Diagnostic didn't exist.  If this is a 'mayAppear' diagnostic, then
      // we're ok.  Otherwise, leave it in the list.
      if (expected.mayAppear)
        ExpectedDiagnostics.erase(ExpectedDiagnostics.begin()+i);
      continue;
    }

    auto emitFixItsError = [&](const char *location, const Twine &message,
                               const char *replStartLoc, const char *replEndLoc,
                               const std::string &replStr) {
      llvm::SMFixIt fix(llvm::SMRange(llvm::SMLoc::getFromPointer(replStartLoc),
                                      llvm::SMLoc::getFromPointer(replEndLoc)),
                        replStr);
      addError(location, message, fix);
    };

    auto &FoundDiagnostic = *FoundDiagnosticIter;

    if (!std::get<1>(FoundDiagnosticInfo)) {
      // Found a diagnostic with the right location and text but the wrong
      // classification or parent. We'll emit an error about the mismatch and
      // thereafter pretend that the diagnostic fully matched.
      auto expectedKind = getDiagKindString(expected.Classification);
      auto actualKind = getDiagKindString(FoundDiagnostic.Classification);
      if (expectedKind != actualKind)
        emitFixItsError(expected.ClassificationStart,
                        llvm::Twine("expected ") + expectedKind + ", not " +
                            actualKind,
                        expected.ClassificationStart,
                        expected.ClassificationEnd, actualKind);
      else {
        ASSERT(ParentID &&
               "fallback that matches kind but is not child note");
        addError(expected.ExpectedStart,
                 "matched child note with different parent");
      }
    }

    const char *missedFixitLoc = nullptr;
    // Verify that any expected fix-its are present in the diagnostic.
    for (auto fixitAlternates : expected.Fixits) {
      assert(!fixitAlternates.empty() && "an empty alternation survived");

      // If we found it, we're ok.
      if (!checkForFixIt(fixitAlternates, FoundDiagnostic, BufferID)) {
        missedFixitLoc = fixitAlternates.front().StartLoc;
        break;
      }
    }

    const bool isUnexpectedFixitsSeen =
        expected.Fixits.size() < FoundDiagnostic.FixIts.size();

    struct ActualFixitsPhrase {
      std::string phrase;
      std::string actualFixits;
    };

    auto makeActualFixitsPhrase =
        [&](ArrayRef<CapturedFixItInfo> actualFixits) -> ActualFixitsPhrase {
      std::string actualFixitsStr =
          renderFixits(actualFixits, BufferID, expected.LineNo);

      return ActualFixitsPhrase{(Twine("actual fix-it") +
                                 (actualFixits.size() >= 2 ? "s" : "") +
                                 " seen: " + actualFixitsStr).str(),
                                actualFixitsStr};
    };

    // If we have any expected fixits that didn't get matched, then they are
    // wrong.  Replace the failed fixit with what actually happened.

    if (missedFixitLoc) {
      // If we had an incorrect expected fixit, render it and produce a fixit
      // of our own.

      assert(!expected.Fixits.empty() &&
             "some fix-its should be expected here");

      const char *replStartLoc = expected.Fixits.front().front().StartLoc;
      const char *replEndLoc = expected.Fixits.back().back().EndLoc;

      std::string message = "expected fix-it not seen";
      std::string actualFixits;

      if (FoundDiagnostic.FixIts.empty()) {
        /// If actual fix-its is empty,
        /// eat a space before first marker.
        /// For example,
        ///
        /// @code
        /// expected-error {{message}} {{1-2=aa}}
        ///                           ~~~~~~~~~~~
        ///                           ^ remove
        /// @endcode
        if (replStartLoc[-1] == ' ') {
          --replStartLoc;
        }
      } else {
        auto phrase = makeActualFixitsPhrase(FoundDiagnostic.FixIts);
        actualFixits = phrase.actualFixits;
        message += "; " + phrase.phrase;
      }

      emitFixItsError(missedFixitLoc, message, replStartLoc, replEndLoc,
                      actualFixits);
    } else if (expected.noExtraFixitsMayAppear() && isUnexpectedFixitsSeen) {
      // If unexpected fixit were produced, add a fixit to add them in.

      assert(!FoundDiagnostic.FixIts.empty() &&
             "some fix-its should be produced here");
      assert(expected.noneMarkerStartLoc && "none marker location is null");

      const char *replStartLoc = nullptr, *replEndLoc = nullptr;
      std::string message;
      if (expected.Fixits.empty()) {
        message = "expected no fix-its";
        replStartLoc = expected.noneMarkerStartLoc;
        replEndLoc = expected.noneMarkerStartLoc;
      } else {
        message = "unexpected fix-it seen";
        replStartLoc = expected.Fixits.front().front().StartLoc;
        replEndLoc = expected.Fixits.back().back().EndLoc;
      }

      auto phrase = makeActualFixitsPhrase(FoundDiagnostic.FixIts);
      std::string actualFixits = phrase.actualFixits;
      message += "; " + phrase.phrase;

      if (replStartLoc == replEndLoc) {
        /// If no fix-its was expected and range of replacement is empty,
        /// insert space after new last marker.
        /// For example:
        ///
        /// @code
        /// expected-error {{message}} {{none}}
        ///                            ^
        ///                    insert `{{1-2=aa}} `
        /// @endcode
        actualFixits += " ";
      }

      emitFixItsError(expected.noneMarkerStartLoc, message, replStartLoc,
                      replEndLoc, actualFixits);
    }

    if (auto expectedDocFile = expected.DocumentationFile) {
      // Verify diagnostic file.
      if (FoundDiagnostic.CategoryDocFile == expectedDocFile->Name)
        expectedDocFile = std::nullopt;

      if (expectedDocFile) {
        if (FoundDiagnostic.CategoryDocFile.empty()) {
          addError(expectedDocFile->StartLoc,
                   "expected documentation file not seen");
        } else {
          // If we had an incorrect expected document file, render it and
          // produce a fixit of our own.
          auto actual =
              renderDocumentationFile(FoundDiagnostic.CategoryDocFile);
          auto replStartLoc = llvm::SMLoc::getFromPointer(expectedDocFile->StartLoc);
          auto replEndLoc = llvm::SMLoc::getFromPointer(expectedDocFile->EndLoc);

          llvm::SMFixIt fix(llvm::SMRange(replStartLoc, replEndLoc), actual);
          addError(expectedDocFile->StartLoc,
                   "expected documentation file not seen; actual documentation "
                   "file: " + actual, fix);
        }
      }
    }

    // Verify each expected diagnostic group name. The diagnostic must belong
    // to every named group; multiple {{group-name=...}} specifiers all have
    // to match.
    for (const auto &expectedGroup : expected.GroupNames) {
      bool matched = llvm::any_of(
          FoundDiagnostic.GroupNames,
          [&](const std::string &name) { return name == expectedGroup.Name; });
      if (matched)
        continue;

      // Filter actual group names to exclude those that match some other
      // expected group name on this expectation, since those have already
      // been accounted for.
      std::vector<StringRef> remainingActual;
      for (const auto &name : FoundDiagnostic.GroupNames) {
        bool isExpected = llvm::any_of(
            expected.GroupNames,
            [&](const ExpectedDiagnosticInfo::ExpectedGroupName &eg) {
              return eg.Name == name;
            });
        if (!isExpected)
          remainingActual.push_back(name);
      }

      if (remainingActual.empty()) {
        addError(expectedGroup.StartLoc, "expected group name not seen");
      } else {
        std::string actual;
        llvm::raw_string_ostream OS(actual);
        llvm::interleave(
            remainingActual,
            [&](StringRef name) { OS << renderGroupName(name); },
            [&] { OS << ' '; });

        auto replStartLoc =
            llvm::SMLoc::getFromPointer(expectedGroup.StartLoc);
        auto replEndLoc = llvm::SMLoc::getFromPointer(expectedGroup.EndLoc);
        llvm::SMFixIt fix(llvm::SMRange(replStartLoc, replEndLoc),
                          renderGroupName(remainingActual.front()));
        addError(expectedGroup.StartLoc,
                 "expected group name not seen; actual group name" +
                     std::string(remainingActual.size() > 1 ? "s" : "") +
                     ": " + OS.str(),
                 fix);
      }
    }

    if (VerifyChildNotes && !expected.ExpectedChildNotes.empty()) {
      verifyDiagnostics(expected.ExpectedChildNotes, BufferID,
                        FoundDiagnostic.ID);
    }

    if (FoundDiagnostic.HasChildren) {
      auto ChildNoteIter = FoundDiagnosticIter + 1;
      while (ChildNoteIter != CapturedDiagnostics.end() &&
             ChildNoteIter->ParentID == FoundDiagnostic.ID) {
        addError(getRawLoc(ChildNoteIter->Loc).getPointer(),
                 ("unexpected child note produced: " +
                  ChildNoteIter->Message).str());
        addNote(expected.ExpectedStart, "for parent matched here");
        ChildNoteIter = CapturedDiagnostics.erase(ChildNoteIter);
      }
    }

    // Actually remove the diagnostic from the list, so we don't match it
    // again. We do have to do this after checking fix-its, though, because
    // the diagnostic owns its fix-its.
    CapturedDiagnostics.erase(FoundDiagnosticIter);
    
    // We found the diagnostic, so remove it... unless we allow an arbitrary
    // number of diagnostics, in which case we want to reprocess this.
    if (expected.mayAppear)
      ++i;
    else if (expected.ExpectedChildNotes.empty())
      ExpectedDiagnostics.erase(ExpectedDiagnostics.begin() + i);
    else
      expected.HasBeenFound = true;
  }
}

void DiagnosticVerifier::verifyRemaining(
    std::vector<ExpectedDiagnosticInfo> &ExpectedDiagnostics,
    const char *FileStart) {
  std::reverse(ExpectedDiagnostics.begin(), ExpectedDiagnostics.end());
  for (auto &expected : ExpectedDiagnostics) {
    if (expected.HasBeenFound) {
      // Only emit errors for unmatched child notes if the parent matched.
      verifyRemaining(expected.ExpectedChildNotes, FileStart);
      continue;
    }
    if (expected.Classification == DiagnosticKindExpansion) {
      verifyRemaining(expected.NestedDiags, FileStart);
      continue;
    }
    std::string message = "expected "+getDiagKindString(expected.Classification)
      + " not produced";

    // Get the range of the expected-foo{{}} diagnostic specifier.
    auto StartLoc = expected.ExpectedStart;
    auto EndLoc = expected.ExpectedEnd;

    // A very common case if for the specifier to be the last thing on the line.
    // In this case, eat any trailing whitespace.
    while (isspace(*EndLoc) && *EndLoc != '\n' && *EndLoc != '\r')
      ++EndLoc;

    // If we found the end of the line, we can do great things.  Otherwise,
    // avoid nuking whitespace that might be zapped through other means.
    if (*EndLoc != '\n' && *EndLoc != '\r') {
      EndLoc = expected.ExpectedEnd;
    } else {
      // If we hit the end of line, then zap whitespace leading up to it.
      while (StartLoc-1 != FileStart && isspace(StartLoc[-1]) &&
             StartLoc[-1] != '\n' && StartLoc[-1] != '\r')
        --StartLoc;

      // If we got to the end of the line, and the thing before this diagnostic
      // is a "//" then we can remove it too.
      if (StartLoc-2 >= FileStart && StartLoc[-1] == '/' && StartLoc[-2] == '/')
        StartLoc -= 2;

      // Perform another round of general whitespace nuking to cleanup
      // whitespace before the //.
      while (StartLoc-1 != FileStart && isspace(StartLoc[-1]) &&
             StartLoc[-1] != '\n' && StartLoc[-1] != '\r')
        --StartLoc;

      // If we found a \n, then we can nuke the entire line.
      if (StartLoc-1 != FileStart &&
          (StartLoc[-1] == '\n' || StartLoc[-1] == '\r'))
        --StartLoc;
    }

    // Remove the expected-foo{{}} as a fixit.
    llvm::SMFixIt fixIt(llvm::SMRange{
      llvm::SMLoc::getFromPointer(StartLoc),
      llvm::SMLoc::getFromPointer(EndLoc)
    }, "");
    addError(expected.ExpectedStart, message, fixIt);
  }
}

void DiagnosticVerifier::addError(const char *Loc, const Twine &message,
                                  ArrayRef<llvm::SMFixIt> FixIts) {
  auto loc = SourceLoc::getFromPointer(Loc);
  Errors.emplace_back(
      SM.GetMessage(loc, llvm::SourceMgr::DK_Error, message, {}, FixIts));
}

void DiagnosticVerifier::addNote(const char *Loc, const Twine &message) {
  ASSERT(!Errors.empty() && "addNote requires a preceding addError");
  auto loc = SourceLoc::getFromPointer(Loc);
  Errors.back().Notes.emplace_back(
      SM.GetMessage(loc, llvm::SourceMgr::DK_Note, message, {}, {}));
}

std::vector<CapturedDiagnosticInfo>::iterator
DiagnosticVerifier::reportAndEraseUnexpected(
    std::vector<CapturedDiagnosticInfo>::iterator DiagIter) {
  addError(getRawLoc(DiagIter->Loc).getPointer(),
           ("unexpected " + getDiagKindString(DiagIter->Classification) +
            " produced: " + DiagIter->Message)
               .str());

  if (VerifyChildNotes) {
    auto ChildIter = DiagIter + 1;
    // All child notes occur immediately after their parent so we only need to
    // look forward in the list for as long as we keep seeing child notes. This
    // also lets us erase the child notes without invalidating DiagIter.
    while (ChildIter != CapturedDiagnostics.end() &&
           ChildIter->ParentID == DiagIter->ID) {
      addNote(getRawLoc(ChildIter->Loc).getPointer(),
              ("with child note: " + ChildIter->Message).str());
      ChildIter = CapturedDiagnostics.erase(ChildIter);
    }
  }

  return CapturedDiagnostics.erase(DiagIter);
}

/// Scan the buffer for location marker definitions of the form "// #name".
/// A marker definition is a comment whose only content is "#name", e.g.:
///   code // #marker1
///   // #marker2
/// The marker name consists of alphanumeric characters, hyphens, or
/// underscores. Nothing else may appear in the comment after the marker name
/// (except trailing whitespace). This prevents false positives from comments
/// like "// #available(...)" or stack traces containing "// #10 0x...".
void DiagnosticVerifier::scanForMarkers(unsigned BufferID) {
  StringRef InputFile = SM.getEntireTextForBuffer(BufferID);
  const SourceLoc BufferStartLoc = SM.getLocForBufferStart(BufferID);

  for (size_t Pos = InputFile.find("//"); Pos != StringRef::npos;
       Pos = InputFile.find("//", Pos + 2)) {
    size_t Cur = Pos + 2;
    while (Cur < InputFile.size() && (InputFile[Cur] == ' ' ||
                                       InputFile[Cur] == '\t'))
      ++Cur;

    if (Cur >= InputFile.size() || InputFile[Cur] != '#')
      continue;

    size_t HashPos = Cur;
    size_t NameStart = HashPos + 1;
    size_t NameEnd = NameStart;
    while (NameEnd < InputFile.size() &&
           (isalnum(InputFile[NameEnd]) || InputFile[NameEnd] == '_' ||
            InputFile[NameEnd] == '-'))
      ++NameEnd;

    if (NameEnd == NameStart)
      continue;

    // Only trailing whitespace is allowed after the marker name until EOL.
    size_t Rest = NameEnd;
    while (Rest < InputFile.size() && (InputFile[Rest] == ' ' ||
                                        InputFile[Rest] == '\t'))
      ++Rest;
    if (Rest < InputFile.size() && InputFile[Rest] != '\n' &&
        InputFile[Rest] != '\r' && InputFile[Rest] != '\0')
      continue;

    StringRef MarkerName = InputFile.slice(NameStart, NameEnd);
    unsigned Line =
        SM.getLineAndColumnInBuffer(
              BufferStartLoc.getAdvancedLoc(HashPos), BufferID)
            .first;

    auto Result =
        LocationMarkers.try_emplace(MarkerName, MarkerLocation{BufferID, Line});
    if (!Result.second) {
      addError(InputFile.data() + HashPos,
               "location marker '#" + MarkerName + "' already defined");
    }
  }
}

bool DiagnosticVerifier::hasMarkerAtLine(unsigned BufferID,
                                         unsigned Line) const {
  for (const auto &Entry : LocationMarkers) {
    if (Entry.second.BufferID == BufferID && Entry.second.Line == Line)
      return true;
  }
  return false;
}

bool DiagnosticVerifier::verifyDeferredMarkerDiagnostics() {
  Errors.clear();
  bool HadError = false;
  auto CapturedDiagIter = CapturedDiagnostics.begin();
  while (CapturedDiagIter != CapturedDiagnostics.end()) {
    if (!CapturedDiagIter->SourceBufferID ||
        !hasMarkerAtLine(*CapturedDiagIter->SourceBufferID,
                         CapturedDiagIter->Line)) {
      ++CapturedDiagIter;
      continue;
    }
    HadError = true;
    CapturedDiagIter = reportAndEraseUnexpected(CapturedDiagIter);
  }
  for (auto &Err : Errors)
    printDiagnostic(Err);
  Errors.clear();
  return HadError;
}

/// After the file has been processed, check to see if we got all of
/// the expected diagnostics and check to see if there were any unexpected
/// ones.
DiagnosticVerifier::Result DiagnosticVerifier::verifyFile(unsigned BufferID) {
  Errors.clear();
  using llvm::SMLoc;

  StringRef InputFile = SM.getEntireTextForBuffer(BufferID);

  // Queue up all of the diagnostics, allowing us to sort them and emit them in
  // file order.

  unsigned PrevExpectedContinuationLine = 0;

  std::vector<ExpectedDiagnosticInfo> ExpectedDiagnostics;

  // Validate that earlier prefixes are not prefixes of alter
  // prefixes... otherwise, we will never pattern match the later prefix.
  validatePrefixList(AdditionalExpectedPrefixes);

  const char *PrevMatchEnd = InputFile.data();
  // Scan the memory buffer looking for expected-note/warning/error.
  for (size_t Match = InputFile.find("expected-");
       Match != StringRef::npos; Match = InputFile.find("expected-", Match+1)) {
    // Process this potential match.  If we fail to process it, just move on to
    // the next match.
    StringRef MatchStart = InputFile.substr(Match);
    if (MatchStart.data() < PrevMatchEnd)
      continue;
    ExpectedDiagnosticInfo Expected(nullptr, nullptr, nullptr, DiagnosticKind(-1));
    unsigned Count = parseExpectedDiagInfo(BufferID, MatchStart, PrevExpectedContinuationLine, Expected);
    if (Count < 1)
      continue;

    // Add the diagnostic the expected number of times.
    for (; Count; --Count)
      ExpectedDiagnostics.push_back(Expected);
    PrevMatchEnd = Expected.ExpectedEnd;
  }

  verifyDiagnostics(ExpectedDiagnostics, BufferID,
                    /*ParentDiagnostic=*/std::nullopt);

  // Check to see if we have any incorrect diagnostics.  If so, diagnose them as
  // such.
  auto expectedDiagIter = ExpectedDiagnostics.begin();
  while (expectedDiagIter != ExpectedDiagnostics.end()) {
    if (expectedDiagIter->HasBeenFound) {
      // FIXME: extract this "near miss" pass and recurse
      // over child notes and expansion contents
      ++expectedDiagIter;
      continue;
    }
    // Check to see if any found diagnostics have the right line and
    // classification, but the wrong text.
    auto I = CapturedDiagnostics.begin();
    for (auto E = CapturedDiagnostics.end(); I != E; ++I) {
      // Verify the file and line of the diagnostic.
      if (I->Line != expectedDiagIter->LineNo || I->SourceBufferID != BufferID
            || I->Classification != expectedDiagIter->Classification)
        continue;

      // Otherwise, we found it, break out.
      break;
    }

    if (I == CapturedDiagnostics.end()) {
      ++expectedDiagIter;
      continue;
    }

    if (I->Message.find(expectedDiagIter->MessageStr) == StringRef::npos) {
      auto StartLoc =
          SMLoc::getFromPointer(expectedDiagIter->MessageRange.begin());
      auto EndLoc = SMLoc::getFromPointer(expectedDiagIter->MessageRange.end());

      llvm::SMFixIt fixIt(llvm::SMRange{StartLoc, EndLoc}, I->Message);
      addError(expectedDiagIter->MessageRange.begin(),
               "incorrect message found", fixIt);
    } else if (I->Column != *expectedDiagIter->ColumnNo) {
      // The difference must be only in the column
      addError(expectedDiagIter->MessageRange.begin(),
               llvm::formatv("message found at column {0} but was expected to "
                             "appear at column {1}",
                             I->Column, *expectedDiagIter->ColumnNo));
    } else {
      llvm_unreachable("unhandled difference from expected diagnostic");
    }
    CapturedDiagnostics.erase(I);
    expectedDiagIter = ExpectedDiagnostics.erase(expectedDiagIter);
  }

  // Diagnose expected diagnostics that didn't appear.
  verifyRemaining(ExpectedDiagnostics, InputFile.data());
  
  // Verify that there are no diagnostics (in MemoryBuffer) left in the list.
  bool HadUnexpectedDiag = false;
  auto CapturedDiagIter = CapturedDiagnostics.begin();
  while (CapturedDiagIter != CapturedDiagnostics.end()) {
    if (CapturedDiagIter->SourceBufferID != BufferID) {
      if (!CapturedDiagIter->SourceBufferID) {
        ++CapturedDiagIter;
        continue;
      }

      // Diagnostics attached to generated sources originating in this
      // buffer also count as part of this buffer for this purpose.
      unsigned scratch;
      llvm::ArrayRef<unsigned> ancestors = SM.getAncestors(CapturedDiagIter->SourceBufferID.value(), scratch);
      if (llvm::find(ancestors, BufferID) == ancestors.end()) {
        ++CapturedDiagIter;
        continue;
      }
    }

    // Defer reporting unexpected diagnostics on lines with location markers,
    // because another file may have an expected-error@#marker for this line.
    if (hasMarkerAtLine(BufferID, CapturedDiagIter->Line)) {
      ++CapturedDiagIter;
      continue;
    }

    HadUnexpectedDiag = true;
    CapturedDiagIter = reportAndEraseUnexpected(CapturedDiagIter);
  }

  // Sort the diagnostics with buffer ID as the primary key and address within
  // the buffer as the secondary key. This ensures that an "unexpected
  // diagnostic" and "expected diagnostic" in the same place are emitted next
  // to each other, and that the order is stable across source files.
  std::sort(Errors.begin(), Errors.end(),
            [&](const SMDiagnosticWithNotes &lhs,
                const SMDiagnosticWithNotes &rhs) -> bool {
              auto lhsLoc = SourceLoc::getFromPointer(lhs.Diag.getLoc().getPointer());
              auto rhsLoc = SourceLoc::getFromPointer(rhs.Diag.getLoc().getPointer());
              unsigned lhsBuf = SM.findBufferContainingLoc(lhsLoc);
              unsigned rhsBuf = SM.findBufferContainingLoc(rhsLoc);
              if (lhsBuf != rhsBuf)
                return lhsBuf < rhsBuf;
              return lhs.Diag.getLoc().getPointer() <
                     rhs.Diag.getLoc().getPointer();
            });

  // Emit all of the queue'd up errors.
  for (const auto &Err : Errors)
    printDiagnostic(Err);

  // If auto-apply fixits is on, rewrite the original source file.
  if (AutoApplyFixes)
    autoApplyFixes(SM, BufferID, Errors);

  return Result{!Errors.empty(), HadUnexpectedDiag};
}

void DiagnosticVerifier::printRemainingDiagnostics() const {
  for (const auto &diag : CapturedDiagnostics) {
    // Determine what kind of diagnostic we're emitting.
    llvm::SourceMgr::DiagKind SMKind;
    switch (diag.Classification) {
    case DiagnosticKind::Error:
      SMKind = llvm::SourceMgr::DK_Error;
      break;
    case DiagnosticKind::Warning:
      SMKind = llvm::SourceMgr::DK_Warning;
      break;

    case DiagnosticKind::Note:
      SMKind = llvm::SourceMgr::DK_Note;
      break;

    case DiagnosticKind::Remark:
      SMKind = llvm::SourceMgr::DK_Remark;
      break;
    }

    auto message =
        SM.GetMessage(diag.Loc, SMKind,
                      "diagnostic produced elsewhere: " + diag.Message.str(),
                      /*Ranges=*/{}, {});
    printDiagnostic(message);
  }
}

static void
processExpansions(SourceManager &SM, llvm::DenseMap<SourceLoc, unsigned> &Expansions,
                  std::vector<CapturedDiagnosticInfo> &CapturedDiagnostics) {
  for (auto &diag : CapturedDiagnostics) {
    if (!diag.SourceBufferID.has_value())
      continue;
    const GeneratedSourceInfo *GSI =
        SM.getGeneratedSourceInfo(diag.SourceBufferID.value());
    if (!GSI)
      continue;
    SourceLoc ExpansionStart = GSI->originalSourceRange.getStart();
    if (ExpansionStart.isInvalid())
      continue;
    if (Expansions.count(ExpansionStart)) {
      ASSERT(Expansions[ExpansionStart] == diag.SourceBufferID.value() &&
             "diagnostics in multiple expansions for the same decl not "
             "supported by -verify");
      continue;
    }
    Expansions.insert(std::make_pair(ExpansionStart, diag.SourceBufferID.value()));
  }
}

static void createDiagnosticInfo(const DiagnosticInfo &Info,
                                 SourceManager &DiagSM,
                                 SourceManager &VerifierSM,
                                 bool VerifyChildNotes,
                                 std::optional<size_t> ParentID,
                                 std::vector<CapturedDiagnosticInfo> &Out) {
  ASSERT(!Info.IsChildNote ||
         Info.ChildDiagnosticInfo.empty() && "child note of child note??");
  SmallVector<CapturedFixItInfo, 2> fixIts;
  for (const auto &fixIt : Info.FixIts) {
    fixIts.emplace_back(DiagSM, fixIt);
  }

  llvm::SmallString<128> message;
  {
    llvm::raw_svector_ostream Out(message);
    DiagnosticEngine::formatDiagnosticText(Out, Info.FormatString,
                                           Info.FormatArgs);
  }

  std::vector<std::string> groupNames;
  groupNames.reserve(Info.CategoryChain.size());
  for (const auto &category : Info.CategoryChain)
    groupNames.emplace_back(category.Name.str());

  DiagLoc loc(DiagSM, VerifierSM, Info.Loc);
  const size_t Idx = Out.size();
  Out.emplace_back(
      message, loc.bufferID, Info.Kind, loc.sourceLoc, loc.line, loc.column,
      fixIts, llvm::sys::path::stem(Info.getCategoryDocumentationURL()).str(),
      std::move(groupNames), Idx, ParentID,
      VerifyChildNotes && !Info.ChildDiagnosticInfo.empty());

  if (VerifyChildNotes) {
    for (const DiagnosticInfo *ChildInfo : Info.ChildDiagnosticInfo)
      createDiagnosticInfo(*ChildInfo, DiagSM, VerifierSM, VerifyChildNotes,
                           Idx, Out);
  }
}

//===----------------------------------------------------------------------===//
// Main entrypoints
//===----------------------------------------------------------------------===//

/// Every time a diagnostic is generated in -verify mode, this function is
/// called with the diagnostic.  We just buffer them up until the end of the
/// file.
void DiagnosticVerifier::handleDiagnostic(SourceManager &SM,
                                          const DiagnosticInfo &Info) {
  // Ignore "fatal error encountered while in -verify mode" errors,
  // because there's no reason to verify them.
  if (Info.ID == diag::verify_encountered_fatal.ID)
    return;
  if (IgnoreMacroLocationNote && Info.ID == diag::in_macro_expansion.ID)
    return;
  if (VerifyChildNotes && Info.IsChildNote)
    // Already added with parent diagnostic
    return;

  createDiagnosticInfo(Info, SM, this->SM, VerifyChildNotes, std::nullopt,
                       CapturedDiagnostics);
}

/// Once all diagnostics have been captured, perform verification.
bool DiagnosticVerifier::finishProcessing() {
  DiagnosticVerifier::Result Result = {false, false};

  SmallVector<unsigned, 4> additionalBufferIDs;
  for (auto path : AdditionalFilePaths) {
    auto bufferID = SM.getIDForBufferIdentifier(path);
    if (!bufferID) {
      // Still need to scan this file for expectations.
      auto result = SM.getFileSystem()->getBufferForFile(path);
      if (!result) {
        auto message = SM.GetMessage(
           SourceLoc(), llvm::SourceMgr::DiagKind::DK_Error,
           llvm::Twine("unable to open file in '-verify-additional-file ") +
           path + "': " + result.getError().message(), {}, {});
        printDiagnostic(message);
        Result.HadError |= true;
        continue;
      }
      bufferID = SM.addNewSourceBuffer(std::move(result.get()));
    }
    if (bufferID) {
      additionalBufferIDs.push_back(*bufferID);
    }
  }

  processExpansions(SM, Expansions, CapturedDiagnostics);

  // Scan all buffers for location marker definitions before verifying, so
  // that markers defined in one file can be referenced from another.
  ArrayRef<unsigned> BufferIDLists[2] = { BufferIDs, additionalBufferIDs };
  for (ArrayRef<unsigned> BufferIDList : BufferIDLists)
    for (auto &BufferID : BufferIDList)
      scanForMarkers(BufferID);

  // Emit any errors from marker scanning (e.g. duplicate marker definitions)
  // before verifyFile() clears the Errors vector.
  for (auto &Err : Errors)
    printDiagnostic(Err);
  if (!Errors.empty())
    Result.HadError = true;
  Errors.clear();

  for (ArrayRef<unsigned> BufferIDList : BufferIDLists)
    for (auto &BufferID : BufferIDList) {
      DiagnosticVerifier::Result FileResult = verifyFile(BufferID);
      Result.HadError |= FileResult.HadError;
      Result.HadUnexpectedDiag |= FileResult.HadUnexpectedDiag;
    }

  // Now that all files have been verified, check for any remaining diagnostics
  // on lines with markers that were deferred during per-file verification.
  if (verifyDeferredMarkerDiagnostics()) {
    Result.HadError = true;
    Result.HadUnexpectedDiag = true;
  }

  if (!IgnoreUnknown) {
    bool HadError = verifyUnknown(CapturedDiagnostics);
    Result.HadError |= HadError;
    // For <unknown>, all errors are unexpected.
    Result.HadUnexpectedDiag |= HadError;
  }
  if (!IgnoreUnrelated) {
    bool HadError = verifyUnrelated(CapturedDiagnostics);
    Result.HadError |= HadError;
    Result.HadUnexpectedDiag |= HadError;
  }

  if (Result.HadUnexpectedDiag)
    printRemainingDiagnostics();

  return Result.HadError;
}