[clangd] Diagfixer for layering violations

[kadircet]

Summary

Introduce a diagfixer that can update build system files in the face of
layering violation warnings.

clang-tools-extra/clangd/Diagnostics.h

 //===--- Diagnostics.h -------------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_DIAGNOSTICS_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_DIAGNOSTICS_H
 
+#include "BuildSystem.h"
 #include "Protocol.h"
 #include "support/Path.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/None.h"

 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const DiagBase &D);
 
 /// Represents a single fix-it that editor can apply to fix the error.
 struct Fix {
   /// Message for the fix-it.
   std::string Message;
   /// TextEdits from clang's fix-its. Must be non-empty.
   llvm::SmallVector<TextEdit, 1> Edits;
+  llvm::Optional<Command> Cmd;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Fix &F);
 
 /// Represents a note for the diagnostic. Severity of notes can only be 'note'
 /// or 'remark'.
 struct Note : DiagBase {};
 
 /// A top-level diagnostic that may have Notes and Fixes.

 bool isBuiltinDiagnosticSuppressed(unsigned ID,
                                    const llvm::StringSet<> &Suppressed);
 /// Take a user-specified diagnostic code, and convert it to a normalized form
 /// stored in the config and consumed by isBuiltinDiagnosticsSuppressed.
 ///
 /// (This strips err_ and -W prefix so we can match with or without them.)
 llvm::StringRef normalizeSuppressedCode(llvm::StringRef);
 
+StoreDiags::DiagFixer missingDependencyFixer(const BuildSystem *BS);
+
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_DIAGNOSTICS_H

clang-tools-extra/clangd/Diagnostics.cpp

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Capacity.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstddef>
 
 namespace clang {
for (auto &Fix : D.Fixes) {
       OS << Sep << Fix;
       Sep = ", ";
     }
   }
   return OS;
 }
 
 CodeAction toCodeAction(const Fix &F, const URIForFile &File) {
+  assert(!F.Edits.empty() || F.Cmd.hasValue());
   CodeAction Action;
   Action.title = F.Message;
   Action.kind = std::string(CodeAction::QUICKFIX_KIND);
+  if (!F.Edits.empty()) {
     Action.edit.emplace();
     Action.edit->changes.emplace();
     (*Action.edit->changes)[File.uri()] = {F.Edits.begin(), F.Edits.end()};
+  }
+  if (F.Cmd)
+    Action.command = *F.Cmd;
   return Action;
 }
 
 Diag toDiag(const llvm::SMDiagnostic &D, Diag::DiagSource Source) {
   Diag Result;
   Result.Message = D.getMessage().str();
   switch (D.getKind()) {
   case llvm::SourceMgr::DK_Error:

 }
 
 llvm::StringRef normalizeSuppressedCode(llvm::StringRef Code) {
   Code.consume_front("err_");
   Code.consume_front("-W");
   return Code;
 }
 
+StoreDiags::DiagFixer missingDependencyFixer(const BuildSystem *BS) {
+  return [BS](DiagnosticsEngine::Level,
+              const clang::Diagnostic &D) -> std::vector<Fix> {
+    if (D.getID() != clang::diag::err_undeclared_use_of_module)
+      return {};
+    clang::clangd::trace::Span Span("DiagFixerDependencyInserter");
+    auto FromModule = D.getArgStdStr(0);
+    auto ToModule = BS->getOwningTarget(D.getArgStdStr(1));
+    if (!ToModule) {
+      clang::clangd::elog("Couldn't find owning module for {0}: {1}",
+                          D.getArgStdStr(1), ToModule.takeError());
+      return {};
+    }
+    // Rather than generating the edit here, we can defer that to diagnostic
+    // resolve time (at the cost of false positives, when BUILD file can't be
+    // edited).
+    auto Edit = BS->addDependency(FromModule, ToModule->front());
+    if (!Edit) {
+      clang::clangd::elog("Couldn't insert dep from {0} to {1}: {2}",
+                          FromModule, ToModule->front(), Edit.takeError());
+      return {};
+    }
+    Fix F;
+    F.Cmd.emplace();
+    F.Cmd->title =
+        llvm::formatv("Add deps {0} to {1}", ToModule->front(), FromModule);
+    F.Cmd->workspaceEdit = std::move(*Edit);
+    F.Cmd->command = Command::CLANGD_APPLY_FIX_COMMAND.str();
+    F.Message = F.Cmd->title;
+    return {std::move(F)};
+  };
+}
 } // namespace clangd
 } // namespace clang