build: implement clang-tidy using our plugin

The principle of this is that you can either externally build it with
Nix (actual implementation will be in a future commit), or it can be
built with meson if the Nix one is not passed in.

The idea I have is that dev shells don't receive the one from Nix to
avoid having to build it, but CI can use the one from Nix and save some
gratuitous rebuilds.

The design of this is that you can run `ninja -C build clang-tidy` and
it will simply correctly clang-tidy the codebase in spite of PCH
bullshit caused by the cc-wrapper.

This is a truly horrendous number of hacks in a ball, caused by bugs in
several pieces of software, and I am not even getting started.

I don't consider this to fix the clang-tidy issue filing, since we still
have a fair number of issues to fix even on the existing minimal
configuration, and I have not yet implemented it in CI. Realistically we
will need to do something like https://github.com/Ericsson/codechecker
to be able to silence warnings without physically touching the code, or
at least *diff* reports between versions.

Also, the run-clang-tidy output design is rather atrocious and must
not be inflicted upon anyone I have respect for, since it buries the
diagnostics in a pile of invocation logs. We would do really well to
integrate with the Gerrit SARIF stuff so we can dump the reports on
people in a user-friendly manner.

Related: https://git.lix.systems/lix-project/lix/issues/147

Change-Id: Ifefe533f3b56874795de231667046b2da6ff2461

1 files changed, 90 insertions, 0 deletions

diff --git a/subprojects/lix-clang-tidy/FixIncludes.cc b/subprojects/lix-clang-tidy/FixIncludes.cc
new file mode 100644
index 000000000..602d3d355
--- /dev/null
+++ b/subprojects/lix-clang-tidy/FixIncludes.cc
@@ -0,0 +1,90 @@
+#include "FixIncludes.hh"
+#include <clang-tidy/ClangTidyCheck.h>
+#include <clang/Basic/Diagnostic.h>
+#include <clang/Basic/SourceManager.h>
+#include <clang/Lex/PPCallbacks.h>
+#include <clang/Lex/Preprocessor.h>
+#include <llvm/ADT/StringRef.h>
+#include <llvm/Support/Debug.h>
+#include <memory>
+#include <set>
+#include <string>
+
+namespace nix::clang_tidy {
+
+using namespace clang;
+using namespace clang::tidy;
+
+class FixIncludesCallbacks : public PPCallbacks {
+public:
+  ClangTidyCheck &Check;
+  Preprocessor &PP;
+  FixIncludesCallbacks(ClangTidyCheck &Check, Preprocessor &PP)
+      : Check(Check), PP(PP) {}
+
+private:
+  bool Ignore = false;
+  virtual void LexedFileChanged(FileID FID, LexedFileChangeReason Reason,
+                                SrcMgr::CharacteristicKind FileType,
+                                FileID PrevFID, SourceLocation Loc) override;
+
+  virtual void InclusionDirective(SourceLocation HashLoc,
+                                  const Token &IncludeTok, StringRef FileName,
+                                  bool IsAngled, CharSourceRange FilenameRange,
+                                  OptionalFileEntryRef File,
+                                  StringRef SearchPath, StringRef RelativePath,
+                                  const Module *Imported,
+                                  SrcMgr::CharacteristicKind FileType) override;
+};
+
+void FixIncludesCallbacks::LexedFileChanged(FileID, LexedFileChangeReason,
+                                            SrcMgr::CharacteristicKind FileType,
+                                            FileID, SourceLocation) {
+  Ignore = FileType != SrcMgr::C_User;
+}
+
+void FixIncludesCallbacks::InclusionDirective(
+    SourceLocation, const Token &, StringRef FileName, bool IsAngled,
+    CharSourceRange FilenameRange, OptionalFileEntryRef File, StringRef,
+    StringRef, const Module *, SrcMgr::CharacteristicKind) {
+  if (Ignore)
+    return;
+
+  // FIXME: this is kinda evil, but this is a one-time fixup
+  const std::vector<std::string> SourceDirs = {"src/", "include/lix/"};
+
+  const auto Bracketize = [IsAngled](StringRef s) {
+    return IsAngled ? ("<" + s + ">").str() : ("\"" + s + "\"").str();
+  };
+
+  for (const auto &SourceDir : SourceDirs) {
+    const bool IsAlreadyFixed = FileName.starts_with("lix/lib");
+    if (File && File->getNameAsRequested().contains(SourceDir) &&
+        !IsAlreadyFixed) {
+      StringRef Name = File->getNameAsRequested();
+      auto Idx = Name.find(SourceDir);
+      assert(Idx != std::string::npos);
+      std::string Suffix = Name.drop_front(Idx + SourceDir.length()).str();
+
+      if (!Suffix.starts_with("lib")) {
+        llvm::dbgs() << "ignored: " << Suffix << "\n";
+        return;
+      }
+
+      Suffix = "lix/" + Suffix;
+
+      auto Diag = Check.diag(FilenameRange.getBegin(),
+                             "include needs to specify the source subdir");
+
+      Diag << FilenameRange
+           << FixItHint::CreateReplacement(FilenameRange, Bracketize(Suffix));
+    }
+  }
+}
+
+void FixIncludesCheck::registerPPCallbacks(const SourceManager &,
+                                           Preprocessor *PP, Preprocessor *) {
+  PP->addPPCallbacks(std::make_unique<FixIncludesCallbacks>(*this, *PP));
+}
+
+}; // namespace nix::clang_tidy