[clangd] Always allow diagnostics from stale preambles

[kadircet]

Summary

We've been running this internally for months now, without any
stability or correctness concerns. It has ~40% speed up on incremental
diagnostics latencies (as preamble can get invalidated through code completion
etc.).

[kadircet]

• Squash base commit

[hokein]

clang-tools-extra/clangd/ConfigYAML.cpp

137

I wonder whether it is worth keeping this flag, but no-op (just emitting an warning message, this flag is no-op).

Probably not worth, since this flag was introduced recently, and it is not in any release.

clang-tools-extra/clangd/ParsedAST.h

156–157

nit: update the comment.

[kadircet]

clang-tools-extra/clangd/ConfigYAML.cpp

137

that's what happens to unrecognized config keys already. user will get a diag message when parsing their config that says AllowStalePreamble is not recognized.

clang-tools-extra/clangd/ClangdLSPServer.h

 //===--- ClangdLSPServer.h - LSP server --------------------------*- 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_CLANGDLSPSERVER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_CLANGDLSPSERVER_H
 
 #include "ClangdServer.h"
+#include "Diagnostics.h"
 #include "GlobalCompilationDatabase.h"
 #include "LSPBinder.h"
 #include "Protocol.h"
 #include "Transport.h"
 #include "support/Context.h"
 #include "support/MemoryTree.h"
 #include "support/Path.h"
 #include "support/Threading.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/JSON.h"
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <optional>
 #include <vector>
 
public:
   bool run();
 
   /// Profiles resource-usage.
   void profile(MemoryTree &MT) const;
 
 private:
   // Implement ClangdServer::Callbacks.
   void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
-                          std::vector<Diag> Diagnostics) override;
+                          llvm::ArrayRef<Diag> Diagnostics) override;
   void onFileUpdated(PathRef File, const TUStatus &Status) override;
   void onBackgroundIndexProgress(const BackgroundQueue::Stats &Stats) override;
   void onSemanticsMaybeChanged(PathRef File) override;
   void onInactiveRegionsReady(PathRef File,
                               std::vector<Range> InactiveRegions) override;
 
   // LSP methods. Notifications have signature void(const Params&).
   // Calls have signature void(const Params&, Callback<Response>).
private:
   LSPBinder::OutgoingMethod<NoParams, std::nullptr_t> SemanticTokensRefresh;
 
   void applyEdit(WorkspaceEdit WE, llvm::json::Value Success,
                  Callback<llvm::json::Value> Reply);
 
   void bindMethods(LSPBinder &, const ClientCapabilities &Caps);
   std::vector<CodeAction> getFixes(StringRef File, const clangd::Diagnostic &D);
 
-
   /// Checks if completion request should be ignored. We need this due to the
   /// limitation of the LSP. Per LSP, a client sends requests for all "trigger
   /// character" we specify, but for '>' and ':' we need to check they actually
   /// produce '->' and '::', respectively.
   bool shouldRunCompletion(const CompletionParams &Params) const;
 
   void applyConfiguration(const ConfigurationSettings &Settings);
 

clang-tools-extra/clangd/ClangdLSPServer.cpp

void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   ServerCaps["codeActionProvider"] =
       Params.capabilities.CodeActionStructure
           ? llvm::json::Object{{"codeActionKinds",
                                 {CodeAction::QUICKFIX_KIND,
                                  CodeAction::REFACTOR_KIND,
                                  CodeAction::INFO_KIND}}}
           : llvm::json::Value(true);
 
-
   std::vector<llvm::StringRef> Commands;
   for (llvm::StringRef Command : Handlers.CommandHandlers.keys())
     Commands.push_back(Command);
   llvm::sort(Commands);
   ServerCaps["executeCommandProvider"] =
       llvm::json::Object{{"commands", Commands}};
 
   llvm::json::Object Result{
if (!Offset) {
     vlog("could not convert position '{0}' to offset for file '{1}'",
          Params.position, Params.textDocument.uri.file());
     return true;
   }
   return allowImplicitCompletion(*Code, *Offset);
 }
 
 void ClangdLSPServer::onDiagnosticsReady(PathRef File, llvm::StringRef Version,
-                                         std::vector<Diag> Diagnostics) {
+                                         llvm::ArrayRef<Diag> Diagnostics) {
   PublishDiagnosticsParams Notification;
   Notification.version = decodeVersion(Version);
   Notification.uri = URIForFile::canonicalize(File, /*TUPath=*/File);
   DiagnosticToReplacementMap LocalFixIts; // Temporary storage
   for (auto &Diag : Diagnostics) {
     toLSPDiags(Diag, Notification.uri, DiagOpts,
                [&](clangd::Diagnostic Diag, llvm::ArrayRef<Fix> Fixes) {
                  std::vector<CodeAction> CodeActions;

clang-tools-extra/clangd/ClangdServer.h

 #include "index/Index.h"
 #include "refactor/Rename.h"
 #include "refactor/Tweak.h"
 #include "support/Function.h"
 #include "support/MemoryTree.h"
 #include "support/Path.h"
 #include "support/ThreadsafeFS.h"
 #include "clang/Tooling/Core/Replacement.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include <functional>
 #include <memory>
 #include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
public:
   public:
     virtual ~Callbacks() = default;
 
     /// Called by ClangdServer when \p Diagnostics for \p File are ready.
     /// These pushed diagnostics might correspond to an older version of the
     /// file, they do not interfere with "pull-based" ClangdServer::diagnostics.
     /// May be called concurrently for separate files, not for a single file.
     virtual void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
-                                    std::vector<Diag> Diagnostics) {}
+                                    llvm::ArrayRef<Diag> Diagnostics) {}
     /// Called whenever the file status is updated.
     /// May be called concurrently for separate files, not for a single file.
     virtual void onFileUpdated(PathRef File, const TUStatus &Status) {}
 
     /// Called when background indexing tasks are enqueued/started/completed.
     /// Not called concurrently.
     virtual void
     onBackgroundIndexProgress(const BackgroundQueue::Stats &Stats) {}

clang-tools-extra/clangd/ClangdServer.cpp

void indexStdlib(const CompilerInvocation &CI, StdLibLocation Loc) {
     else
       Task();
   }
 
   void onMainAST(PathRef Path, ParsedAST &AST, PublishFn Publish) override {
     if (FIndex)
       FIndex->updateMain(Path, AST);
 
-    assert(AST.getDiagnostics() &&
-           "We issue callback only with fresh preambles");
-    std::vector<Diag> Diagnostics = *AST.getDiagnostics();
     if (ServerCallbacks)
       Publish([&]() {
         ServerCallbacks->onDiagnosticsReady(Path, AST.version(),
-                                            std::move(Diagnostics));
+                                            AST.getDiagnostics());
         if (CollectInactiveRegions) {
           ServerCallbacks->onInactiveRegionsReady(Path,
                                                   getInactiveRegions(AST));
         }
       });
   }
 
   void onFailedAST(PathRef Path, llvm::StringRef Version,
Context operator()(llvm::StringRef File) {
       });
       // Blindly publish diagnostics for the (unopened) parsed config files.
       // We must avoid reporting diagnostics for *the same file* concurrently.
       // Source diags are published elsewhere, but those are different files.
       if (!ReportableDiagnostics.empty()) {
         std::lock_guard<std::mutex> Lock(PublishMu);
         for (auto &Entry : ReportableDiagnostics)
           Publish->onDiagnosticsReady(Entry.first(), /*Version=*/"",
-                                      std::move(Entry.second));
+                                      Entry.second);
       }
       return Context::current().derive(Config::Key, std::move(C));
     }
 
     void handleDiagnostic(const llvm::SMDiagnostic &D,
                           std::vector<Diag> *ClientDiagnostics) {
       switch (D.getKind()) {
       case llvm::SourceMgr::DK_Error:
void ClangdServer::customAction(PathRef File, llvm::StringRef Name,
   WorkScheduler->runWithAST(Name, File, std::move(Action));
 }
 
 void ClangdServer::diagnostics(PathRef File, Callback<std::vector<Diag>> CB) {
   auto Action =
       [CB = std::move(CB)](llvm::Expected<InputsAndAST> InpAST) mutable {
         if (!InpAST)
           return CB(InpAST.takeError());
-        if (auto Diags = InpAST->AST.getDiagnostics())
-          return CB(*Diags);
-        // FIXME: Use ServerCancelled error once it is settled in LSP-3.17.
-        return CB(llvm::make_error<LSPError>("server is busy parsing includes",
-                                             ErrorCode::InternalError));
+        return CB(InpAST->AST.getDiagnostics());
       };
 
   WorkScheduler->runWithAST("Diagnostics", File, std::move(Action));
 }
 
 llvm::StringMap<TUScheduler::FileStats> ClangdServer::fileStats() const {
   return WorkScheduler->fileStats();
 }

clang-tools-extra/clangd/Config.h

struct {
 
     /// Configures what clang-tidy checks to run and options to use with them.
     struct {
       // A comma-seperated list of globs specify which clang-tidy checks to run.
       std::string Checks;
       llvm::StringMap<std::string> CheckOptions;
     } ClangTidy;
 
-    /// Enable emitting diagnostics using stale preambles.
-    bool AllowStalePreamble = false;
-
     IncludesPolicy UnusedIncludes = IncludesPolicy::Strict;
     IncludesPolicy MissingIncludes = IncludesPolicy::None;
 
     /// IncludeCleaner will not diagnose usages of these headers matched by
     /// these regexes.
     struct {
       std::vector<std::function<bool(llvm::StringRef)>> IgnoreHeader;
     } Includes;

clang-tools-extra/clangd/ConfigCompile.cpp

if (F.UnusedIncludes) {
       }
       if (Val) {
         Out.Apply.push_back([Val](const Params &, Config &C) {
           C.Diagnostics.UnusedIncludes = *Val;
         });
       }
     }
 
-    if (F.AllowStalePreamble) {
-      if (auto Val = F.AllowStalePreamble)
-        Out.Apply.push_back([Val](const Params &, Config &C) {
-          C.Diagnostics.AllowStalePreamble = **Val;
-        });
-    }
-
     if (F.MissingIncludes)
       if (auto Val = compileEnum<Config::IncludesPolicy>("MissingIncludes",
                                                          **F.MissingIncludes)
                          .map("Strict", Config::IncludesPolicy::Strict)
                          .map("None", Config::IncludesPolicy::None)
                          .value())
         Out.Apply.push_back([Val](const Params &, Config &C) {
           C.Diagnostics.MissingIncludes = *Val;

clang-tools-extra/clangd/ConfigFragment.h

struct DiagnosticsBlock {
     /// transitively includes headers that are used. This should be fixed by
     /// including those headers directly.
     ///
     /// Valid values are:
     /// - Strict
     /// - std::nullopt
     std::optional<Located<std::string>> UnusedIncludes;
 
-    /// Enable emitting diagnostics using stale preambles.
-    std::optional<Located<bool>> AllowStalePreamble;
-
     /// Controls if clangd should analyze missing #include directives.
     /// clangd will warn if no header providing a symbol is `#include`d
     /// (missing) directly, and suggest adding it.
     ///
     /// Strict means a header providing a symbol is missing if it is not
     /// *directly #include'd. The file might still compile if the header is
     /// included transitively.
     ///

clang-tools-extra/clangd/ConfigYAML.cpp

void parse(Fragment::DiagnosticsBlock &F, Node &N) {
     Dict.handle("UnusedIncludes", [&](Node &N) {
       F.UnusedIncludes = scalarValue(N, "UnusedIncludes");
     });
     Dict.handle("MissingIncludes", [&](Node &N) {
       F.MissingIncludes = scalarValue(N, "MissingIncludes");
     });
     Dict.handle("Includes", [&](Node &N) { parse(F.Includes, N); });
     Dict.handle("ClangTidy", [&](Node &N) { parse(F.ClangTidy, N); });
-    Dict.handle("AllowStalePreamble", [&](Node &N) {
-      F.AllowStalePreamble = boolValue(N, "AllowStalePreamble");
-    });
     Dict.parse(N);
   }
 
   void parse(Fragment::DiagnosticsBlock::ClangTidyBlock &F, Node &N) {
     DictParser Dict("ClangTidy", this);
     Dict.handle("Add", [&](Node &N) {
       if (auto Values = scalarValues(N))
         F.Add = std::move(*Values);

clang-tools-extra/clangd/ParsedAST.h

public:
   }
 
   /// This function returns top-level decls present in the main file of the AST.
   /// The result does not include the decls that come from the preamble.
   /// (These should be const, but RecursiveASTVisitor requires Decl*).
   ArrayRef<Decl *> getLocalTopLevelDecls();
   ArrayRef<const Decl *> getLocalTopLevelDecls() const;
 
-  const std::optional<std::vector<Diag>> &getDiagnostics() const {
-    return Diags;
-  }
+  llvm::ArrayRef<Diag> getDiagnostics() const;
 
   /// Returns the estimated size of the AST and the accessory structures, in
   /// bytes. Does not include the size of the preamble.
   std::size_t getUsedBytes() const;
   const IncludeStructure &getIncludeStructure() const;
   const CanonicalIncludes &getCanonicalIncludes() const;
 
   /// Gets all macro references (definition, expansions) present in the main
public:
   }
 
 private:
   ParsedAST(PathRef TUPath, llvm::StringRef Version,
             std::shared_ptr<const PreambleData> Preamble,
             std::unique_ptr<CompilerInstance> Clang,
             std::unique_ptr<FrontendAction> Action, syntax::TokenBuffer Tokens,
             MainFileMacros Macros, std::vector<PragmaMark> Marks,
-            std::vector<Decl *> LocalTopLevelDecls,
-            std::optional<std::vector<Diag>> Diags, IncludeStructure Includes,
-            CanonicalIncludes CanonIncludes);
+            std::vector<Decl *> LocalTopLevelDecls, std::vector<Diag> Diags,
+            IncludeStructure Includes, CanonicalIncludes CanonIncludes);
 
   Path TUPath;
   std::string Version;
   // In-memory preambles must outlive the AST, it is important that this member
   // goes before Clang and Action.
   std::shared_ptr<const PreambleData> Preamble;
   // We store an "incomplete" FrontendAction (i.e. no EndSourceFile was called
   // on it) and CompilerInstance used to run it. That way we don't have to do
   // complex memory management of all Clang structures on our own. (They are
   // stored in CompilerInstance and cleaned up by
   // FrontendAction.EndSourceFile).
   std::unique_ptr<CompilerInstance> Clang;
   std::unique_ptr<FrontendAction> Action;
   /// Tokens recorded after the preamble finished.
   ///   - Includes all spelled tokens for the main file.
   ///   - Includes expanded tokens produced **after** preamble.
   ///   - Does not have spelled or expanded tokens for files from preamble.
   syntax::TokenBuffer Tokens;
 
   /// All macro definitions and expansions in the main file.
   MainFileMacros Macros;
   // Pragma marks in the main file.
   std::vector<PragmaMark> Marks;
-  // Data, stored after parsing. std::nullopt if AST was built with a stale
-  // preamble.
-  std::optional<std::vector<Diag>> Diags;
+  // Diags emitted while parsing this AST (including preamble and compiler
+  // invocation).
+  std::vector<Diag> Diags;
   // Top-level decls inside the current file. Not that this does not include
   // top-level decls from the preamble.
   std::vector<Decl *> LocalTopLevelDecls;
   IncludeStructure Includes;
   CanonicalIncludes CanonIncludes;
   std::unique_ptr<HeuristicResolver> Resolver;
 };
 
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_PARSEDAST_H

clang-tools-extra/clangd/ParsedAST.cpp

ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
   StoreDiags ASTDiags;
   ASTDiags.setDiagCallback(
       [&ASTListeners](const clang::Diagnostic &D, clangd::Diag &Diag) {
         llvm::for_each(ASTListeners,
                        [&](const auto &L) { L->sawDiagnostic(D, Diag); });
       });
 
   std::optional<PreamblePatch> Patch;
-  bool PreserveDiags = true;
   // We might use an ignoring diagnostic consumer if they are going to be
   // dropped later on to not pay for extra latency by processing them.
   DiagnosticConsumer *DiagConsumer = &ASTDiags;
   IgnoreDiagnostics DropDiags;
   if (Preamble) {
     Patch = PreamblePatch::createFullPatch(Filename, Inputs, *Preamble);
     Patch->apply(*CI);
-    PreserveDiags = Patch->preserveDiagnostics();
-    if (!PreserveDiags)
-      DiagConsumer = &DropDiags;
   }
   auto Clang = prepareCompilerInstance(
       std::move(CI), PreamblePCH,
       llvm::MemoryBuffer::getMemBufferCopy(Inputs.Contents, Filename), VFS,
       *DiagConsumer);
   if (!Clang) {
     // The last diagnostic contains information about the reason of this
     // failure.
     std::vector<Diag> Diags(ASTDiags.take());
     elog("Failed to prepare a compiler instance: {0}",
          !Diags.empty() ? static_cast<DiagBase &>(Diags.back()).Message
                         : "unknown error");
     return std::nullopt;
   }
   tidy::ClangTidyOptions ClangTidyOpts;
-  if (PreserveDiags) {
+  {
     trace::Span Tracer("ClangTidyOpts");
     ClangTidyOpts = getTidyOptionsForFile(Inputs.ClangTidyProvider, Filename);
     dlog("ClangTidy configuration for file {0}: {1}", Filename,
          tidy::configurationAsText(ClangTidyOpts));
 
     // If clang-tidy is configured to emit clang warnings, we should too.
     //
     // Such clang-tidy configuration consists of two parts:
tidy::ClangTidyOptions ClangTidyOpts;
     // Instead, we just use these to filter which extra diagnostics we enable.
     auto &Diags = Clang->getDiagnostics();
     TidyDiagnosticGroups TidyGroups(ClangTidyOpts.Checks ? *ClangTidyOpts.Checks
                                                          : llvm::StringRef());
     if (ClangTidyOpts.ExtraArgsBefore)
       applyWarningOptions(*ClangTidyOpts.ExtraArgsBefore, TidyGroups, Diags);
     if (ClangTidyOpts.ExtraArgs)
       applyWarningOptions(*ClangTidyOpts.ExtraArgs, TidyGroups, Diags);
-  } else {
-    // Skips some analysis.
-    Clang->getDiagnosticOpts().IgnoreWarnings = true;
   }
 
   auto Action = std::make_unique<ClangdFrontendAction>();
   const FrontendInputFile &MainInput = Clang->getFrontendOpts().Inputs[0];
   if (!Action->BeginSourceFile(*Clang, MainInput)) {
     log("BeginSourceFile() failed when building AST for {0}",
         MainInput.getFile());
     return std::nullopt;
ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
   ast_matchers::MatchFinder CTFinder;
   std::optional<tidy::ClangTidyContext> CTContext;
   // Must outlive FixIncludes.
   auto BuildDir = VFS->getCurrentWorkingDirectory();
   std::optional<IncludeFixer> FixIncludes;
   llvm::DenseMap<diag::kind, DiagnosticsEngine::Level> OverriddenSeverity;
   // No need to run clang-tidy or IncludeFixerif we are not going to surface
   // diagnostics.
-  if (PreserveDiags) {
+  {
     trace::Span Tracer("ClangTidyInit");
     static const auto *CTFactories = [] {
       auto *CTFactories = new tidy::ClangTidyCheckFactories;
       for (const auto &E : tidy::ClangTidyModuleRegistry::entries())
         E.instantiate()->addCheckFactories(*CTFactories);
       return CTFactories;
     }();
     CTContext.emplace(std::make_unique<tidy::DefaultOptionsProvider>(
ParsedAST::build(llvm::StringRef Filename, const ParseInputs &Inputs,
   // So just inform the preprocessor of EOF, while keeping everything alive.
   PP.EndSourceFile();
   // UnitDiagsConsumer is local, we can not store it in CompilerInstance that
   // has a longer lifetime.
   Clang->getDiagnostics().setClient(new IgnoreDiagnostics);
   // CompilerInstance won't run this callback, do it directly.
   ASTDiags.EndSourceFile();
 
-  std::optional<std::vector<Diag>> Diags;
+  std::vector<Diag> Diags = CompilerInvocationDiags;
   // FIXME: Also skip generation of diagnostics alltogether to speed up ast
   // builds when we are patching a stale preamble.
-  if (PreserveDiags) {
-    Diags = CompilerInvocationDiags;
-    // Add diagnostics from the preamble, if any.
-    if (Preamble)
-      llvm::append_range(*Diags, Patch->patchedDiags());
-    // Finally, add diagnostics coming from the AST.
-    {
-      std::vector<Diag> D = ASTDiags.take(&*CTContext);
-      Diags->insert(Diags->end(), D.begin(), D.end());
-    }
+    llvm::append_range(Diags, Patch->patchedDiags());
+    Diags.insert(Diags.end(), D.begin(), D.end());
   }
   ParsedAST Result(Filename, Inputs.Version, std::move(Preamble),
                    std::move(Clang), std::move(Action), std::move(Tokens),
                    std::move(Macros), std::move(Marks), std::move(ParsedDecls),
                    std::move(Diags), std::move(Includes),
                    std::move(CanonIncludes));
-  if (Result.Diags)
-    llvm::move(getIncludeCleanerDiags(Result, Inputs.Contents),
-               std::back_inserter(*Result.Diags));
+             std::back_inserter(Result.Diags));
   return std::move(Result);
 }
 
 ParsedAST::ParsedAST(ParsedAST &&Other) = default;
 
 ParsedAST &ParsedAST::operator=(ParsedAST &&Other) = default;
 
 ParsedAST::~ParsedAST() {

 
 const MainFileMacros &ParsedAST::getMacros() const { return Macros; }
 const std::vector<PragmaMark> &ParsedAST::getMarks() const { return Marks; }
 
 std::size_t ParsedAST::getUsedBytes() const {
   auto &AST = getASTContext();
   // FIXME(ibiryukov): we do not account for the dynamically allocated part of
   // Message and Fixes inside each diagnostic.
-  std::size_t Total = clangd::getUsedBytes(LocalTopLevelDecls) +
-                      (Diags ? clangd::getUsedBytes(*Diags) : 0);
+  std::size_t Total =
+      clangd::getUsedBytes(LocalTopLevelDecls) + clangd::getUsedBytes(Diags);
 
   // FIXME: the rest of the function is almost a direct copy-paste from
   // libclang's clang_getCXTUResourceUsage. We could share the implementation.
 
   // Sum up various allocators inside the ast context and the preprocessor.
   Total += AST.getASTAllocatedMemory();
   Total += AST.getSideTableAllocatedMemory();
   Total += AST.Idents.getAllocator().getTotalMemory();

 
 ParsedAST::ParsedAST(PathRef TUPath, llvm::StringRef Version,
                      std::shared_ptr<const PreambleData> Preamble,
                      std::unique_ptr<CompilerInstance> Clang,
                      std::unique_ptr<FrontendAction> Action,
                      syntax::TokenBuffer Tokens, MainFileMacros Macros,
                      std::vector<PragmaMark> Marks,
                      std::vector<Decl *> LocalTopLevelDecls,
-                     std::optional<std::vector<Diag>> Diags,
-                     IncludeStructure Includes, CanonicalIncludes CanonIncludes)
+                     std::vector<Diag> Diags, IncludeStructure Includes,
+                     CanonicalIncludes CanonIncludes)
     : TUPath(TUPath), Version(Version), Preamble(std::move(Preamble)),
       Clang(std::move(Clang)), Action(std::move(Action)),
       Tokens(std::move(Tokens)), Macros(std::move(Macros)),
       Marks(std::move(Marks)), Diags(std::move(Diags)),
       LocalTopLevelDecls(std::move(LocalTopLevelDecls)),
       Includes(std::move(Includes)), CanonIncludes(std::move(CanonIncludes)) {
   Resolver = std::make_unique<HeuristicResolver>(getASTContext());
   assert(this->Clang);
   assert(this->Action);
 }
 
 const include_cleaner::PragmaIncludes *ParsedAST::getPragmaIncludes() const {
   if (!Preamble)
     return nullptr;
   return &Preamble->Pragmas;
 }
 
 std::optional<llvm::StringRef> ParsedAST::preambleVersion() const {
   if (!Preamble)
     return std::nullopt;
   return llvm::StringRef(Preamble->Version);
 }
 
+llvm::ArrayRef<Diag> ParsedAST::getDiagnostics() const { return Diags; }
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/Preamble.h

public:
   std::vector<Inclusion> preambleIncludes() const;
 
   /// Returns preamble bounds for the Modified.
   PreambleBounds modifiedBounds() const { return ModifiedBounds; }
 
   /// Returns textual patch contents.
   llvm::StringRef text() const { return PatchContents; }
 
-  /// Whether diagnostics generated using this patch are trustable.
-  bool preserveDiagnostics() const;
-
   /// Returns diag locations for Modified contents.
   llvm::ArrayRef<Diag> patchedDiags() const { return PatchedDiags; }
 
   static constexpr llvm::StringLiteral HeaderName = "__preamble_patch__.h";
 
   llvm::ArrayRef<PragmaMark> marks() const;
   const MainFileMacros &mainFileMacros() const;
 

clang-tools-extra/clangd/Preamble.cpp

PreamblePatch PreamblePatch::unmodified(const PreambleData &Preamble) {
   PreamblePatch PP;
   PP.Baseline = &Preamble;
   PP.PreambleIncludes = Preamble.Includes.MainFileIncludes;
   PP.ModifiedBounds = Preamble.Preamble.getBounds();
   PP.PatchedDiags = Preamble.Diags;
   return PP;
 }
 
-bool PreamblePatch::preserveDiagnostics() const {
-  return PatchContents.empty() ||
-         Config::current().Diagnostics.AllowStalePreamble;
-}
 llvm::ArrayRef<PragmaMark> PreamblePatch::marks() const {
   if (PatchContents.empty())
     return Baseline->Marks;
   return PatchedMarks;
 }
 
 const MainFileMacros &PreamblePatch::mainFileMacros() const {
   if (PatchContents.empty())

clang-tools-extra/clangd/TUScheduler.cpp

auto Task = [=]() mutable {
     // can be built concurrently.
     PreamblePeer.update(std::make_unique<CompilerInvocation>(*Invocation),
                         Inputs, CompilerInvocationDiags, WantDiags);
 
     // Emit diagnostics from (possibly) stale preamble while waiting for a
     // rebuild. Newly built preamble cannot emit diagnostics before this call
     // finishes (ast callbacks are called from astpeer thread), hence we
     // gurantee eventual consistency.
-    if (LatestPreamble && WantDiags != WantDiagnostics::No &&
-        Config::current().Diagnostics.AllowStalePreamble)
+    if (LatestPreamble && WantDiags != WantDiagnostics::No)
       generateDiagnostics(std::move(Invocation), std::move(Inputs),
                           std::move(CompilerInvocationDiags));
 
     std::unique_lock<std::mutex> Lock(Mutex);
     PreambleCV.wait(Lock, [this] {
       // Block until we reiceve a preamble request, unless a preamble already
       // exists, as patching an empty preamble would imply rebuilding it from
       // scratch.

 void ASTWorker::updatePreamble(std::unique_ptr<CompilerInvocation> CI,
                                ParseInputs PI,
                                std::shared_ptr<const PreambleData> Preamble,
                                std::vector<Diag> CIDiags,
                                WantDiagnostics WantDiags) {
   llvm::StringLiteral TaskName = "Build AST";
   // Store preamble and build diagnostics with new preamble if requested.
   auto Task = [this, Preamble = std::move(Preamble), CI = std::move(CI),
-               PI = std::move(PI), CIDiags = std::move(CIDiags),
+               CIDiags = std::move(CIDiags),
                WantDiags = std::move(WantDiags)]() mutable {
     // Update the preamble inside ASTWorker queue to ensure atomicity. As a task
     // running inside ASTWorker assumes internals won't change until it
     // finishes.
     if (!LatestPreamble || Preamble != *LatestPreamble) {
       ++PreambleBuildCount;
       // Cached AST is no longer valid.
       IdleASTs.take(this);
auto Task = [this, Preamble = std::move(Preamble), CI = std::move(CI),
     // Notify anyone waiting for a preamble.
     PreambleCV.notify_all();
     // Give up our ownership to old preamble before starting expensive AST
     // build.
     Preamble.reset();
     // We only need to build the AST if diagnostics were requested.
     if (WantDiags == WantDiagnostics::No)
       return;
-    // The file may have been edited since we started building this preamble.
-    // If diagnostics need a fresh preamble, we must use the old version that
-    // matches the preamble. We make forward progress as updatePreamble()
-    // receives increasing versions, and this is the only place we emit
-    // diagnostics.
-    // If diagnostics can use a stale preamble, we use the current contents of
-    // the file instead. This provides more up-to-date diagnostics, and avoids
-    // diagnostics going backwards (we may have already emitted staler-preamble
-    // diagnostics for the new version). We still have eventual consistency: at
-    // some point updatePreamble() will catch up to the current file.
-    if (Config::current().Diagnostics.AllowStalePreamble)
-      PI = FileInputs;
+    // Since the file may have been edited since we started building this
+    // preamble, we use the current contents of the file instead. This provides
+    // more up-to-date diagnostics, and avoids diagnostics going backwards (we
+    // may have already emitted staler-preamble diagnostics for the new
+    // version).
+    // We still have eventual consistency: at some point updatePreamble() will
+    // catch up to the current file.
     // Report diagnostics with the new preamble to ensure progress. Otherwise
     // diagnostics might get stale indefinitely if user keeps invalidating the
     // preamble.
-    generateDiagnostics(std::move(CI), std::move(PI), std::move(CIDiags));
+    generateDiagnostics(std::move(CI), FileInputs, std::move(CIDiags));
   };
   if (RunSync) {
     runTask(TaskName, Task);
     return;
   }
   {
     std::lock_guard<std::mutex> Lock(Mutex);
     PreambleRequests.push_back({std::move(Task), std::string(TaskName),

clang-tools-extra/clangd/tool/Check.cpp

bool buildAST() {
 
     log("Building AST...");
     AST = ParsedAST::build(File, Inputs, std::move(Invocation),
                            /*InvocationDiags=*/std::vector<Diag>{}, Preamble);
     if (!AST) {
       elog("Failed to build AST");
       return false;
     }
-    ErrCount += showErrors(llvm::ArrayRef(*AST->getDiagnostics())
-                               .drop_front(Preamble->Diags.size()));
+    ErrCount +=
+        showErrors(AST->getDiagnostics().drop_front(Preamble->Diags.size()));
 
     if (Opts.BuildDynamicSymbolIndex) {
       log("Indexing AST...");
       Index.updateMain(File, *AST);
     }
 
     if (!CheckTidyTime.empty()) {
       if (!CLANGD_TIDY_CHECKS) {

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

 #include "refactor/Tweak.h"
 #include "support/MemoryTree.h"
 #include "support/Path.h"
 #include "support/Threading.h"
 #include "clang/Config/config.h"
 #include "clang/Sema/CodeCompleteConsumer.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/Core/Replacement.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/VirtualFileSystem.h"
if (D.Severity == DiagnosticsEngine::Error ||
       return true;
   }
   return false;
 }
 
 class ErrorCheckingCallbacks : public ClangdServer::Callbacks {
 public:
   void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
-                          std::vector<Diag> Diagnostics) override {
+                          llvm::ArrayRef<Diag> Diagnostics) override {
     bool HadError = diagsContainErrors(Diagnostics);
     std::lock_guard<std::mutex> Lock(Mutex);
     HadErrorInLastDiags = HadError;
   }
 
   bool hadErrorInLastDiags() {
     std::lock_guard<std::mutex> Lock(Mutex);
     return HadErrorInLastDiags;
   }
 
 private:
   std::mutex Mutex;
   bool HadErrorInLastDiags = false;
 };
 
 /// For each file, record whether the last published diagnostics contained at
 /// least one error.
 class MultipleErrorCheckingCallbacks : public ClangdServer::Callbacks {
 public:
   void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
-                          std::vector<Diag> Diagnostics) override {
+                          llvm::ArrayRef<Diag> Diagnostics) override {
     bool HadError = diagsContainErrors(Diagnostics);
 
     std::lock_guard<std::mutex> Lock(Mutex);
     LastDiagsHadError[File] = HadError;
   }
 
   /// Exposes all files consumed by onDiagnosticsReady in an unspecified order.
   /// For each file, a bool value indicates whether the last diagnostics
TEST(ClangdServerTest, PropagatesContexts) {
   private:
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> viewImpl() const override {
       Got = Context::current().getExisting(Secret);
       return buildTestFS({});
     }
   } FS;
   struct Callbacks : public ClangdServer::Callbacks {
     void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
-                            std::vector<Diag> Diagnostics) override {
+                            llvm::ArrayRef<Diag> Diagnostics) override {
       Got = Context::current().getExisting(Secret);
     }
     int Got;
   } Callbacks;
   MockCompilationDatabase CDB;
 
   // Verify that the context is plumbed to the FS provider and diagnostics.
   ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &Callbacks);
TEST(ClangdServerTest, RespectsConfig) {
   EXPECT_NE(Result->front().PreferredDeclaration.range, Example.range());
 }
 
 TEST(ClangdServerTest, PropagatesVersion) {
   MockCompilationDatabase CDB;
   MockFS FS;
   struct Callbacks : public ClangdServer::Callbacks {
     void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
-                            std::vector<Diag> Diagnostics) override {
+                            llvm::ArrayRef<Diag> Diagnostics) override {
       Got = Version.str();
     }
     std::string Got = "";
   } Callbacks;
 
   // Verify that the version is plumbed to diagnostics.
   ClangdServer Server(CDB, FS, ClangdServer::optsForTest(), &Callbacks);
   runAddDocument(Server, testPath("foo.cpp"), "void main(){}", "42");
struct FileStat {
     bool HadErrorsInLastDiags = false;
   };
 
   class TestDiagConsumer : public ClangdServer::Callbacks {
   public:
     TestDiagConsumer() : Stats(FilesCount, FileStat()) {}
 
     void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
-                            std::vector<Diag> Diagnostics) override {
+                            llvm::ArrayRef<Diag> Diagnostics) override {
       StringRef FileIndexStr = llvm::sys::path::stem(File);
       ASSERT_TRUE(FileIndexStr.consume_front("Foo"));
 
       unsigned long FileIndex = std::stoul(FileIndexStr.str());
 
       bool HadError = diagsContainErrors(Diagnostics);
 
       std::lock_guard<std::mutex> Lock(Mutex);
TEST(ClangdThreadingTest, NoConcurrentDiagnostics) {
   class NoConcurrentAccessDiagConsumer : public ClangdServer::Callbacks {
   public:
     std::atomic<int> Count = {0};
 
     NoConcurrentAccessDiagConsumer(std::promise<void> StartSecondReparse)
         : StartSecondReparse(std::move(StartSecondReparse)) {}
 
     void onDiagnosticsReady(PathRef, llvm::StringRef,
-                            std::vector<Diag>) override {
+                            llvm::ArrayRef<Diag>) override {
       ++Count;
       std::unique_lock<std::mutex> Lock(Mutex, std::try_to_lock_t());
       ASSERT_TRUE(Lock.owns_lock())
           << "Detected concurrent onDiagnosticsReady calls for the same file.";
 
       // If we started the second parse immediately, it might cancel the first.
       // So we don't allow it to start until the first has delivered diags...
       if (FirstRequest) {
TEST(ClangdServerTest, TestStackOverflow) {
   EXPECT_TRUE(DiagConsumer.hadErrorInLastDiags());
 }
 #endif
 
 TEST(ClangdServer, TidyOverrideTest) {
   struct DiagsCheckingCallback : public ClangdServer::Callbacks {
   public:
     void onDiagnosticsReady(PathRef File, llvm::StringRef Version,
-                            std::vector<Diag> Diagnostics) override {
+                            llvm::ArrayRef<Diag> Diagnostics) override {
       std::lock_guard<std::mutex> Lock(Mutex);
       HadDiagsInLastCallback = !Diagnostics.empty();
     }
 
     std::mutex Mutex;
     bool HadDiagsInLastCallback = false;
   } DiagConsumer;
 

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

 
 TEST_F(ConfigCompileTests, Style) {
   Frag = {};
   Frag.Style.FullyQualifiedNamespaces.push_back(std::string("foo"));
   Frag.Style.FullyQualifiedNamespaces.push_back(std::string("bar"));
   EXPECT_TRUE(compileAndApply());
   EXPECT_THAT(Conf.Style.FullyQualifiedNamespaces, ElementsAre("foo", "bar"));
 }
-
-TEST_F(ConfigCompileTests, AllowDiagsFromStalePreamble) {
-  Frag = {};
-  EXPECT_TRUE(compileAndApply());
-  // Off by default.
-  EXPECT_EQ(Conf.Diagnostics.AllowStalePreamble, false);
-
-  Frag.Diagnostics.AllowStalePreamble.emplace(true);
-  EXPECT_TRUE(compileAndApply());
-  EXPECT_EQ(Conf.Diagnostics.AllowStalePreamble, true);
-
-  Frag.Diagnostics.AllowStalePreamble.emplace(false);
-  EXPECT_TRUE(compileAndApply());
-  EXPECT_EQ(Conf.Diagnostics.AllowStalePreamble, false);
-}
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang

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

Style:
   FullyQualifiedNamespaces: [foo, bar])yaml");
   auto Results =
       Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
   ASSERT_EQ(Results.size(), 1u);
   EXPECT_THAT(Results[0].Style.FullyQualifiedNamespaces,
               ElementsAre(val("foo"), val("bar")));
 }
-
-TEST(ParseYAML, DiagnosticsMode) {
-  CapturedDiags Diags;
-  {
-    Annotations YAML(R"yaml(
-Diagnostics:
-  AllowStalePreamble: Yes)yaml");
-    auto Results =
-        Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
-    ASSERT_THAT(Diags.Diagnostics, IsEmpty());
-    ASSERT_EQ(Results.size(), 1u);
-    EXPECT_THAT(Results[0].Diagnostics.AllowStalePreamble,
-                llvm::ValueIs(val(true)));
-  }
-
-  {
-    Annotations YAML(R"yaml(
-Diagnostics:
-  AllowStalePreamble: No)yaml");
-    auto Results =
-        Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
-    ASSERT_THAT(Diags.Diagnostics, IsEmpty());
-    ASSERT_EQ(Results.size(), 1u);
-    EXPECT_THAT(Results[0].Diagnostics.AllowStalePreamble,
-                llvm::ValueIs(val(false)));
-  }
-}
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang

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

o]]();
       struct Foo { int x; }; Foo a;
       a.$nomember[[y]];
       test::$nomembernamespace[[test]];
       $macro[[ID($macroarg[[fod]])]]();
     }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(
           // Make sure the whole token is highlighted.
           AllOf(Diag(Test.range("range"),
                      "invalid range expression of type 'struct Container *'; "
                      "did you mean to dereference it with '*'?"),
                 withFix(Fix(Test.range("insertstar"), "*", "insert '*'"))),
           // This range spans lines.
           AllOf(Diag(Test.range("typo"),
Annotations Test(R"cpp(
     enum A { X };
     struct B { A a; };
     void foo(B b) {
       switch ([[b.a]]) {}
     }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.ExtraArgs = {"-Wswitch"};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(Diag(Test.range(),
                                "enumeration value 'X' not handled in switch")));
 }
 
 TEST(DiagnosticsTest, FlagsMatter) {
   Annotations Test("[[void]] main() {} // error-ok");
   auto TU = TestTU::withCode(Test.code());
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
                                 withFix(Fix(Test.range(), "int",
                                             "change 'void' to 'int'")))));
   // Same code built as C gets different diagnostics.
   TU.Filename = "Plain.c";
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(), "return type of 'main' is not 'int'"),
           withFix(Fix(Test.range(), "int", "change return type to 'int'")))));
 }
 
 TEST(DiagnosticsTest, DiagnosticPreamble) {
   Annotations Test(R"cpp(
     #include $[["not-found.h"]] // error-ok
   )cpp");
 
   auto TU = TestTU::withCode(Test.code());
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(::testing::AllOf(
                   Diag(Test.range(), "'not-found.h' file not found"),
                   diagSource(Diag::Clang), diagName("pp_file_not_found"))));
 }
 
 TEST(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
   Annotations Test(R"cpp(
     float foo = [[0.1f]];
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   // Enable alias clang-tidy checks, these check emits the same diagnostics
   // (except the check name).
   TU.ClangTidyProvider = addTidyChecks("readability-uppercase-literal-suffix,"
                                        "hicpp-uppercase-literal-suffix");
   // Verify that we filter out the duplicated diagnostic message.
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Test.range(),
                "floating point literal has suffix 'f', which is not uppercase"),
           diagSource(Diag::ClangTidy)))));
 
   Test = Annotations(R"cpp(
     template<typename T>
     void func(T) {
       float f = [[0.3f]];
     }
     void k() {
       func(123);
       func(2.0);
     }
   )cpp");
   TU.Code = std::string(Test.code());
   // The check doesn't handle template instantiations which ends up emitting
   // duplicated messages, verify that we deduplicate them.
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Test.range(),
                "floating point literal has suffix 'f', which is not uppercase"),
           diagSource(Diag::ClangTidy)))));
 }
 
 TEST(DiagnosticsTest, ClangTidy) {
   Annotations Test(R"cpp(
TEST(DiagnosticsTest, ClangTidy) {
   TU.HeaderFilename = "assert.h"; // Suppress "not found" error.
   TU.ClangTidyProvider = addTidyChecks("bugprone-sizeof-expression,"
                                        "bugprone-macro-repeated-side-effects,"
                                        "modernize-deprecated-headers,"
                                        "modernize-use-trailing-return-type,"
                                        "misc-no-recursion");
   TU.ExtraArgs.push_back("-Wno-unsequenced");
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(
           AllOf(Diag(Test.range("deprecated"),
                      "inclusion of deprecated C++ header 'assert.h'; consider "
                      "using 'cassert' instead"),
                 diagSource(Diag::ClangTidy),
                 diagName("modernize-deprecated-headers"),
                 withFix(Fix(Test.range("deprecated"), "<cassert>",
                             "change '\"assert.h\"' to '<cassert>'"))),
TEST(DiagnosticsTest, ClangTidyEOF) {
   [[#]]include <b.h>
   #include "a.h")cpp");
   // clang-format on
   auto TU = TestTU::withCode(Test.code());
   TU.ExtraArgs = {"-isystem."};
   TU.AdditionalFiles["a.h"] = TU.AdditionalFiles["b.h"] = "";
   TU.ClangTidyProvider = addTidyChecks("llvm-include-order");
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ifTidyChecks(Contains(
           AllOf(Diag(Test.range(), "#includes are not sorted properly"),
                 diagSource(Diag::ClangTidy), diagName("llvm-include-order")))));
 }
 
 TEST(DiagnosticTest, TemplatesInHeaders) {
   // Diagnostics from templates defined in headers are placed at the expansion.
   Annotations Main(R"cpp(
     Derived<int> [[y]]; // error-ok
   )cpp");
   Annotations Header(R"cpp(
     template <typename T>
     struct Derived : [[T]] {};
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.HeaderCode = Header.code().str();
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Main.range(), "in template: base specifier must name a class"),
           withNote(Diag(Header.range(), "error occurred here"),
                    Diag(Main.range(), "in instantiation of template class "
                                       "'Derived<int>' requested here")))));
 }
 
 TEST(DiagnosticTest, MakeUnique) {
TU.HeaderCode = R"cpp(
     // These mocks aren't quite right - we omit unique_ptr for simplicity.
     // forward is included to show its body is not needed to get the diagnostic.
     template <typename T> T&& forward(T& t);
     template <typename T, typename... A> T* make_unique(A&&... args) {
        return new T(std::forward<A>(args)...);
     }
     }
   )cpp";
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(),
                        "in template: "
                        "no matching constructor for initialization of 'S'")));
 }
 
 TEST(DiagnosticTest, MakeShared) {
   // We usually miss diagnostics from header functions as we don't parse them.
TU.HeaderCode = R"cpp(
     // forward is included to show its body is not needed to get the diagnostic.
     template <typename T> T&& forward(T& t);
     template <typename T, typename... A> T* make_shared(A&&... args) {
        return new T(std::forward<A>(args)...);
     }
     }
   )cpp";
   TU.ParseOpts.PreambleParseForwardingFunctions = true;
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(),
                        "in template: "
                        "no matching constructor for initialization of 'S'")));
 }
 
 TEST(DiagnosticTest, NoMultipleDiagnosticInFlight) {
   Annotations Main(R"cpp(
void f() {
       [[for]] (auto it = label_info_map.begin(); it != label_info_map.end(); ++it) {
         auto S = *it;
       }
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider = addTidyChecks("modernize-loop-convert");
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "use range-based for loop instead"),
           diagSource(Diag::ClangTidy), diagName("modernize-loop-convert")))));
 }
 
 TEST(DiagnosticTest, RespectsDiagnosticConfig) {
   Annotations Main(R"cpp(
     // error-ok
     void x() {
       [[unknown]]();
       $ret[[return]] 42;
     }
   )cpp");
   auto TU = TestTU::withCode(Main.code());
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      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));
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  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));
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 }
 
 TEST(DiagnosticTest, ClangTidySuppressionComment) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double d = 8 / i;  // NOLINT
       // NOLINTNEXTLINE
int main() {
 
       // verify no crashes on unmatched nolints.
       // NOLINTBEGIN
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider = addTidyChecks("bugprone-integer-division");
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "result of integer division used in a floating "
                              "point context; possible loss of precision"),
           diagSource(Diag::ClangTidy),
           diagName("bugprone-integer-division")))));
 }
 
 TEST(DiagnosticTest, ClangTidySystemMacro) {
TEST(DiagnosticTest, ClangTidySystemMacro) {
   )cpp";
 
   TU.ClangTidyProvider = addTidyChecks("bugprone-integer-division");
   std::string BadDivision = "result of integer division used in a floating "
                             "point context; possible loss of precision";
 
   // Expect to see warning from user macros, but not system macros.
   // This matches clang-tidy --system-headers=0 (the default).
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ifTidyChecks(
                   UnorderedElementsAre(Diag(Main.range("inline"), BadDivision),
                                        Diag(Main.range("user"), BadDivision))));
 }
 
 TEST(DiagnosticTest, ClangTidyWarningAsError) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double f = [[8]] / i; // error-ok
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider =
       addTidyChecks("bugprone-integer-division", "bugprone-integer-division");
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "result of integer division used in a floating "
                              "point context; possible loss of precision"),
           diagSource(Diag::ClangTidy), diagName("bugprone-integer-division"),
           diagSeverity(DiagnosticsEngine::Error)))));
 }
 
 TidyProvider addClangArgs(std::vector<llvm::StringRef> ExtraArgs,
TEST(DiagnosticTest, ClangTidyEnablesClangWarning) {
   TestTU TU = TestTU::withCode(Main.code());
   // This is always emitted as a clang warning, not a clang-tidy diagnostic.
   auto UnusedFooWarning =
       AllOf(Diag(Main.range(), "unused function 'foo'"),
             diagName("-Wunused-function"), diagSource(Diag::Clang),
             diagSeverity(DiagnosticsEngine::Warning));
 
   // Check the -Wunused warning isn't initially on.
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 
   // We enable warnings based on clang-tidy extra args, if the matching
   // clang-diagnostic- is there.
   TU.ClangTidyProvider =
       addClangArgs({"-Wunused"}, "clang-diagnostic-unused-function");
-  EXPECT_THAT(*TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning));
+  EXPECT_THAT(TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning));
 
   // clang-diagnostic-* is acceptable
   TU.ClangTidyProvider = addClangArgs({"-Wunused"}, "clang-diagnostic-*");
-  EXPECT_THAT(*TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning));
+  EXPECT_THAT(TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning));
   // And plain * (may turn on other checks too).
   TU.ClangTidyProvider = addClangArgs({"-Wunused"}, "*");
-  EXPECT_THAT(*TU.build().getDiagnostics(), Contains(UnusedFooWarning));
+  EXPECT_THAT(TU.build().getDiagnostics(), Contains(UnusedFooWarning));
   // And we can explicitly exclude a category too.
   TU.ClangTidyProvider = addClangArgs(
       {"-Wunused"}, "clang-diagnostic-*,-clang-diagnostic-unused-function");
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 
   // Without the exact check specified, the warnings are not enabled.
   TU.ClangTidyProvider = addClangArgs({"-Wunused"}, "clang-diagnostic-unused");
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 
   // We don't respect other args.
   TU.ClangTidyProvider = addClangArgs({"-Wunused", "-Dfoo=bar"},
                                       "clang-diagnostic-unused-function");
-  EXPECT_THAT(*TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning))
+  EXPECT_THAT(TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning))
       << "Not unused function 'bar'!";
 
   // -Werror doesn't apply to warnings enabled by clang-tidy extra args.
   TU.ExtraArgs = {"-Werror"};
   TU.ClangTidyProvider =
       addClangArgs({"-Wunused"}, "clang-diagnostic-unused-function");
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(diagSeverity(DiagnosticsEngine::Warning)));
 
   // But clang-tidy extra args won't *downgrade* errors to warnings either.
   TU.ExtraArgs = {"-Wunused", "-Werror"};
   TU.ClangTidyProvider =
       addClangArgs({"-Wunused"}, "clang-diagnostic-unused-function");
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(diagSeverity(DiagnosticsEngine::Error)));
 
   // FIXME: we're erroneously downgrading the whole group, this should be Error.
   TU.ExtraArgs = {"-Wunused-function", "-Werror"};
   TU.ClangTidyProvider =
       addClangArgs({"-Wunused"}, "clang-diagnostic-unused-label");
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(diagSeverity(DiagnosticsEngine::Warning)));
 
   // This looks silly, but it's the typical result if a warning is enabled by a
   // high-level .clang-tidy file and disabled by a low-level one.
   TU.ExtraArgs = {};
   TU.ClangTidyProvider = addClangArgs({"-Wunused", "-Wno-unused"},
                                       "clang-diagnostic-unused-function");
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 
   // Overriding only works in the proper order.
   TU.ClangTidyProvider =
       addClangArgs({"-Wunused"}, {"clang-diagnostic-unused-function"});
-  EXPECT_THAT(*TU.build().getDiagnostics(), SizeIs(1));
+  EXPECT_THAT(TU.build().getDiagnostics(), SizeIs(1));
 
   // More specific vs less-specific: match clang behavior
   TU.ClangTidyProvider = addClangArgs({"-Wunused", "-Wno-unused-function"},
                                       {"clang-diagnostic-unused-function"});
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
   TU.ClangTidyProvider = addClangArgs({"-Wunused-function", "-Wno-unused"},
                                       {"clang-diagnostic-unused-function"});
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 
   // We do allow clang-tidy config to disable warnings from the compile
   // command. It's unclear this is ideal, but it's hard to avoid.
   TU.ExtraArgs = {"-Wunused"};
   TU.ClangTidyProvider = addClangArgs({"-Wno-unused"}, {});
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 }
 
 TEST(DiagnosticTest, LongFixMessages) {
   // We limit the size of printed code.
   Annotations Source(R"cpp(
     int main() {
       // error-ok
       int somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier;
       [[omereallyreallyreallyreallyreallyreallyreallyreallylongidentifier]]= 10;
     }
   )cpp");
   TestTU TU = TestTU::withCode(Source.code());
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(withFix(Fix(
           Source.range(),
           "somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier",
           "change 'omereallyreallyreallyreallyreallyreallyreallyreall…' to "
           "'somereallyreallyreallyreallyreallyreallyreallyreal…'"))));
   // Only show changes up to a first newline.
   Source = Annotations(R"cpp(
     // error-ok
     int main() {
       int ident;
       [[ide\
 n]] = 10; // error-ok
     }
   )cpp");
   TU.Code = std::string(Source.code());
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(withFix(
                   Fix(Source.range(), "ident", "change 'ide\\…' to 'ident'"))));
 }
 
 TEST(DiagnosticTest, NewLineFixMessage) {
   Annotations Source("int a;[[]]");
   TestTU TU = TestTU::withCode(Source.code());
   TU.ExtraArgs = {"-Wnewline-eof"};
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(withFix((Fix(Source.range(), "\n", "insert '\\n'")))));
 }
 
 TEST(DiagnosticTest, ClangTidySuppressionCommentTrumpsWarningAsError) {
   Annotations Main(R"cpp(
     int main() {
       int i = 3;
       double f = [[8]] / i;  // NOLINT
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider =
       addTidyChecks("bugprone-integer-division", "bugprone-integer-division");
-  EXPECT_THAT(*TU.build().getDiagnostics(), UnorderedElementsAre());
+  EXPECT_THAT(TU.build().getDiagnostics(), UnorderedElementsAre());
 }
 
 TEST(DiagnosticTest, ClangTidyNoLiteralDataInMacroToken) {
   Annotations Main(R"cpp(
     #define SIGTERM 15
     using pthread_t = int;
     int pthread_kill(pthread_t thread, int sig);
     int func() {
       pthread_t thread;
       return pthread_kill(thread, 0);
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider = addTidyChecks("bugprone-bad-signal-to-kill-thread");
-  EXPECT_THAT(*TU.build().getDiagnostics(), UnorderedElementsAre()); // no-crash
+  EXPECT_THAT(TU.build().getDiagnostics(), UnorderedElementsAre()); // no-crash
 }
 
 TEST(DiagnosticTest, ElseAfterReturnRange) {
   Annotations Main(R"cpp(
     int foo(int cond) {
     if (cond == 1) {
       return 42;
     } [[else]] if (cond == 2) {
       return 43;
     }
     return 44;
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider = addTidyChecks("llvm-else-after-return");
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ifTidyChecks(ElementsAre(
                   Diag(Main.range(), "do not use 'else' after 'return'"))));
 }
 
 TEST(DiagnosticTest, ClangTidySelfContainedDiags) {
   Annotations Main(R"cpp($MathHeader[[]]
     struct Foo{
       int A, B;
TEST(DiagnosticTest, ClangTidySelfContainedDiags) {
   // Again in clang-tidy only the include directive would be emitted for the
   // first warning. However we need the include attaching for both warnings.
   clangd::Fix ExpectedDFix;
   ExpectedDFix.Message = "variable 'D' is not initialized";
   ExpectedDFix.Edits.push_back(TextEdit{Main.range("DFix"), " = NAN"});
   ExpectedDFix.Edits.push_back(
       TextEdit{Main.range("MathHeader"), "#include <math.h>\n\n"});
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(
           AllOf(Diag(Main.range("A"), "'A' should be initialized in a member "
                                       "initializer of the constructor"),
                 withFix(equalToFix(ExpectedAFix))),
           AllOf(Diag(Main.range("B"), "'B' should be initialized in a member "
                                       "initializer of the constructor"),
                 withFix(equalToFix(ExpectedBFix))),
           AllOf(Diag(Main.range("C"), "variable 'C' is not initialized"),
Annotations Test(R"cpp(
     #ifndef FOO
     #define FOO
       int a = [[b]]; // error-ok
     #else
       int x = y;
     #endif
     )cpp");
   EXPECT_THAT(
-      *TestTU::withCode(Test.code()).build().getDiagnostics(),
+      TestTU::withCode(Test.code()).build().getDiagnostics(),
       ElementsAre(Diag(Test.range(), "use of undeclared identifier 'b'")));
 }
 
 TEST(DiagnosticsTest, IgnoreVerify) {
   auto TU = TestTU::withCode(R"cpp(
     int a; // expected-error {{}}
   )cpp");
   TU.ExtraArgs.push_back("-Xclang");
   TU.ExtraArgs.push_back("-verify");
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 }
 
 TEST(DiagnosticTest, IgnoreBEFilelistOptions) {
   auto TU = TestTU::withCode("");
   TU.ExtraArgs.push_back("-Xclang");
   for (const auto *DisableOption :
        {"-fsanitize-ignorelist=null", "-fprofile-list=null",
         "-fxray-always-instrument=null", "-fxray-never-instrument=null",
         "-fxray-attr-list=null"}) {
     TU.ExtraArgs.push_back(DisableOption);
-    EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+    EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
     TU.ExtraArgs.pop_back();
   }
 }
 
 // Recursive main-file include is diagnosed, and doesn't crash.
 TEST(DiagnosticsTest, RecursivePreamble) {
   auto TU = TestTU::withCode(R"cpp(
     #include "foo.h" // error-ok
     int symbol;
   )cpp");
   TU.Filename = "foo.h";
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(diagName("pp_including_mainfile_in_preamble")));
   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
 }
 
 // Recursive main-file include with #pragma once guard is OK.
 TEST(DiagnosticsTest, RecursivePreamblePragmaOnce) {
   auto TU = TestTU::withCode(R"cpp(
     #pragma once
     #include "foo.h"
     int symbol;
   )cpp");
   TU.Filename = "foo.h";
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               Not(Contains(diagName("pp_including_mainfile_in_preamble"))));
   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
 }
 
 // Recursive main-file include with #ifndef guard should be OK.
 // However, it's not yet recognized (incomplete at end of preamble).
 TEST(DiagnosticsTest, RecursivePreambleIfndefGuard) {
   auto TU = TestTU::withCode(R"cpp(
     #ifndef FOO
     #define FOO
     #include "foo.h" // error-ok
     int symbol;
     #endif
   )cpp");
   TU.Filename = "foo.h";
   // FIXME: should be no errors here.
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(diagName("pp_including_mainfile_in_preamble")));
   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
 }
 
 TEST(DiagnosticsTest, PreambleWithPragmaAssumeNonnull) {
   auto TU = TestTU::withCode(R"cpp(
 #pragma clang assume_nonnull begin
 void foo(int *x);
 #pragma clang assume_nonnull end
 )cpp");
   auto AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
+  EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
   const auto *X = cast<FunctionDecl>(findDecl(AST, "foo")).getParamDecl(0);
   ASSERT_TRUE(X->getOriginalType()->getNullability() ==
               NullabilityKind::NonNull);
 }
 
 TEST(DiagnosticsTest, PreambleHeaderWithBadPragmaAssumeNonnull) {
   Annotations Header(R"cpp(
 #pragma clang assume_nonnull begin  // error-ok
 void foo(int *X);
 )cpp");
   auto TU = TestTU::withCode(R"cpp(
 #include "foo.h"  // unterminated assume_nonnull should not affect bar.
 void bar(int *Y);
 )cpp");
   TU.AdditionalFiles = {{"foo.h", std::string(Header.code())}};
   auto AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               ElementsAre(diagName("pp_eof_in_assume_nonnull")));
   const auto *X = cast<FunctionDecl>(findDecl(AST, "foo")).getParamDecl(0);
   ASSERT_TRUE(X->getOriginalType()->getNullability() ==
               NullabilityKind::NonNull);
   const auto *Y = cast<FunctionDecl>(findDecl(AST, "bar")).getParamDecl(0);
   ASSERT_FALSE(Y->getOriginalType()->getNullability());
 }
 
 TEST(DiagnosticsTest, InsideMacros) {
   Annotations Test(R"cpp(
     #define TEN 10
     #define RET(x) return x + 10
 
     int* foo() {
       RET($foo[[0]]); // error-ok
     }
     int* bar() {
       return $bar[[TEN]];
     }
     )cpp");
-  EXPECT_THAT(*TestTU::withCode(Test.code()).build().getDiagnostics(),
+  EXPECT_THAT(TestTU::withCode(Test.code()).build().getDiagnostics(),
               ElementsAre(Diag(Test.range("foo"),
                                "cannot initialize return object of type "
                                "'int *' with an rvalue of type 'int'"),
                           Diag(Test.range("bar"),
                                "cannot initialize return object of type "
                                "'int *' with an rvalue of type 'int'")));
 }
 
 TEST(DiagnosticsTest, NoFixItInMacro) {
   Annotations Test(R"cpp(
     #define Define(name) void name() {}
 
     [[Define]](main) // error-ok
   )cpp");
   auto TU = TestTU::withCode(Test.code());
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
                                 Not(withFix(_)))));
 }
 
 TEST(DiagnosticsTest, PragmaSystemHeader) {
   Annotations Test("#pragma clang [[system_header]]\n");
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(), "#pragma system_header ignored in main file"))));
   TU.Filename = "TestTU.h";
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 }
 
 TEST(ClangdTest, MSAsm) {
   // Parsing MS assembly tries to use the target MCAsmInfo, which we don't link.
   // We used to crash here. Now clang emits a diagnostic, which we filter out.
   llvm::InitializeAllTargetInfos(); // As in ClangdMain
   auto TU = TestTU::withCode("void fn() { __asm { cmp cl,64 } }");
   TU.ExtraArgs = {"-fms-extensions"};
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 }
 
 TEST(DiagnosticsTest, ToLSP) {
   URIForFile MainFile =
       URIForFile::canonicalize(testPath("foo/bar/main.cpp"), "");
   URIForFile HeaderFile =
       URIForFile::canonicalize(testPath("foo/bar/header.h"), "");
 
std::vector<std::pair<llvm::StringRef, llvm::StringRef>> Tests{
       {"-Wdelete-incomplete", "void f() { [[delete]] x; }"},
       {"dereference_incomplete_type",
        R"cpp(void f() { asm("" : "=r"([[*]]x)::); })cpp"},
   };
   for (auto Case : Tests) {
     Annotations Main(Case.second);
     TU.Code = Main.code().str() + "\n // error-ok";
     EXPECT_THAT(
-        *TU.build().getDiagnostics(),
+        TU.build().getDiagnostics(),
         ElementsAre(AllOf(diagName(Case.first), hasRange(Main.range()),
                           withFix(Fix(Range{}, "#include \"x.h\"\n",
                                       "Include \"x.h\" for symbol ns::X")))))
         << Case.second;
   }
 }
 
 TEST(IncludeFixerTest, IncompleteEnum) {
TEST(IncludeFixerTest, IncompleteEnum) {
   std::vector<std::pair<llvm::StringRef, llvm::StringRef>> Tests{
       {"incomplete_enum", "enum class X : int; using enum [[X]];"},
       {"underlying_type_of_incomplete_enum",
        "[[__underlying_type]](enum X) i;"},
   };
   for (auto Case : Tests) {
     Annotations Main(Case.second);
     TU.Code = Main.code().str() + "\n // error-ok";
-    EXPECT_THAT(*TU.build().getDiagnostics(),
+    EXPECT_THAT(TU.build().getDiagnostics(),
                 Contains(AllOf(diagName(Case.first), hasRange(Main.range()),
                                withFix(Fix(Range{}, "#include \"x.h\"\n",
                                            "Include \"x.h\" for symbol X")))))
         << Case.second;
   }
 }
 
 TEST(IncludeFixerTest, NoSuggestIncludeWhenNoDefinitionInHeader) {
int main() {
   Sym.IncludeHeaders.emplace_back("\"x.h\"", 1, Symbol::Include);
 
   SymbolSlab::Builder Slab;
   Slab.insert(Sym);
   auto Index =
       MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
   TU.ExternalIndex = Index.get();
 
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Test.range("base"), "base class has incomplete type"),
                   Diag(Test.range("access"),
                        "member access into incomplete type 'ns::X'")));
 }
 
 TEST(IncludeFixerTest, Typo) {
   Annotations Test(R"cpp(// error-ok
using Type = ns::$template[[Foo]]<int>;
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
       {SymbolWithHeader{"ns::X", "unittest:///x.h", "\"x.h\""},
        SymbolWithHeader{"Global", "unittest:///global.h", "\"global.h\""},
        SymbolWithHeader{"ns::Foo", "unittest:///foo.h", "\"foo.h\""}});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       UnorderedElementsAre(
           AllOf(Diag(Test.range("unqualified1"), "unknown type name 'X'"),
                 diagName("unknown_typename"),
                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Include \"x.h\" for symbol ns::X"))),
           Diag(Test.range("unqualified2"), "use of undeclared identifier 'X'"),
           AllOf(Diag(Test.range("qualified1"),
                      "no type named 'X' in namespace 'ns'"),

 )cpp");
   auto Index = buildIndexWithSymbol(
       {SymbolWithHeader{"X", "unittest:///x.h", "\"x.h\""},
        SymbolWithHeader{"ns::X", "unittest:///ns.h", "\"x.h\""}});
   TU.ExternalIndex = Index.get();
   // FIXME: -fms-compatibility (which is default on windows) breaks the
   // ns::X cases when the namespace is undeclared. Find out why!
   TU.ExtraArgs = {"-fno-ms-compatibility"};
-  EXPECT_THAT(*TU.build().getDiagnostics(), Each(withFix(_)));
+  EXPECT_THAT(TU.build().getDiagnostics(), Each(withFix(_)));
 }
 
 TEST(IncludeFixerTest, MultipleMatchedSymbols) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace na {
 namespace nb {
 void foo() {
   $unqualified[[X]] x;
 }
 }
 }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
       {SymbolWithHeader{"na::X", "unittest:///a.h", "\"a.h\""},
        SymbolWithHeader{"na::nb::X", "unittest:///b.h", "\"b.h\""}});
   TU.ExternalIndex = Index.get();
 
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Test.range("unqualified"), "unknown type name 'X'"),
                   diagName("unknown_typename"),
                   withFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
                               "Include \"a.h\" for symbol na::X"),
                           Fix(Test.range("insert"), "#include \"b.h\"\n",
                               "Include \"b.h\" for symbol na::nb::X")))));
 }
 
 TEST(IncludeFixerTest, NoCrashMemberAccess) {
   Annotations Test(R"cpp(// error-ok
     struct X { int  xyz; };
     void g() { X x; x.$[[xy]]; }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"na::X", "unittest:///a.h", "\"a.h\""});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       UnorderedElementsAre(Diag(Test.range(), "no member named 'xy' in 'X'")));
 }
 
 TEST(IncludeFixerTest, UseCachedIndexResults) {
   // As index results for the identical request are cached, more than 5 fixes
   // are generated.
   Annotations Test(R"cpp(// error-ok
 $insert[[]]void foo() {

 }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index =
       buildIndexWithSymbol(SymbolWithHeader{"X", "unittest:///a.h", "\"a.h\""});
   TU.ExternalIndex = Index.get();
 
   auto Parsed = TU.build();
-  for (const auto &D : *Parsed.getDiagnostics()) {
+  for (const auto &D : Parsed.getDiagnostics()) {
     if (D.Fixes.size() != 1) {
       ADD_FAILURE() << "D.Fixes.size() != 1";
       continue;
     }
     EXPECT_EQ(D.Fixes[0].Message, std::string("Include \"a.h\" for symbol X"));
   }
 }
 
 TEST(IncludeFixerTest, UnresolvedNameAsSpecifier) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
 }
 void g() {  ns::$[[scope]]::X_Y();  }
   )cpp");
   TestTU TU;
   TU.Code = std::string(Test.code());
   // FIXME: Figure out why this is needed and remove it, PR43662.
   TU.ExtraArgs.push_back("-fno-ms-compatibility");
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"ns::scope::X_Y", "unittest:///x.h", "\"x.h\""});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       UnorderedElementsAre(
           AllOf(Diag(Test.range(), "no member named 'scope' in namespace 'ns'"),
                 diagName("no_member"),
                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Include \"x.h\" for symbol ns::scope::X_Y")))));
 }
 
 TEST(IncludeFixerTest, UnresolvedSpecifierWithSemaCorrection) {
void f() {
   // FIXME: Figure out why this is needed and remove it, PR43662.
   TU.ExtraArgs.push_back("-fno-ms-compatibility");
   auto Index = buildIndexWithSymbol(
       {SymbolWithHeader{"clang::clangd::X", "unittest:///x.h", "\"x.h\""},
        SymbolWithHeader{"clang::clangd::ns::Y", "unittest:///y.h", "\"y.h\""}});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       UnorderedElementsAre(
           AllOf(Diag(Test.range("q1"), "use of undeclared identifier 'clangd'; "
                                        "did you mean 'clang'?"),
                 diagName("undeclared_var_use_suggest"),
                 withFix(_, // change clangd to clang
                         Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Include \"x.h\" for symbol clang::clangd::X"))),
           AllOf(Diag(Test.range("x"), "no type named 'X' in namespace 'clang'"),
namespace c {
   b::$[[X]] x;
 }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"a::X", "unittest:///x.h", "\"x.h\""});
   TU.ExternalIndex = Index.get();
 
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Test.range(), "no type named 'X' in namespace 'a'"),
                   diagName("typename_nested_not_found"),
                   withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                               "Include \"x.h\" for symbol a::X")))));
 }
 
 TEST(IncludeFixerTest, NoCrashOnTemplateInstantiations) {
Annotations Test(R"cpp(
     };
   )cpp");
 
   auto TU = TestTU::withCode(Test.code());
   auto Index = buildIndexWithSymbol({});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(Diag(Test.range(), "use of undeclared identifier 'a'")));
 }
 
 TEST(IncludeFixerTest, HeaderNamedInDiag) {
   Annotations Test(R"cpp(
     $insert[[]]int main() {
       [[printf]]("");
     }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.ExtraArgs = {"-xc", "-std=c99",
                   "-Wno-error=implicit-function-declaration"};
   auto Index = buildIndexWithSymbol({});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(), "call to undeclared library function 'printf' "
                              "with type 'int (const char *, ...)'; ISO C99 "
                              "and later do not support implicit function "
                              "declarations"),
           withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
                       "Include <stdio.h> for symbol printf")))));
 
   TU.ExtraArgs = {"-xc", "-std=c89"};
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(), "implicitly declaring library function 'printf' "
                              "with type 'int (const char *, ...)'"),
           withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
                       "Include <stdio.h> for symbol printf")))));
 }
 
 TEST(IncludeFixerTest, CImplicitFunctionDecl) {
TEST(IncludeFixerTest, CImplicitFunctionDecl) {
 
   SymbolSlab::Builder Slab;
   Slab.insert(Sym);
   auto Index =
       MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ElementsAre(AllOf(
           Diag(Test.range(),
                "call to undeclared function 'foo'; ISO C99 and later do not "
                "support implicit function declarations"),
           withFix(Fix(Range{}, "#include \"foo.h\"\n",
                       "Include \"foo.h\" for symbol foo")))));
 
   TU.ExtraArgs = {"-std=c89", "-Wall"};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(AllOf(
                   Diag(Test.range(), "implicit declaration of function 'foo'"),
                   withFix(Fix(Range{}, "#include \"foo.h\"\n",
                               "Include \"foo.h\" for symbol foo")))));
 }
 
 TEST(DiagsInHeaders, DiagInsideHeader) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header("[[no_type_spec]]; // error-ok");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(), "in included file: a type specifier is "
                                      "required for all declarations"),
                   withNote(Diag(Header.range(), "error occurred here")))));
 }
 
 TEST(DiagsInHeaders, DiagInTransitiveInclude) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", "#include \"b.h\""},
                         {"b.h", "no_type_spec; // error-ok"}};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(Diag(Main.range(),
                                         "in included file: a type specifier is "
                                         "required for all declarations")));
 }
 
 TEST(DiagsInHeaders, DiagInMultipleHeaders) {
   Annotations Main(R"cpp(
     #include $a[["a.h"]]
     #include $b[["b.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", "no_type_spec; // error-ok"},
                         {"b.h", "no_type_spec; // error-ok"}};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range("a"), "in included file: a type specifier is "
                                         "required for all declarations"),
                   Diag(Main.range("b"), "in included file: a type specifier is "
                                         "required for all declarations")));
 }
 
 TEST(DiagsInHeaders, PreferExpansionLocation) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     #include "b.h"
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {
       {"a.h", "#include \"b.h\"\n"},
       {"b.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               Contains(Diag(Main.range(), "in included file: a type specifier "
                                           "is required for all declarations")));
 }
 
 TEST(DiagsInHeaders, PreferExpansionLocationMacros) {
   Annotations Main(R"cpp(
     #define X
     #include "a.h"
     #undef X
     #include [["b.h"]]
     void foo() {})cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {
       {"a.h", "#include \"c.h\"\n"},
       {"b.h", "#include \"c.h\"\n"},
       {"c.h", "#ifndef X\n#define X\nno_type_spec; // error-ok\n#endif"}};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(Diag(Main.range(),
                                         "in included file: a type specifier is "
                                         "required for all declarations")));
 }
 
 TEST(DiagsInHeaders, LimitDiagsOutsideMainFile) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
TU.AdditionalFiles = {{"a.h", "#include \"c.h\"\n"},
       no_type_spec_4;
       no_type_spec_5;
       no_type_spec_6;
       no_type_spec_7;
       no_type_spec_8;
       no_type_spec_9;
       no_type_spec_10;
       #endif)cpp"}};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(Diag(Main.range(),
                                         "in included file: a type specifier is "
                                         "required for all declarations")));
 }
 
 TEST(DiagsInHeaders, OnlyErrorOrFatal) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header(R"cpp(
     [[no_type_spec]]; // error-ok
     int x = 5/0;)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(), "in included file: a type specifier is "
                                      "required for all declarations"),
                   withNote(Diag(Header.range(), "error occurred here")))));
 }
 
 TEST(DiagsInHeaders, OnlyDefaultErrorOrFatal) {
   Annotations Main(R"cpp(
     #include [["a.h"]] // get unused "foo" warning when building preamble.
     )cpp");
   Annotations Header(R"cpp(
     namespace { void foo() {} }
     void func() {foo();} ;)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   // promote warnings to errors.
   TU.ExtraArgs = {"-Werror", "-Wunused"};
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 }
 
 TEST(DiagsInHeaders, FromNonWrittenSources) {
   Annotations Main(R"cpp(
     #include [["a.h"]]
     void foo() {})cpp");
   Annotations Header(R"cpp(
     int x = 5/0;
     int b = [[FOO]]; // error-ok)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
   TU.ExtraArgs = {"-DFOO=NOOO"};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(),
                        "in included file: use of undeclared identifier 'NOOO'"),
                   withNote(Diag(Header.range(), "error occurred here")))));
 }
 
 TEST(DiagsInHeaders, ErrorFromMacroExpansion) {
   Annotations Main(R"cpp(
   void bar() {
     int fo; // error-ok
     #include [["a.h"]]
   })cpp");
   Annotations Header(R"cpp(
   #define X foo
   X;)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(), "in included file: use of undeclared "
                                      "identifier 'foo'; did you mean 'fo'?")));
 }
 
 TEST(DiagsInHeaders, ErrorFromMacroArgument) {
   Annotations Main(R"cpp(
   void bar() {
     int fo; // error-ok
     #include [["a.h"]]
   })cpp");
   Annotations Header(R"cpp(
   #define X(arg) arg
   X(foo);)cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.AdditionalFiles = {{"a.h", std::string(Header.code())}};
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   Diag(Main.range(), "in included file: use of undeclared "
                                      "identifier 'foo'; did you mean 'fo'?")));
 }
 
 TEST(IgnoreDiags, FromNonWrittenInclude) {
   TestTU TU;
   TU.ExtraArgs.push_back("--include=a.h");
   TU.AdditionalFiles = {{"a.h", "void main();"}};
   // The diagnostic "main must return int" is from the header, we don't attempt
   // to render it in the main file as there is no written location there.
-  EXPECT_THAT(*TU.build().getDiagnostics(), UnorderedElementsAre());
+  EXPECT_THAT(TU.build().getDiagnostics(), UnorderedElementsAre());
 }
 
 TEST(ToLSPDiag, RangeIsInMain) {
   ClangdDiagnosticOptions Opts;
   clangd::Diag D;
   D.Range = {pos(1, 2), pos(3, 4)};
   D.Notes.emplace_back();
   Note &N = D.Notes.back();
TEST(ParsedASTTest, ModuleSawDiag) {
   FMS.add(std::make_unique<DiagModifierModule>());
 
   Annotations Code("[[test]]; /* error-ok */");
   TestTU TU;
   TU.Code = Code.code().str();
   TU.FeatureModules = &FMS;
 
   auto AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               testing::Contains(Diag(Code.range(), KDiagMsg.str())));
 }
 
 TEST(Preamble, EndsOnNonEmptyLine) {
   TestTU TU;
   TU.ExtraArgs = {"-Wnewline-eof"};
 
   {
     TU.Code = "#define FOO\n  void bar();\n";
     auto AST = TU.build();
-    EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
+    EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
   }
   {
     Annotations Code("#define FOO[[]]");
     TU.Code = Code.code().str();
     auto AST = TU.build();
     EXPECT_THAT(
-        *AST.getDiagnostics(),
+        AST.getDiagnostics(),
         testing::Contains(Diag(Code.range(), "no newline at end of file")));
   }
 }
 
 TEST(Diagnostics, Tags) {
   TestTU TU;
   TU.ExtraArgs = {"-Wunused", "-Wdeprecated"};
   Annotations Test(R"cpp(
   void bar() __attribute__((deprecated));
   void foo() {
     int $unused[[x]];
     $deprecated[[bar]]();
   })cpp");
   TU.Code = Test.code().str();
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   AllOf(Diag(Test.range("unused"), "unused variable 'x'"),
                         withTag(DiagnosticTag::Unnecessary)),
                   AllOf(Diag(Test.range("deprecated"), "'bar' is deprecated"),
                         withTag(DiagnosticTag::Deprecated))));
 
   Test = Annotations(R"cpp(
     $typedef[[typedef int INT]];
   )cpp");
   TU.Code = Test.code();
   TU.ClangTidyProvider = addTidyChecks("modernize-use-using");
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(
           AllOf(Diag(Test.range("typedef"), "use 'using' instead of 'typedef'"),
                 withTag(DiagnosticTag::Deprecated)))));
 }
 
 TEST(DiagnosticsTest, IncludeCleaner) {
   Annotations Test(R"cpp(
 $fix[[  $diag[[#include "unused.h"]]
]]
   Config Cfg;
   Cfg.Diagnostics.UnusedIncludes = Config::IncludesPolicy::Strict;
   // Set filtering.
   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(),
+      AST.getDiagnostics(),
       Contains(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();
+  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));
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
   Cfg.Diagnostics.SuppressAll = false;
   Cfg.Diagnostics.Suppress = {"unused-includes"};
   WithContextValue SuppressFilterWithCfg(Config::Key, std::move(Cfg));
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  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(
   /*error-ok*/
     void bar() {
       int x;
       $diag[[foo]]($fix[[]]x, 1);
     })cpp");
   TestTU TU;
   TU.Code = Source.code().str();
   TU.HeaderCode = Header.str();
   EXPECT_THAT(
-      *TU.build().getDiagnostics(),
+      TU.build().getDiagnostics(),
       UnorderedElementsAre(AllOf(
           Diag(Source.range("diag"), "no matching function for call to 'foo'"),
           withFix(Fix(Source.range("fix"), "&",
                       "candidate function not viable: no known conversion from "
                       "'int' to 'int *' for 1st argument; take the address of "
                       "the argument with &")))));
 }
 
 TEST(DiagnosticsTest, UnusedInHeader) {
   // Clang diagnoses unused static inline functions outside headers.
   auto TU = TestTU::withCode("static inline void foo(void) {}");
   TU.ExtraArgs.push_back("-Wunused-function");
   TU.Filename = "test.c";
-  EXPECT_THAT(*TU.build().getDiagnostics(),
+  EXPECT_THAT(TU.build().getDiagnostics(),
               ElementsAre(withID(diag::warn_unused_function)));
   // Sema should recognize a *.h file open in clangd as a header.
   // https://github.com/clangd/vscode-clangd/issues/360
   TU.Filename = "test.h";
-  EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
+  EXPECT_THAT(TU.build().getDiagnostics(), IsEmpty());
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

TEST(FeatureModulesTest, SuppressDiags) {
   FMS.add(std::make_unique<DiagModifierModule>());
 
   Annotations Code("[[test]]; /* error-ok */");
   TestTU TU;
   TU.Code = Code.code().str();
 
   {
     auto AST = TU.build();
-    EXPECT_THAT(*AST.getDiagnostics(), testing::Not(testing::IsEmpty()));
+    EXPECT_THAT(AST.getDiagnostics(), testing::Not(testing::IsEmpty()));
   }
 
   TU.FeatureModules = &FMS;
   {
     auto AST = TU.build();
-    EXPECT_THAT(*AST.getDiagnostics(), testing::IsEmpty());
+    EXPECT_THAT(AST.getDiagnostics(), testing::IsEmpty());
   }
 }
 
 TEST(FeatureModulesTest, BeforeExecute) {
   struct BeforeExecuteModule final : public FeatureModule {
     struct Listener : public FeatureModule::ASTListener {
       void beforeExecute(CompilerInstance &CI) override {
         CI.getPreprocessor().SetSuppressIncludeNotFoundError(true);
TestTU TU = TestTU::withCode(R"cpp(
 
     void foo() {
       #include "not_found_not_preamble.h"
     }
   )cpp");
 
   {
     auto AST = TU.build();
-    EXPECT_THAT(*AST.getDiagnostics(), testing::Not(testing::IsEmpty()));
+    EXPECT_THAT(AST.getDiagnostics(), testing::Not(testing::IsEmpty()));
   }
 
   TU.FeatureModules = &FMS;
   {
     auto AST = TU.build();
-    EXPECT_THAT(*AST.getDiagnostics(), testing::IsEmpty());
+    EXPECT_THAT(AST.getDiagnostics(), testing::IsEmpty());
   }
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

)cpp");
   TU.AdditionalFiles["module.h"] = R"cpp(
     typedef int foo;
 )cpp";
   TU.AdditionalFiles["m.modulemap"] = R"modulemap(
     module M {
       header "module.h"
     }
 )modulemap";
-  EXPECT_TRUE(TU.build().getDiagnostics()->empty());
+  EXPECT_TRUE(TU.build().getDiagnostics().empty());
 }
 
 TEST(Modules, Diagnostic) {
   // Produce a diagnostic while building an implicit module. Use
   // -fmodules-strict-decluse, but any non-silenced diagnostic will do.
   TestTU TU = TestTU::withCode(R"cpp(
     /*error-ok*/
     #include "modular.h"

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

TEST(ParsedASTTest, PatchesAdditionalIncludes) {
   EXPECT_THAT(EmptyPreamble->Includes.MainFileIncludes, IsEmpty());
 
   // Now build an AST using empty preamble and ensure patched includes worked.
   TU.Code = ModifiedContents.str();
   Inputs = TU.inputs(FS);
   auto PatchedAST = ParsedAST::build(testPath("foo.cpp"), Inputs, std::move(CI),
                                      {}, EmptyPreamble);
   ASSERT_TRUE(PatchedAST);
-  ASSERT_FALSE(PatchedAST->getDiagnostics());
 
   // Ensure source location information is correct, including resolved paths.
   EXPECT_THAT(PatchedAST->getIncludeStructure().MainFileIncludes,
               testing::Pointwise(
                   eqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
   // Ensure file proximity signals are correct.
   auto &SM = PatchedAST->getSourceManager();
   auto &FM = SM.getFileManager();
TEST(ParsedASTTest, HeaderGuardsSelfInclude) {
   TU.ImplicitHeaderGuard = false;
   TU.Filename = "self.h";
 
   TU.Code = R"cpp(
     #include "self.h" // error-ok
     ;
   )cpp";
   auto AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               ElementsAre(diag("recursively when building a preamble")));
   EXPECT_FALSE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     ;
     #include "self.h" // error-ok
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), ElementsAre(diag("nested too deeply")));
+  EXPECT_THAT(AST.getDiagnostics(), ElementsAre(diag("nested too deeply")));
   EXPECT_FALSE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     #pragma once
     #include "self.h"
     ;
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
+  EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
   EXPECT_TRUE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     #pragma once
     ;
     #include "self.h"
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
+  EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
   EXPECT_TRUE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     ;
     #pragma once
     #include "self.h"
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
+  EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
   EXPECT_TRUE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     #ifndef GUARD
     #define GUARD
     #include "self.h" // error-ok: FIXME, this would be nice to support
     #endif
     ;
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               ElementsAre(diag("recursively when building a preamble")));
   EXPECT_TRUE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     #ifndef GUARD
     #define GUARD
     ;
     #include "self.h"
     #endif
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
+  EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
   EXPECT_TRUE(mainIsGuarded(AST));
 
   // Guarded too late...
   TU.Code = R"cpp(
     #include "self.h" // error-ok
     #ifndef GUARD
     #define GUARD
     ;
     #endif
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               ElementsAre(diag("recursively when building a preamble")));
   EXPECT_FALSE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     #include "self.h" // error-ok
     ;
     #ifndef GUARD
     #define GUARD
     #endif
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               ElementsAre(diag("recursively when building a preamble")));
   EXPECT_FALSE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     ;
     #ifndef GUARD
     #define GUARD
     #include "self.h"
     #endif
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
+  EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
   EXPECT_FALSE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     #include "self.h" // error-ok
     #pragma once
     ;
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               ElementsAre(diag("recursively when building a preamble")));
   EXPECT_TRUE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     #include "self.h" // error-ok
     ;
     #pragma once
   )cpp";
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               ElementsAre(diag("recursively when building a preamble")));
   EXPECT_TRUE(mainIsGuarded(AST));
 }
 
 // Tests how we handle common idioms for splitting a header-only library
 // into interface and implementation files (e.g. *.h vs *.inl).
 // These files mutually include each other, and need careful handling of include
 // guards (which interact with preambles).
TEST(ParsedASTTest, HeaderGuardsImplIface) {
   TU.ExtraArgs.push_back("-xc++-header");
 
   // Editing the interface file, which is include guarded (easy case).
   // We mostly get this right via PP if we don't recognize the include guard.
   TU.Filename = "iface.h";
   TU.Code = guard(Interface);
   TU.AdditionalFiles = {{"impl.h", Implementation}};
   auto AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
+  EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
   EXPECT_TRUE(mainIsGuarded(AST));
   // Slightly harder: the `#pragma once` is part of the preamble, and we
   // need to transfer it to the main file's HeaderFileInfo.
   TU.Code = once(Interface);
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), IsEmpty());
+  EXPECT_THAT(AST.getDiagnostics(), IsEmpty());
   EXPECT_TRUE(mainIsGuarded(AST));
 
   // Editing the implementation file, which is not include guarded.
   TU.Filename = "impl.h";
   TU.Code = Implementation;
   TU.AdditionalFiles = {{"iface.h", guard(Interface)}};
   AST = TU.build();
   // The diagnostic is unfortunate in this case, but correct per our model.
   // Ultimately the include is skipped and the code is parsed correctly though.
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               ElementsAre(diag("in included file: main file cannot be included "
                                "recursively when building a preamble")));
   EXPECT_FALSE(mainIsGuarded(AST));
   // Interface is pragma once guarded, same thing.
   TU.AdditionalFiles = {{"iface.h", once(Interface)}};
   AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(),
+  EXPECT_THAT(AST.getDiagnostics(),
               ElementsAre(diag("in included file: main file cannot be included "
                                "recursively when building a preamble")));
   EXPECT_FALSE(mainIsGuarded(AST));
 }
 
 TEST(ParsedASTTest, DiscoversPragmaMarks) {
   TestTU TU;
   TU.AdditionalFiles["Header.h"] = R"(

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

for (const auto &Case : Cases) {
     const auto ExpectedBounds =
         Lexer::ComputePreamble(Case.Modified, *CI->getLangOpts());
     EXPECT_EQ(PP.modifiedBounds().Size, ExpectedBounds.Size);
     EXPECT_EQ(PP.modifiedBounds().PreambleEndsAtStartOfLine,
               ExpectedBounds.PreambleEndsAtStartOfLine);
   }
 }
 
-TEST(PreamblePatch, DropsDiagnostics) {
-  llvm::StringLiteral Code = "#define FOO\nx;/* error-ok */";
-  // First check that this code generates diagnostics.
-  EXPECT_THAT(*TestTU::withCode(Code).build().getDiagnostics(),
-              testing::Not(testing::IsEmpty()));
-  // Ensure they are dropeed when a patched preamble is used.
-  EXPECT_FALSE(createPatchedAST("", Code)->getDiagnostics());
-}
-
 TEST(PreamblePatch, MacroLoc) {
   llvm::StringLiteral Baseline = "\n#define MACRO 12\nint num = MACRO;";
   llvm::StringLiteral Modified = " \n#define MACRO 12\nint num = MACRO;";
   auto AST = createPatchedAST(Baseline, Modified);
   ASSERT_TRUE(AST);
 }
 
 TEST(PreamblePatch, NoopWhenNotRequested) {
MATCHER_P(Diag, Range, "Diag at " + llvm::to_string(Range)) {
   return arg.Range == Range;
 }
 MATCHER_P2(Diag, Range, Name,
            "Diag at " + llvm::to_string(Range) + " = [" + Name + "]") {
   return arg.Range == Range && arg.Name == Name;
 }
 
 TEST(PreamblePatch, DiagnosticsFromMainASTAreInRightPlace) {
-  Config Cfg;
-  Cfg.Diagnostics.AllowStalePreamble = true;
-  WithContextValue WithCfg(Config::Key, std::move(Cfg));
-
   {
     Annotations Code("#define FOO");
     // Check with removals from preamble.
     Annotations NewCode("[[x]];/* error-ok */");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(),
+    EXPECT_THAT(AST->getDiagnostics(),
                 ElementsAre(Diag(NewCode.range(), "missing_type_specifier")));
   }
   {
     // Check with additions to preamble.
     Annotations Code("#define FOO");
     Annotations NewCode(R"(
 #define FOO
 #define BAR
 [[x]];/* error-ok */)");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(),
+    EXPECT_THAT(AST->getDiagnostics(),
                 ElementsAre(Diag(NewCode.range(), "missing_type_specifier")));
   }
 }
 
 TEST(PreamblePatch, DiagnosticsToPreamble) {
   Config Cfg;
-  Cfg.Diagnostics.AllowStalePreamble = true;
   Cfg.Diagnostics.UnusedIncludes = Config::IncludesPolicy::Strict;
   Cfg.Diagnostics.MissingIncludes = Config::IncludesPolicy::Strict;
   WithContextValue WithCfg(Config::Key, std::move(Cfg));
 
   llvm::StringMap<std::string> AdditionalFiles;
   AdditionalFiles["foo.h"] = "#pragma once";
   AdditionalFiles["bar.h"] = "#pragma once";
   {
     Annotations Code(R"(
 // Test comment
 [[#include "foo.h"]])");
     // Check with removals from preamble.
     Annotations NewCode(R"([[#  include "foo.h"]])");
     auto AST = createPatchedAST(Code.code(), NewCode.code(), AdditionalFiles);
-    EXPECT_THAT(*AST->getDiagnostics(),
+    EXPECT_THAT(AST->getDiagnostics(),
                 ElementsAre(Diag(NewCode.range(), "unused-includes")));
   }
   {
     // Check with additions to preamble.
     Annotations Code(R"(
 // Test comment
 [[#include "foo.h"]])");
     Annotations NewCode(R"(
 $bar[[#include "bar.h"]]
 // Test comment
 $foo[[#include "foo.h"]])");
     auto AST = createPatchedAST(Code.code(), NewCode.code(), AdditionalFiles);
     EXPECT_THAT(
-        *AST->getDiagnostics(),
+        AST->getDiagnostics(),
         UnorderedElementsAre(Diag(NewCode.range("bar"), "unused-includes"),
                              Diag(NewCode.range("foo"), "unused-includes")));
   }
   {
     Annotations Code("#define [[FOO]] 1\n");
     // Check ranges for notes.
     // This also makes sure we don't generate missing-include diagnostics
     // because macros are redefined in preamble-patch.
     Annotations NewCode(R"(#define BARXYZ 1
 #define $foo1[[FOO]] 1
 void foo();
 #define $foo2[[FOO]] 2)");
     auto AST = createPatchedAST(Code.code(), NewCode.code(), AdditionalFiles);
     EXPECT_THAT(
-        *AST->getDiagnostics(),
+        AST->getDiagnostics(),
         ElementsAre(AllOf(Diag(NewCode.range("foo2"), "-Wmacro-redefined"),
                           withNote(Diag(NewCode.range("foo1"))))));
   }
 }
 
 TEST(PreamblePatch, TranslatesDiagnosticsInPreamble) {
-  Config Cfg;
-  Cfg.Diagnostics.AllowStalePreamble = true;
-  WithContextValue WithCfg(Config::Key, std::move(Cfg));
-
   {
     // Check with additions to preamble.
     Annotations Code("#include [[<foo>]]");
     Annotations NewCode(R"(
 #define BAR
 #include [[<foo>]])");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(),
+    EXPECT_THAT(AST->getDiagnostics(),
                 ElementsAre(Diag(NewCode.range(), "pp_file_not_found")));
   }
   {
     // Check with removals from preamble.
     Annotations Code(R"(
 #define BAR
 #include [[<foo>]])");
     Annotations NewCode("#include [[<foo>]]");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(),
+    EXPECT_THAT(AST->getDiagnostics(),
                 ElementsAre(Diag(NewCode.range(), "pp_file_not_found")));
   }
   {
     // Drop line with diags.
     Annotations Code("#include [[<foo>]]");
     Annotations NewCode("#define BAR\n#define BAZ\n");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(), IsEmpty());
+    EXPECT_THAT(AST->getDiagnostics(), IsEmpty());
   }
   {
     // Picks closest line in case of multiple alternatives.
     Annotations Code("#include [[<foo>]]");
     Annotations NewCode(R"(
 #define BAR
 #include [[<foo>]]
 #define BAR
 #include <foo>)");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(),
+    EXPECT_THAT(AST->getDiagnostics(),
                 ElementsAre(Diag(NewCode.range(), "pp_file_not_found")));
   }
   {
     // Drop diag if line spelling has changed.
     Annotations Code("#include [[<foo>]]");
     Annotations NewCode(" # include <foo>");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(), IsEmpty());
+    EXPECT_THAT(AST->getDiagnostics(), IsEmpty());
   }
   {
     // Multiple lines.
     Annotations Code(R"(
 #define BAR
 #include [[<fo\
 o>]])");
     Annotations NewCode(R"(#include [[<fo\
 o>]])");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(),
+    EXPECT_THAT(AST->getDiagnostics(),
                 ElementsAre(Diag(NewCode.range(), "pp_file_not_found")));
   }
   {
     // Multiple lines with change.
     Annotations Code(R"(
 #define BAR
 #include <fox>
 #include [[<fo\
 o>]])");
     Annotations NewCode(R"(#include <fo\
 x>)");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(), IsEmpty());
+    EXPECT_THAT(AST->getDiagnostics(), IsEmpty());
   }
   {
     // Preserves notes.
     Annotations Code(R"(
 #define $note[[BAR]] 1
 #define $main[[BAR]] 2)");
     Annotations NewCode(R"(
 #define BAZ 0
 #define $note[[BAR]] 1
 #define BAZ 0
 #define $main[[BAR]] 2)");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
     EXPECT_THAT(
-        *AST->getDiagnostics(),
+        AST->getDiagnostics(),
         ElementsAre(AllOf(Diag(NewCode.range("main"), "-Wmacro-redefined"),
                           withNote(Diag(NewCode.range("note"))))));
   }
   {
     // Preserves diag without note.
     Annotations Code(R"(
 #define $note[[BAR]] 1
 #define $main[[BAR]] 2)");
     Annotations NewCode(R"(
 #define $main[[BAR]] 2)");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
     EXPECT_THAT(
-        *AST->getDiagnostics(),
+        AST->getDiagnostics(),
         ElementsAre(AllOf(Diag(NewCode.range("main"), "-Wmacro-redefined"),
                           Field(&Diag::Notes, IsEmpty()))));
   }
   {
     // Make sure orphaned notes are not promoted to diags.
     Annotations Code(R"(
 #define $note[[BAR]] 1
 #define $main[[BAR]] 2)");
     Annotations NewCode(R"(
 #define BAZ 0
 #define BAR 1)");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(), IsEmpty());
+    EXPECT_THAT(AST->getDiagnostics(), IsEmpty());
   }
   {
     Annotations Code(R"(
 #ifndef FOO
 #define FOO
 void foo();
 #endif)");
     // This code will emit a diagnostic for unterminated #ifndef (as stale
     // preamble has the conditional but main file doesn't terminate it).
     // We shouldn't emit any diagnotiscs (and shouldn't crash).
     Annotations NewCode("");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
-    EXPECT_THAT(*AST->getDiagnostics(), IsEmpty());
+    EXPECT_THAT(AST->getDiagnostics(), IsEmpty());
   }
   {
     Annotations Code(R"(
 #ifndef FOO
 #define FOO
 void foo();
 #endif)");
     // This code will emit a diagnostic for unterminated #ifndef (as stale
     // preamble has the conditional but main file doesn't terminate it).
     // We shouldn't emit any diagnotiscs (and shouldn't crash).
     // FIXME: Patch/ignore diagnostics in such cases.
     Annotations NewCode(R"(
 i[[nt]] xyz;
     )");
     auto AST = createPatchedAST(Code.code(), NewCode.code());
     EXPECT_THAT(
-        *AST->getDiagnostics(),
+        AST->getDiagnostics(),
         ElementsAre(Diag(NewCode.range(), "pp_unterminated_conditional")));
   }
 }
 
 MATCHER_P2(Mark, Range, Text, "") {
   return std::tie(arg.Rng, arg.Trivia) == std::tie(Range, Text);
 }
 
 TEST(PreamblePatch, MacroAndMarkHandling) {
-  Config Cfg;
-  Cfg.Diagnostics.AllowStalePreamble = true;
-  WithContextValue WithCfg(Config::Key, std::move(Cfg));
-
   {
     Annotations Code(R"cpp(
 #ifndef FOO
 #define FOO
 // Some comments
 #pragma mark XX
 #define BAR
 

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

 #include "Expand.inc"
         br^eak;
     }
   )cpp";
   Annotations Test(Case);
   auto TU = TestTU::withCode(Test.code());
   TU.AdditionalFiles["Expand.inc"] = "MACRO\n";
   auto AST = TU.build();
-  EXPECT_THAT(*AST.getDiagnostics(), ::testing::IsEmpty());
+  EXPECT_THAT(AST.getDiagnostics(), ::testing::IsEmpty());
   auto T = makeSelectionTree(Case, AST);
 
   EXPECT_EQ("BreakStmt", T.commonAncestor()->kind());
   EXPECT_EQ("WhileStmt", T.commonAncestor()->Parent->kind());
 }
 
 TEST(SelectionTest, IncludedFile) {
   const char *Case = R"cpp(

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

static Key<llvm::unique_function<void(PathRef File, std::vector<Diag>)>>
       DiagsCallbackKey;
 
   /// A diagnostics callback that should be passed to TUScheduler when it's used
   /// in updateWithDiags.
   static std::unique_ptr<ParsingCallbacks> captureDiags() {
     class CaptureDiags : public ParsingCallbacks {
     public:
       void onMainAST(PathRef File, ParsedAST &AST, PublishFn Publish) override {
-        reportDiagnostics(File, *AST.getDiagnostics(), Publish);
+        reportDiagnostics(File, AST.getDiagnostics(), Publish);
       }
 
       void onFailedAST(PathRef File, llvm::StringRef Version,
                        std::vector<Diag> Diags, PublishFn Publish) override {
         reportDiagnostics(File, Diags, Publish);
       }
 
     private:
       void reportDiagnostics(PathRef File, llvm::ArrayRef<Diag> Diags,
                              PublishFn Publish) {
         auto *D = Context::current().get(DiagsCallbackKey);
         if (!D)
           return;
         Publish([&]() {
-          const_cast<
-              llvm::unique_function<void(PathRef, std::vector<Diag>)> &> (*D)(
-              File, std::move(Diags));
+          const_cast<llvm::unique_function<void(PathRef, std::vector<Diag>)> &>(
+              *D)(File, Diags);
         });
       }
     };
     return std::make_unique<CaptureDiags>();
   }
 
   /// Schedule an update and call \p CB with the diagnostics it produces, if
   /// any. The TUScheduler should be created with captureDiags as a

 TEST_F(TUSchedulerTests, WantDiagnostics) {
   std::atomic<int> CallbackCount(0);
   {
     // To avoid a racy test, don't allow tasks to actually run on the worker
     // thread until we've scheduled them all.
     Notification Ready;
     TUScheduler S(CDB, optsForTest(), captureDiags());
     auto Path = testPath("foo.cpp");
-    updateWithDiags(S, Path, "", WantDiagnostics::Yes,
+    // Semicolons here and in the following inputs are significant. They ensure
+    // preamble stays the same across runs. Otherwise we might get multiple
+    // diagnostics callbacks, once with the stale preamble and another with the
+    // fresh preamble.
+    updateWithDiags(S, Path, ";", WantDiagnostics::Yes,
                     [&](std::vector<Diag>) { Ready.wait(); });
-    updateWithDiags(S, Path, "request diags", WantDiagnostics::Yes,
+    updateWithDiags(S, Path, ";request diags", WantDiagnostics::Yes,
                     [&](std::vector<Diag>) { ++CallbackCount; });
-    updateWithDiags(S, Path, "auto (clobbered)", WantDiagnostics::Auto,
+    updateWithDiags(S, Path, ";auto (clobbered)", WantDiagnostics::Auto,
                     [&](std::vector<Diag>) {
                       ADD_FAILURE()
                           << "auto should have been cancelled by auto";
                     });
-    updateWithDiags(S, Path, "request no diags", WantDiagnostics::No,
+    updateWithDiags(S, Path, ";request no diags", WantDiagnostics::No,
                     [&](std::vector<Diag>) {
                       ADD_FAILURE() << "no diags should not be called back";
                     });
-    updateWithDiags(S, Path, "auto (produces)", WantDiagnostics::Auto,
+    updateWithDiags(S, Path, ";auto (produces)", WantDiagnostics::Auto,
                     [&](std::vector<Diag>) { ++CallbackCount; });
     Ready.notify();
 
     ASSERT_TRUE(S.blockUntilIdle(timeoutSeconds(10)));
   }
   EXPECT_EQ(2, CallbackCount);
 }
 
TEST_F(TUSchedulerTests, NoopOnEmptyChanges) {
   ASSERT_FALSE(DoUpdate(SourceContents));
   ASSERT_EQ(S.fileStats().lookup(Source).ASTBuilds, 3u);
   ASSERT_EQ(S.fileStats().lookup(Source).PreambleBuilds, 2u);
 
   // Update to the compile commands should also cause a rebuild.
   CDB.ExtraClangFlags.push_back("-DSOMETHING");
   ASSERT_TRUE(DoUpdate(SourceContents));
   ASSERT_FALSE(DoUpdate(SourceContents));
-  ASSERT_EQ(S.fileStats().lookup(Source).ASTBuilds, 4u);
+  // This causes 2 AST builds always. We first build an AST with the stale
+  // preamble, and build a second AST once the fresh preamble is ready.
+  ASSERT_EQ(S.fileStats().lookup(Source).ASTBuilds, 5u);
   ASSERT_EQ(S.fileStats().lookup(Source).PreambleBuilds, 3u);
 }
 
 // We rebuild if a completely missing header exists, but not if one is added
 // on a higher-priority include path entry (for performance).
 // (Previously we wouldn't automatically rebuild when files were added).
 TEST_F(TUSchedulerTests, MissingHeader) {
   CDB.ExtraClangFlags.push_back("-I" + testPath("a"));
TEST_F(TUSchedulerTests, PublishWithStalePreamble) {
   private:
     std::condition_variable DiagsReceived;
     std::mutex DiagMu;
     std::vector<std::pair</*PreambleVersion*/ std::string,
                           /*MainFileVersion*/ std::string>>
         DiagVersions;
   };
 
-  Config Cfg;
-  Cfg.Diagnostics.AllowStalePreamble = true;
-  WithContextValue WithCfg(Config::Key, std::move(Cfg));
-
   DiagCollector Collector;
   Notification UnblockPreamble;
   auto DiagCallbacks = std::make_unique<BlockPreambleThread>(
       UnblockPreamble,
       [&Collector](ParsedAST &AST) { Collector.onDiagnostics(AST); });
   TUScheduler S(CDB, optsForTest(), std::move(DiagCallbacks));
   Path File = testPath("foo.cpp");
   auto BlockForDiags = [&](ParseInputs PI) {

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

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();
   }
-  assert(AST->getDiagnostics() &&
-         "TestTU should always build an AST with a fresh Preamble");
   // Check for error diagnostics and report gtest failures (unless expected).
   // This guards against accidental syntax errors silently subverting tests.
   // error-ok is awfully primitive - using clang -verify would be nicer.
   // Ownership and layering makes it pretty hard.
   bool ErrorOk = [&, this] {
     llvm::StringLiteral Marker = "error-ok";
     if (llvm::StringRef(Code).contains(Marker) ||
         llvm::StringRef(HeaderCode).contains(Marker))
       return true;
     for (const auto &KV : this->AdditionalFiles)
       if (llvm::StringRef(KV.second).contains(Marker))
         return true;
     return false;
   }();
   if (!ErrorOk) {
     // We always build AST with a fresh preamble in TestTU.
-    for (const auto &D : *AST->getDiagnostics())
+    for (const auto &D : AST->getDiagnostics())
       if (D.Severity >= DiagnosticsEngine::Error) {
         llvm::errs()
             << "TestTU failed to build (suppress with /*error-ok*/): \n"
             << D << "\n\nFor code:\n"
             << Code;
         std::abort(); // Stop after first error for simplicity.
       }
   }

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

TEST(TypeHierarchy, RecursiveHierarchyUnbounded) {
   )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   TU.ExtraArgs.push_back("-ftemplate-depth=10");
   auto AST = TU.build();
 
   // The compiler should produce a diagnostic for hitting the
   // template instantiation depth.
-  ASSERT_TRUE(!AST.getDiagnostics()->empty());
+  ASSERT_FALSE(AST.getDiagnostics().empty());
 
   // Make sure getTypeHierarchy() doesn't get into an infinite recursion.
   // The parent is reported as "S" because "S<0>" is an invalid instantiation.
   // We then iterate once more and find "S" again before detecting the
   // recursion.
   auto Result = getTypeHierarchy(AST, Source.points()[0], 0,
                                  TypeHierarchyDirection::Parents);
   ASSERT_THAT(Result, SizeIs(1));