fix(parser): Validate the reported diagnostic messages

When `cxx-frontend` is invoked with the option `-verify` the reported
diagnostic messages are validated against the expected diagnostics
defined using comment-directives matchig the following regex:

```
  //\s*expected-(error|warning)(@[+-]?\d+)?\s*{{.+}}
```

Implements #38

Author: robertoraggi

src/cxx/preprocessor.cc

@@ -1731,4 +1731,11 @@ std::string_view Preprocessor::getTextLine(const Token &token) const {
   return textLine;
 }
 
+std::string_view Preprocessor::getTokenText(const Token &token) const {
+  if (token.fileId() == 0) return std::string_view();
+  const SourceFile *file = d->sourceFiles_[token.fileId() - 1].get();
+  std::string_view source = file->source;
+  return source.substr(token.offset(), token.length());
+}
+
 }  // namespace cxx

src/cxx/preprocessor.h

@@ -86,6 +86,8 @@ class Preprocessor {
 
   std::string_view getTextLine(const Token &token) const;
 
+  std::string_view getTokenText(const Token &token) const;
+
   void squeeze();
 
  private:

src/frontend/cli.cc

@@ -145,6 +145,8 @@ std::vector<CLIOptionDescr> options{
      "Set the toolchain to 'linux', 'darwin' or 'windows'",
      CLIOptionDescrKind::kSeparated},
 
+    {"-verify", "Verify the diagnostic messages", &CLI::opt_verify},
+
     {"-v", "Show commands to run and use verbose output", &CLI::opt_v},
 
 };

src/frontend/cli.h

@@ -61,6 +61,7 @@ class CLI {
   bool opt_nostdincpp = false;
   bool opt_S = false;
   bool opt_c = false;
+  bool opt_verify = false;
   bool opt_v = false;
 
   bool checkTypes() const { return opt_ir_dump || opt_S || opt_c; }

src/frontend/frontend.cc

@@ -44,13 +44,109 @@
 #include <fstream>
 #include <iomanip>
 #include <iostream>
+#include <list>
+#include <regex>
 #include <sstream>
 #include <string>
 
 #include "cli.h"
 
 namespace cxx {
 
+struct ExpectedDiagnostic {
+  Severity severity = Severity::Error;
+  std::string_view fileName;
+  unsigned line = 0;
+  std::string message;
+};
+
+struct VerifyCommentHandler : CommentHandler {
+  std::regex rx{
+      "^//\\s*expected-(error|warning)(?:@([+-]?\\d+))?\\s*\\{\\{(.+)\\}\\}"};
+  std::list<ExpectedDiagnostic> expectedDiagnostics;
+
+  void handleComment(Preprocessor* preprocessor, const Token& token) override {
+    const std::string text{preprocessor->getTokenText(token)};
+
+    std::smatch match;
+
+    if (std::regex_match(text, match, rx)) {
+      std::string_view fileName;
+      unsigned line = 0;
+      unsigned column = 0;
+
+      preprocessor->getTokenStartPosition(token, &line, &column, &fileName);
+
+      Severity severity = Severity::Error;
+
+      if (match[1] == "warning") severity = Severity::Warning;
+
+      std::string offset = match[2];
+
+      if (!offset.empty()) line += std::stoi(offset);
+
+      const auto& message = match[3];
+
+      expectedDiagnostics.push_back({severity, fileName, line, message});
+    }
+  }
+};
+
+struct VerifyDiagnostics : DiagnosticsClient {
+  std::list<Diagnostic> reportedDiagnostics;
+  bool verify = false;
+
+  void report(const Diagnostic& diagnostic) override {
+    if (!verify) {
+      DiagnosticsClient::report(diagnostic);
+      return;
+    }
+
+    reportedDiagnostics.push_back(diagnostic);
+  }
+
+  void verifyExpectedDiagnostics(
+      const std::list<ExpectedDiagnostic>& expectedDiagnostics) {
+    if (!verify) return;
+
+    for (const auto& expected : expectedDiagnostics) {
+      if (auto it = findDiagnostic(expected); it != cend(reportedDiagnostics)) {
+        reportedDiagnostics.erase(it);
+      }
+    }
+
+    for (const auto& diag : reportedDiagnostics) {
+      DiagnosticsClient::report(diag);
+    }
+  }
+
+ private:
+  std::list<Diagnostic>::const_iterator findDiagnostic(
+      const ExpectedDiagnostic& expected) const {
+    return std::find_if(reportedDiagnostics.begin(), reportedDiagnostics.end(),
+                        [&](const Diagnostic& d) {
+                          if (d.severity() != expected.severity) {
+                            return false;
+                          }
+
+                          unsigned line = 0;
+                          unsigned column = 0;
+                          std::string_view fileName;
+
+                          preprocessor()->getTokenStartPosition(
+                              d.token(), &line, &column, &fileName);
+
+                          if (line != expected.line) return false;
+
+                          if (fileName != expected.fileName) return false;
+
+                          if (d.message() != expected.message) return false;
+
+                          return true;
+                        });
+  }
+};
+
 std::string readAll(const std::string& fileName, std::istream& in) {
   std::string code;
   char buffer[4 * 1024];
@@ -95,13 +191,21 @@ void dumpTokens(const CLI& cli, TranslationUnit& unit, std::ostream& output) {
 
 bool runOnFile(const CLI& cli, const std::string& fileName) {
   Control control;
-  DiagnosticsClient diagnosticsClient;
+  VerifyDiagnostics diagnosticsClient;
   TranslationUnit unit(&control, &diagnosticsClient);
 
   auto preprocesor = unit.preprocessor();
 
   std::unique_ptr<Toolchain> toolchain;
 
+  VerifyCommentHandler verifyCommentHandler;
+
+  diagnosticsClient.verify = cli.opt_verify;
+
+  if (cli.opt_verify) {
+    preprocesor->setCommentHandler(&verifyCommentHandler);
+  }
+
   auto toolchainId = cli.getSingle("-toolchain");
 
   if (!toolchainId) {
@@ -176,24 +280,29 @@ bool runOnFile(const CLI& cli, const std::string& fileName) {
 
   auto& output = outfile ? *outfile : std::cout;
 
+  bool shouldExit = false;
+
   if (cli.opt_E && !cli.opt_dM) {
     preprocesor->preprocess(readAll(fileName), fileName, output);
-    return true;
-  }
-
-  unit.setSource(readAll(fileName), fileName);
-
-  if (cli.opt_dM) {
-    preprocesor->printMacros(output);
-    return true;
+    shouldExit = true;
+  } else {
+    unit.setSource(readAll(fileName), fileName);
+
+    if (cli.opt_dM) {
+      preprocesor->printMacros(output);
+      shouldExit = true;
+    } else if (cli.opt_dump_tokens) {
+      dumpTokens(cli, unit, output);
+      shouldExit = true;
+    } else if (cli.opt_Eonly) {
+      shouldExit = true;
+    }
   }
 
-  if (cli.opt_dump_tokens) {
-    dumpTokens(cli, unit, output);
-    return true;
-  }
+  if (shouldExit) {
+    diagnosticsClient.verifyExpectedDiagnostics(
+        verifyCommentHandler.expectedDiagnostics);
 
-  if (cli.opt_Eonly) {
     return true;
   }
 
@@ -204,10 +313,7 @@ bool runOnFile(const CLI& cli, const std::string& fileName) {
   if (cli.opt_ast_dump) {
     ASTPrinter print(&unit);
     output << print(unit.ast(), /*print locations*/ true);
-    return result;
-  }
-
-  if (cli.opt_S || cli.opt_ir_dump || cli.opt_c) {
+  } else if (cli.opt_S || cli.opt_ir_dump || cli.opt_c) {
     Codegen cg;
 
     auto module = cg(&unit);
@@ -221,6 +327,9 @@ bool runOnFile(const CLI& cli, const std::string& fileName) {
     }
   }
 
+  diagnosticsClient.verifyExpectedDiagnostics(
+      verifyCommentHandler.expectedDiagnostics);
+
   return result;
 }