[clangd] Support Config in TestTU.

[hokein]

Summary

Add a config as a filed in TestTU, for each TestTU::build, we set the
config. And make the Config copyable.

This is needed for enabling the unused-include feature by default.

[hokein]

abandon this in favour of https://reviews.llvm.org/D152685/

clang-tools-extra/clangd/Config.h

 // vocabulary types where possible.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIG_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CONFIG_H
 
 #include "support/Context.h"
-#include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include <functional>
 #include <optional>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace clangd {
 
 /// Settings that express user/project preferences and control clangd behavior.
 ///
 /// Generally, features should consume Config::current() and the caller is
 /// responsible for setting it appropriately. In practice these callers are
 /// ClangdServer, TUScheduler, and BackgroundQueue.
 struct Config {
   /// Returns the Config of the current Context, or an empty configuration.
   static const Config &current();
   /// Context key which can be used to set the current Config.
   static clangd::Key<Config> Key;
 
   Config() = default;
-  Config(const Config &) = delete;
-  Config &operator=(const Config &) = delete;
+  Config(const Config &) = default;
+  Config &operator=(const Config &) = default;
   Config(Config &&) = default;
   Config &operator=(Config &&) = default;
 
   struct CDBSearchSpec {
     enum { Ancestors, FixedDir, NoCDBSearch } Policy = Ancestors;
     // Absolute, native slashes, no trailing slash.
     std::optional<std::string> FixedCDBPath;
   };
 
   /// Controls how the compile command for the current file is determined.
   struct {
     /// Edits to apply to the compile command, in sequence.
-    std::vector<llvm::unique_function<void(std::vector<std::string> &) const>>
-        Edits;
+    std::vector<std::function<void(std::vector<std::string> &)>> Edits;
     /// Where to search for compilation databases for this file's flags.
     CDBSearchSpec CDBSearch = {CDBSearchSpec::Ancestors, std::nullopt};
   } CompileFlags;
 
   enum class BackgroundPolicy { Build, Skip };
   /// Describes an external index configuration.
   struct ExternalIndexSpec {
     enum { None, File, Server } Kind = None;

clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp

Annotations Main(R"cpp(
     }
   )cpp");
   auto TU = TestTU::withCode(Main.code());
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(Diag(Main.range(), "use of undeclared identifier 'unknown'"),
                   Diag(Main.range("ret"),
                        "void function 'x' should not return a value")));
-  Config Cfg;
-  Cfg.Diagnostics.Suppress.insert("return-type");
-  WithContextValue WithCfg(Config::Key, std::move(Cfg));
+
+  TU.Cfg.Diagnostics.Suppress.insert("return-type");
   EXPECT_THAT(*TU.build().getDiagnostics(),
               ElementsAre(Diag(Main.range(),
                                "use of undeclared identifier 'unknown'")));
 }
 
 TEST(DiagnosticTest, RespectsDiagnosticConfigInHeader) {
   Annotations Header(R"cpp(
     int x = "42";  // error-ok
   )cpp");
   Annotations Main(R"cpp(
     #include "header.hpp"
   )cpp");
   auto TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles["header.hpp"] = std::string(Header.code());
-  Config Cfg;
-  Cfg.Diagnostics.Suppress.insert("init_conversion_failed");
-  WithContextValue WithCfg(Config::Key, std::move(Cfg));
+  TU.Cfg.Diagnostics.Suppress.insert("init_conversion_failed");
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
 TEST(DiagnosticTest, ClangTidySuppressionComment) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double d = 8 / i;  // NOLINT
]]
   TU.AdditionalFiles["ignore.h"] = R"cpp(
     #pragma once
     void ignore() {}
   )cpp";
   TU.AdditionalFiles["system/system_header.h"] = "";
   TU.ExtraArgs = {"-isystem" + testPath("system")};
   // Off by default.
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
-  Config Cfg;
-  Cfg.Diagnostics.UnusedIncludes = Config::IncludesPolicy::Strict;
+  TU.Cfg.Diagnostics.UnusedIncludes = Config::IncludesPolicy::Strict;
   // Set filtering.
-  Cfg.Diagnostics.Includes.IgnoreHeader.emplace_back(
+  TU.Cfg.Diagnostics.Includes.IgnoreHeader.emplace_back(
       [](llvm::StringRef Header) { return Header.endswith("ignore.h"); });
-  WithContextValue WithCfg(Config::Key, std::move(Cfg));
   auto AST = TU.build();
   EXPECT_THAT(
       *AST.getDiagnostics(),
       UnorderedElementsAre(AllOf(
           Diag(Test.range("diag"),
                "included header unused.h is not used directly"),
           withTag(DiagnosticTag::Unnecessary), diagSource(Diag::Clangd),
           withFix(Fix(Test.range("fix"), "", "remove #include directive")))));
   auto &Diag = AST.getDiagnostics()->front();
   EXPECT_EQ(getDiagnosticDocURI(Diag.Source, Diag.ID, Diag.Name),
             std::string("https://clangd.llvm.org/guides/include-cleaner"));
-  Cfg.Diagnostics.SuppressAll = true;
-  WithContextValue SuppressAllWithCfg(Config::Key, std::move(Cfg));
+  TU.Cfg.Diagnostics.SuppressAll = true;
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
-  Cfg.Diagnostics.SuppressAll = false;
-  Cfg.Diagnostics.Suppress = {"unused-includes"};
-  WithContextValue SuppressFilterWithCfg(Config::Key, std::move(Cfg));
+  TU.Cfg.Diagnostics.SuppressAll = false;
+  TU.Cfg.Diagnostics.Suppress = {"unused-includes"};
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 }
 
 TEST(DiagnosticsTest, FixItFromHeader) {
   llvm::StringLiteral Header(R"cpp(
     void foo(int *);
     void foo(int *, int);)cpp");
   Annotations Source(R"cpp(

clang-tools-extra/clangd/unittests/TestTU.h

 //
 //===---------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTTU_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_UNITTESTS_TESTTU_H
 
 #include "../TidyProvider.h"
 #include "Compiler.h"
+#include "Config.h"
 #include "FeatureModule.h"
 #include "ParsedAST.h"
 #include "TestFS.h"
 #include "index/Index.h"
 #include "llvm/ADT/StringMap.h"
 #include <memory>
 #include <string>
 #include <utility>
struct TestTU {
   }
 
   static TestTU withHeaderCode(llvm::StringRef HeaderCode) {
     TestTU TU;
     TU.HeaderCode = std::string(HeaderCode);
     return TU;
   }
 
+  TestTU();
+
   // The code to be compiled.
   std::string Code;
   std::string Filename = "TestTU.cpp";
 
   // Define contents of a header which will be implicitly included by Code.
   std::string HeaderCode;
   std::string HeaderFilename = "TestTU.h";
 
   // Name and contents of each file.
   llvm::StringMap<std::string> AdditionalFiles;
 
   // Extra arguments for the compiler invocation.
   std::vector<std::string> ExtraArgs;
 
+  Config Cfg;
+
   // Predefine macros such as __UINTPTR_TYPE__.
   bool PredefineMacros = false;
 
   TidyProvider ClangTidyProvider = {};
   // Index to use when building AST.
   const SymbolIndex *ExternalIndex = nullptr;
 
   // Simulate a header guard of the header (using an #import directive).

clang-tools-extra/clangd/unittests/TestTU.cpp

 //===--- TestTU.cpp - Scratch source files for testing --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestTU.h"
 #include "CompileCommands.h"
 #include "Compiler.h"
+#include "Config.h"
 #include "Diagnostics.h"
 #include "TestFS.h"
 #include "index/FileIndex.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdlib>
 
 namespace clang {
 namespace clangd {
 
+TestTU::TestTU() {
+  // Disable the clangd-specific diagnostics by default.
+  Cfg.Diagnostics.UnusedIncludes = Config::IncludesPolicy::None;
+  Cfg.Diagnostics.MissingIncludes = Config::IncludesPolicy::None;
+}
+
 ParseInputs TestTU::inputs(MockFS &FS) const {
   std::string FullFilename = testPath(Filename),
               FullHeaderName = testPath(HeaderFilename),
               ImportThunk = testPath("import_thunk.h");
   // We want to implicitly include HeaderFilename without messing up offsets.
   // -include achieves this, but sometimes we want #import (to simulate a header
   // guard without messing up offsets). In this case, use an intermediate file.
   std::string ThunkContents = "#import \"" + FullHeaderName + "\"\n";
ParsedAST TestTU::build() const {
   Inputs.Opts = ParseOpts;
   StoreDiags Diags;
   auto CI = buildCompilerInvocation(Inputs, Diags);
   assert(CI && "Failed to build compilation invocation.");
   if (OverlayRealFileSystemForModules)
     initializeModuleCache(*CI);
   auto ModuleCacheDeleter = llvm::make_scope_exit(
       std::bind(deleteModuleCache, CI->getHeaderSearchOpts().ModuleCachePath));
-
+  WithContextValue Ctx(Config::Key, Cfg);
   auto Preamble = clang::clangd::buildPreamble(testPath(Filename), *CI, Inputs,
                                                /*StoreInMemory=*/true,
                                                /*PreambleCallback=*/nullptr);
   auto AST = ParsedAST::build(testPath(Filename), Inputs, std::move(CI),
                               Diags.take(), Preamble);
   if (!AST) {
     llvm::errs() << "Failed to build code:\n" << Code;
     std::abort();