[clangd] [WIP] [Not ready for review] Semantic highlighting

[nridge]

Summary

Done:

• Basic plumbing
• Encoding of semantic highlighting tokens into the protocol format
• Computation of (most) semantic highlightings given an AST
• Unit test suite (for implemented highlightings)

Remains to be done:

• Highlightings for macro definitions and macro invocations
• Some special highlightings like overloaded operators
• End-to-end test to exercise the protocol bits

[nridge]

Add [clangd] to title

[nik]

Some general notes regarding the current state of this patch as I was testing it with a language client:

• It still applies for current trunk, except for a *Tests* file.
• Note that a VersionedTextDocumentIdentifier has to be used, e.g. a "version" must be included in the response. This helped to get it working for now (not a proper fix):

--- clang-tools-extra/clangd/Protocol.cpp
+++ clang-tools-extra/clangd/Protocol.cpp
@@ -79,11 +79,11 @@ llvm::json::Value toJSON(const URIForFile &U) { return U.uri(); }
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const URIForFile &U) {
   return OS << U.uri();
 }
 
 llvm::json::Value toJSON(const TextDocumentIdentifier &R) {
-  return llvm::json::Object{{"uri", R.uri}};
+  return llvm::json::Object{{"uri", R.uri}, {"version", nullptr}};
 }
 
 bool fromJSON(const llvm::json::Value &Params, TextDocumentIdentifier &R) {
   llvm::json::ObjectMapper O(Params);
   return O && O.map("uri", R.uri);

[nridge]

Abandoning as all of the functionality in this prototype is now present in mainline (except for the ability to color declarations differently from references, which is blocked on a spec change as discussed in D66990).

clang-tools-extra/clangd/CMakeLists.txt

add_clang_library(clangDaemon
   Headers.cpp
   IncludeFixer.cpp
   JSONTransport.cpp
   Logger.cpp
   Protocol.cpp
   Quality.cpp
   RIFF.cpp
   Selection.cpp
+  SemanticHighlighting.cpp
   SourceCode.cpp
   Threading.cpp
   Trace.cpp
   TUScheduler.cpp
   URI.cpp
   XRefs.cpp
 
   index/Background.cpp

clang-tools-extra/clangd/ClangdLSPServer.h

 
 class SymbolIndex;
 
 /// This class exposes ClangdServer's capabilities via Language Server Protocol.
 ///
 /// MessageHandler binds the implemented LSP methods (e.g. onInitialize) to
 /// corresponding JSON-RPC methods ("initialize").
 /// The server also supports $/cancelRequest (MessageHandler provides this).
-class ClangdLSPServer : private DiagnosticsConsumer {
+class ClangdLSPServer : private DiagnosticsConsumer,
+                        private SemanticHighlightingConsumer {
 public:
   /// If \p CompileCommandsDir has a value, compile_commands.json will be
   /// loaded only from \p CompileCommandsDir. Otherwise, clangd will look
   /// for compile_commands.json in all parent directories of each file.
   /// If UseDirBasedCDB is false, compile commands are not read from disk.
   // FIXME: Clean up signature around CDBs.
   ClangdLSPServer(Transport &Transp, const FileSystemProvider &FSProvider,
                   const clangd::CodeCompleteOptions &CCOpts,
                   llvm::Optional<Path> CompileCommandsDir, bool UseDirBasedCDB,
                   llvm::Optional<OffsetEncoding> ForcedOffsetEncoding,
                   const ClangdServer::Options &Opts);
   ~ClangdLSPServer();
 
   /// Run LSP server loop, communicating with the Transport provided in the
   /// constructor. This method must not be executed more than once.
   ///
   /// \return Whether we shut down cleanly with a 'shutdown' -> 'exit' sequence.
   bool run();
 
 private:
   // Implement DiagnosticsConsumer.
   void onDiagnosticsReady(PathRef File, std::vector<Diag> Diagnostics) override;
   void onFileUpdated(PathRef File, const TUStatus &Status) override;
 
+  void onSemanticHighlightingReady(
+      PathRef File, std::vector<SemanticHighlightingToken> Tokens) override;
+
   // LSP methods. Notifications have signature void(const Params&).
   // Calls have signature void(const Params&, Callback<Response>).
   void onInitialize(const InitializeParams &, Callback<llvm::json::Value>);
   void onShutdown(const ShutdownParams &, Callback<std::nullptr_t>);
   void onSync(const NoParams &, Callback<std::nullptr_t>);
   void onDocumentDidOpen(const DidOpenTextDocumentParams &);
   void onDocumentDidChange(const DidChangeTextDocumentParams &);
   void onDocumentDidClose(const DidCloseTextDocumentParams &);

clang-tools-extra/clangd/ClangdLSPServer.cpp

 //===--- ClangdLSPServer.cpp - 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangdLSPServer.h"
 #include "Diagnostics.h"
 #include "Protocol.h"
+#include "SemanticHighlighting.h"
 #include "SourceCode.h"
 #include "Trace.h"
 #include "URI.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
void ClangdLSPServer::onInitialize(const InitializeParams &Params,
   if (const auto &Dir = Params.initializationOptions.compilationDatabasePath)
     CompileCommandsDir = Dir;
   if (UseDirBasedCDB)
     BaseCDB = llvm::make_unique<DirectoryBasedGlobalCompilationDatabase>(
         CompileCommandsDir);
   CDB.emplace(BaseCDB.get(), Params.initializationOptions.fallbackFlags,
               ClangdServerOpts.ResourceDir);
   Server.emplace(*CDB, FSProvider, static_cast<DiagnosticsConsumer &>(*this),
+                 static_cast<SemanticHighlightingConsumer &>(*this),
                  ClangdServerOpts);
   applyConfiguration(Params.initializationOptions.ConfigSettings);
 
   CCOpts.EnableSnippets = Params.capabilities.CompletionSnippets;
   DiagOpts.EmbedFixesInDiagnostics = Params.capabilities.DiagnosticFixes;
   DiagOpts.SendDiagnosticCategory = Params.capabilities.DiagnosticCategory;
   DiagOpts.EmitRelatedLocations =
       Params.capabilities.DiagnosticRelatedInformation;
llvm::json::Object Result{
             {"referencesProvider", true},
             {"executeCommandProvider",
              llvm::json::Object{
                  {"commands",
                   {ExecuteCommandParams::CLANGD_APPLY_FIX_COMMAND,
                    ExecuteCommandParams::CLANGD_APPLY_TWEAK}},
              }},
             {"typeHierarchyProvider", true},
-        }}}};
+            {"semanticHighlighting",
+             llvm::json::Object{
+                 {"scopes", getSemanticHighlightingScopes()}}}}}}};
   if (NegotiatedOffsetEncoding)
     Result["offsetEncoding"] = *NegotiatedOffsetEncoding;
   Reply(std::move(Result));
 }
 
 void ClangdLSPServer::onShutdown(const ShutdownParams &Params,
                                  Callback<std::nullptr_t> Reply) {
   // Do essentially nothing, just say we're ready to exit.
// Cache FixIts
     std::lock_guard<std::mutex> Lock(FixItsMutex);
     FixItsMap[File] = LocalFixIts;
   }
 
   // Send a notification to the LSP client.
   publishDiagnostics(URI, std::move(LSPDiagnostics));
 }
 
+void ClangdLSPServer::onSemanticHighlightingReady(
+    PathRef File, std::vector<SemanticHighlightingToken> Tokens) {
+  TextDocumentIdentifier TDI{URIForFile::canonicalize(File, /*TUPath=*/File)};
+  auto SHInfos = encodeSHTokens(Tokens);
+  notify(
+      "textDocument/semanticHighlighting",
+      llvm::json::Object{{"textDocument", TDI}, {"lines", std::move(SHInfos)}});
+}
+
 void ClangdLSPServer::onFileUpdated(PathRef File, const TUStatus &Status) {
   if (!SupportFileStatus)
     return;
   // FIXME: we don't emit "BuildingFile" and `RunningAction`, as these
   // two statuses are running faster in practice, which leads the UI constantly
   // changing, and doesn't provide much value. We may want to emit status at a
   // reasonable time interval (e.g. 0.5s).
   if (Status.Action.S == TUAction::BuildingFile ||

clang-tools-extra/clangd/ClangdServer.h

public:
   /// if compilation arguments changed on calls to forceReparse().
   ///
   /// After each parsing request finishes, ClangdServer reports diagnostics to
   /// \p DiagConsumer. Note that a callback to \p DiagConsumer happens on a
   /// worker thread. Therefore, instances of \p DiagConsumer must properly
   /// synchronize access to shared state.
   ClangdServer(const GlobalCompilationDatabase &CDB,
                const FileSystemProvider &FSProvider,
-               DiagnosticsConsumer &DiagConsumer, const Options &Opts);
+               DiagnosticsConsumer &DiagConsumer,
+               SemanticHighlightingConsumer &SHConsumer, const Options &Opts);
 
   /// Add a \p File to the list of tracked C++ files or update the contents if
   /// \p File is already tracked. Also schedules parsing of the AST for it on a
   /// separate thread. When the parsing is complete, DiagConsumer passed in
   /// constructor will receive onDiagnosticsReady callback.
   void addDocument(PathRef File, StringRef Contents,
                    WantDiagnostics WD = WantDiagnostics::Auto);
 

clang-tools-extra/clangd/ClangdServer.cpp

 #include <mutex>
 
 namespace clang {
 namespace clangd {
 namespace {
 
 // Update the FileIndex with new ASTs and plumb the diagnostics responses.
 struct UpdateIndexCallbacks : public ParsingCallbacks {
-  UpdateIndexCallbacks(FileIndex *FIndex, DiagnosticsConsumer &DiagConsumer)
-      : FIndex(FIndex), DiagConsumer(DiagConsumer) {}
+  UpdateIndexCallbacks(FileIndex *FIndex, DiagnosticsConsumer &DiagConsumer,
+                       SemanticHighlightingConsumer &SHConsumer)
+      : FIndex(FIndex), DiagConsumer(DiagConsumer), SHConsumer(SHConsumer) {}
 
   void onPreambleAST(PathRef Path, ASTContext &Ctx,
                      std::shared_ptr<clang::Preprocessor> PP,
                      const CanonicalIncludes &CanonIncludes) override {
     if (FIndex)
       FIndex->updatePreamble(Path, Ctx, std::move(PP), CanonIncludes);
   }
 
   void onMainAST(PathRef Path, ParsedAST &AST) override {
     if (FIndex)
       FIndex->updateMain(Path, AST);
   }
 
   void onDiagnostics(PathRef File, std::vector<Diag> Diags) override {
     DiagConsumer.onDiagnosticsReady(File, std::move(Diags));
   }
 
+  virtual void onSemanticHighlighting(
+      PathRef File, std::vector<SemanticHighlightingToken> Tokens) override {
+    SHConsumer.onSemanticHighlightingReady(File, Tokens);
+  }
+
   void onFileUpdated(PathRef File, const TUStatus &Status) override {
     DiagConsumer.onFileUpdated(File, Status);
   }
 
 private:
   FileIndex *FIndex;
   DiagnosticsConsumer &DiagConsumer;
+  SemanticHighlightingConsumer &SHConsumer;
 };
 } // namespace
 
 ClangdServer::Options ClangdServer::optsForTest() {
   ClangdServer::Options Opts;
   Opts.UpdateDebounce = std::chrono::steady_clock::duration::zero(); // Faster!
   Opts.StorePreamblesInMemory = true;
   Opts.AsyncThreadsCount = 4; // Consistent!
   return Opts;
 }
 
 ClangdServer::ClangdServer(const GlobalCompilationDatabase &CDB,
                            const FileSystemProvider &FSProvider,
                            DiagnosticsConsumer &DiagConsumer,
+                           SemanticHighlightingConsumer &SHConsumer,
                            const Options &Opts)
     : FSProvider(FSProvider),
       DynamicIdx(Opts.BuildDynamicSymbolIndex
                      ? new FileIndex(Opts.HeavyweightDynamicSymbolIndex)
                      : nullptr),
       ClangTidyOptProvider(Opts.ClangTidyOptProvider),
       SuggestMissingIncludes(Opts.SuggestMissingIncludes),
       WorkspaceRoot(Opts.WorkspaceRoot),
       // Pass a callback into `WorkScheduler` to extract symbols from a newly
       // parsed file and rebuild the file index synchronously each time an AST
       // is parsed.
       // FIXME(ioeric): this can be slow and we may be able to index on less
       // critical paths.
       WorkScheduler(CDB, Opts.AsyncThreadsCount, Opts.StorePreamblesInMemory,
-                    llvm::make_unique<UpdateIndexCallbacks>(DynamicIdx.get(),
-                                                            DiagConsumer),
+                    llvm::make_unique<UpdateIndexCallbacks>(
+                        DynamicIdx.get(), DiagConsumer, SHConsumer),
                     Opts.UpdateDebounce, Opts.RetentionPolicy) {
   // Adds an index to the stack, at higher priority than existing indexes.
   auto AddIndex = [&](SymbolIndex *Idx) {
     if (this->Index != nullptr) {
       MergedIdx.push_back(llvm::make_unique<MergedIndex>(Idx, this->Index));
       this->Index = MergedIdx.back().get();
     } else {
       this->Index = Idx;

clang-tools-extra/clangd/Protocol.h

struct Diagnostic {
 
   /// Clangd extension: code actions related to this diagnostic.
   /// Only with capability textDocument.publishDiagnostics.codeActionsInline.
   /// (These actions can also be obtained using textDocument/codeAction).
   llvm::Optional<std::vector<CodeAction>> codeActions;
 };
 llvm::json::Value toJSON(const Diagnostic &);
 
+/// Represents semantic highlighting information that has to be applied on a
+/// specific line of the text document.
+struct SemanticHighlightingInformation {
+  /// The zero-based line position in the text document.
+  int line;
+
+  /// A base64 encoded string representing every single highlighting character
+  /// with its start position, length, and the "lookup table" index of the
+  /// semantic highlighting TextMate scopes.
+  /// If empty, then no highlighted positions are available for the line.
+  llvm::Optional<std::string> tokens;
+};
+llvm::json::Value toJSON(const SemanticHighlightingInformation &);
+
 /// A LSP-specific comparator used to find diagnostic in a container like
 /// std:map.
 /// We only use the required fields of Diagnostic to do the comparsion to avoid
 /// any regression issues from LSP clients (e.g. VScode), see
 /// https://git.io/vbr29
 struct LSPDiagnosticCompare {
   bool operator()(const Diagnostic &LHS, const Diagnostic &RHS) const {
     return std::tie(LHS.range, LHS.message) < std::tie(RHS.range, RHS.message);

clang-tools-extra/clangd/Protocol.cpp

if (!O || !O.map("range", R.range) || !O.map("message", R.message))
     return false;
   O.map("severity", R.severity);
   O.map("category", R.category);
   O.map("code", R.code);
   O.map("source", R.source);
   return true;
 }
 
+llvm::json::Value toJSON(const SemanticHighlightingInformation &SHI) {
+  llvm::json::Object Result{{"line", SHI.line}};
+  if (SHI.tokens)
+    Result["tokens"] = *SHI.tokens;
+  return std::move(Result);
+}
+
 bool fromJSON(const llvm::json::Value &Params, CodeActionContext &R) {
   llvm::json::ObjectMapper O(Params);
   return O && O.map("diagnostics", R.diagnostics);
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Diagnostic &D) {
   OS << D.range << " [";
   switch (D.severity) {

clang-tools-extra/clangd/SemanticHighlighting.h

+//===--- SemanticHighlighting.h ----------------------------------*- C++-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_SEMANTIC_HIGHLIGHTING_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_SEMANTIC_HIGHLIGHTING_H
+
+#include "ClangdUnit.h"
+#include "Path.h"
+#include "Protocol.h"
+
+namespace clang {
+namespace clangd {
+
+enum class SemanticHighlightingKind : uint16_t {
+  Class,
+  Enum,
+  EnumClass,
+  Enumerator,
+  Field,
+  Function,
+  FunctionDeclaration,
+  GlobalVariable,
+  Label,
+  LocalVariable,
+  LocalVariableDeclaration,
+  Macro,
+  MacroDefinition,
+  Method,
+  MethodDeclaration,
+  Namespace,
+  ParameterVariable,
+  StaticField,
+  StaticMethod,
+  StaticMethodDeclaration,
+  TemplateParameter,
+  Typedef,
+  Special_LastKind,
+  // TODO: OverloadedOperator, VariablePassedByNonconstRef
+};
+
+/// Return the supported semantic highlighting scopes.
+/// Every top-level element of the returned array corresponds to
+/// one of the token kinds in SemanticHighlightingKind, and
+/// contains one or more TextMate scope names corresponding to
+/// that token kind.
+std::vector<std::vector<std::string>> getSemanticHighlightingScopes();
+
+struct SemanticHighlightingToken {
+  Range R;
+  SemanticHighlightingKind Kind;
+
+  friend bool operator==(const SemanticHighlightingToken &A,
+                         const SemanticHighlightingToken &B) {
+    return A.R == B.R && A.Kind == B.Kind;
+  }
+  friend bool operator<(const SemanticHighlightingToken &A,
+                        const SemanticHighlightingToken &B) {
+    return (A.R < B.R) || (A.R == B.R && A.Kind < B.Kind);
+  }
+};
+
+std::vector<SemanticHighlightingToken>
+computeSemanticHighlightings(ParsedAST &AST);
+
+class SemanticHighlightingConsumer {
+public:
+  virtual ~SemanticHighlightingConsumer() = default;
+
+  virtual void onSemanticHighlightingReady(
+      PathRef File, std::vector<SemanticHighlightingToken> Tokens) = 0;
+};
+
+/// Encode semantic highlighting tokens for an AST into the representation
+/// used in the wire protocol.
+std::vector<SemanticHighlightingInformation>
+encodeSHTokens(const std::vector<SemanticHighlightingToken> &Tokens);
+
+} // namespace clangd
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_SEMANTIC_HIGHLIGHTING_H

clang-tools-extra/clangd/SemanticHighlighting.cpp

+//===--- SemanticHighlighting.cpp --------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "SemanticHighlighting.h"
+
+#include "AST.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+
+namespace clang {
+namespace clangd {
+
+std::vector<std::vector<std::string>> getSemanticHighlightingScopes() {
+  // For now, just use one scope per token kind. The protocol supports
+  // multiple, expected to be arranged from most specific to least specific,
+  // which could be added later.
+  // TODO: Revise scope names to make consistent with other languages / editors?
+  return {
+      {"entity.name.class.cpp"},                      // Class
+      {"entity.name.enum.cpp"},                       // Enum
+      {"entity.name.enum.class.cpp"},                 // EnumClass
+      {"entity.name.enumerator.cpp"},                 // Enumerator
+      {"entity.name.variable.member.cpp"},            // Field
+      {"entity.name.function.cpp"},                   // Function
+      {"entity.name.function.declaration.cpp"},       // FunctionDeclaration
+      {"entity.name.variable.global.cpp"},            // GlobalVariable
+      {"entity.name.label.cpp"},                      // Label
+      {"entity.name.variable.local.cpp"},             // LocalVariable
+      {"entity.name.variable.local.declaration.cpp"}, // LocalVariableDeclaration
+      {"entity.name.macro.cpp"},                      // Macro
+      {"entity.name.macro.definition.cpp"},           // MacroDefinition
+      {"entity.name.function.member.cpp"},            // Method
+      {"entity.name.function.member.declaration.cpp"}, // MethodDeclaration
+      {"entity.name.namespace.cpp"},                   // Namespace
+      {"entity.name.variable.parameter.cpp"},          // ParameterVariable
+      {"entity.name.variable.member.static.cpp"},      // StaticField
+      {"entity.name.function.member.static.cpp"},      // StaticMethod
+      {"entity.name.function.member.static.declaration.cpp"}, // StaticMethodDeclaration
+      {"entity.name.templateparameter.cpp"}, // TemplateParameter
+      {"entity.name.typedef.cpp"},           // Typedef
+  };
+}
+
+namespace {
+
+Optional<SemanticHighlightingKind> classifyDecl(Decl *D, bool IsDeclaration) {
+  if (dyn_cast<ParmVarDecl>(D)) {
+    return SemanticHighlightingKind::ParameterVariable;
+  }
+  if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
+    if (VD->isStaticDataMember()) {
+      return SemanticHighlightingKind::StaticField;
+    }
+    if (VD->isLocalVarDecl()) {
+      return IsDeclaration ? SemanticHighlightingKind::LocalVariableDeclaration
+                           : SemanticHighlightingKind::LocalVariable;
+    }
+    return SemanticHighlightingKind::GlobalVariable;
+  }
+  if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) {
+    return SemanticHighlightingKind::Field;
+  }
+  if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
+    if (MD->isStatic()) {
+      return IsDeclaration ? SemanticHighlightingKind::StaticMethodDeclaration
+                           : SemanticHighlightingKind::StaticMethod;
+    }
+    return IsDeclaration ? SemanticHighlightingKind::MethodDeclaration
+                         : SemanticHighlightingKind::Method;
+  }
+  if (dyn_cast<FunctionDecl>(D)) {
+    return IsDeclaration ? SemanticHighlightingKind::FunctionDeclaration
+                         : SemanticHighlightingKind::Function;
+  }
+  if (dyn_cast<RecordDecl>(D)) {
+    return SemanticHighlightingKind::Class;
+  }
+  if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
+    return ED->isScoped() ? SemanticHighlightingKind::EnumClass
+                          : SemanticHighlightingKind::Enum;
+  }
+  if (dyn_cast<EnumConstantDecl>(D)) {
+    return SemanticHighlightingKind::Enumerator;
+  }
+  if (dyn_cast<TemplateTypeParmDecl>(D) ||
+      dyn_cast<NonTypeTemplateParmDecl>(D) ||
+      dyn_cast<TemplateTemplateParmDecl>(D)) {
+    return SemanticHighlightingKind::TemplateParameter;
+  }
+  if (dyn_cast<TypedefNameDecl>(D)) {
+    return SemanticHighlightingKind::Typedef;
+  }
+  if (dyn_cast<NamespaceDecl>(D)) {
+    return SemanticHighlightingKind::Namespace;
+  }
+  // TODO: Label, Macro, MacroDefinition.
+  return llvm::None;
+}
+
+bool isAnonymous(Decl *D) {
+  if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
+    return ND->getDeclName().isEmpty();
+  }
+  return false;
+}
+
+class SemanticHighlightingVisitor
+    : public RecursiveASTVisitor<SemanticHighlightingVisitor> {
+  using Base = RecursiveASTVisitor<SemanticHighlightingVisitor>;
+
+public:
+  SemanticHighlightingVisitor(ASTContext &Context) : Context{Context} {}
+
+  std::vector<SemanticHighlightingToken> collectTokens() {
+    // FIXME: Having to set the scope here is required to get the
+    // VariableTemplates test to pass. This is either a clangd bug or a clang
+    // AST bug.
+    // Context.setTraversalScope({Context.getTranslationUnitDecl()});
+
+    TraverseAST(Context);
+
+    // Deduplicate tokens.
+    // This takes care of avoiding duplicates in some cases that would be
+    // difficult to handle during the AST traversal itself, such as
+    // the template-name in the declaration of a class template specialization
+    // being traversed both as a Decl and as a TypeLoc.
+    std::sort(Tokens.begin(), Tokens.end());
+    auto Last = std::unique(Tokens.begin(), Tokens.end());
+    Tokens.erase(Last, Tokens.end());
+
+    return std::move(Tokens);
+  }
+
+  // RecursiveASTVisitor overrides
+  // TODO: We're probably missing some.
+
+  // Declarations
+  bool VisitNamedDecl(NamedDecl *ND) {
+    // Don't emit a highlighting for an empty name.
+    if (isAnonymous(ND)) {
+      return true;
+    }
+    if (auto Kind = classifyDecl(ND, /*IsDeclaration=*/true)) {
+      addToken(*Kind, findNameLoc(ND));
+    }
+    return true;
+  }
+
+  // Expressions
+  bool VisitDeclRefExpr(DeclRefExpr *E) {
+    return handleReference(E->getDecl(), E->getLocation());
+  }
+  bool VisitMemberExpr(MemberExpr *E) {
+    return handleReference(E->getMemberDecl(), E->getMemberLoc());
+  }
+
+  // Types
+  bool VisitTagTypeLoc(TagTypeLoc L) {
+    return handleReference(L.getDecl(), L.getNameLoc());
+  }
+  bool VisitTypedefTypeLoc(TypedefTypeLoc L) {
+    return handleReference(L.getTypedefNameDecl(), L.getNameLoc());
+  }
+  bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc L) {
+    // Color the template name. The visitor takes care of visiting the
+    // arguments.
+    // TODO: Could we do this via TraverseTemplateName?
+    //       Unclear how we would get the location.
+    auto TemplateNameLoc = L.getTemplateNameLoc();
+    if (TemplateDecl *TD =
+            L.getTypePtr()->getTemplateName().getAsTemplateDecl()) {
+      return handleReference(TD->getTemplatedDecl(), TemplateNameLoc);
+    }
+    // If dependent, fall back to Class.
+    addToken(SemanticHighlightingKind::Class, TemplateNameLoc);
+    return true;
+  }
+  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc L) {
+    return handleReference(L.getDecl(), L.getNameLoc());
+  }
+  bool VisitDependentNameTypeLoc(DependentNameTypeLoc L) {
+    // For now, assume it's a class.
+    // TODO: Perform heuristic resolution to try to make a better guess.
+    addToken(SemanticHighlightingKind::Class, L.getNameLoc());
+    return true;
+  }
+  bool VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc L) {
+    addToken(SemanticHighlightingKind::Class, L.getNameLoc());
+    return true;
+  }
+
+  // Other node types, only available via Traverse*()
+  bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLoc) {
+    if (NestedNameSpecifier *NNS = NNSLoc.getNestedNameSpecifier()) {
+      if (NNS->getKind() == NestedNameSpecifier::Namespace) {
+        addToken(SemanticHighlightingKind::Namespace,
+                 NNSLoc.getLocalBeginLoc());
+      } else if (NNS->getKind() == NestedNameSpecifier::Identifier) {
+        // This seems to occur when a nested-name-specifier has a
+        // dependent segment that can't be resolved to a type yet.
+        // Assume it resolves to a class.
+        // TODO: Perform heuristic resolution to try to make a better guess.
+        addToken(SemanticHighlightingKind::Class, NNSLoc.getLocalBeginLoc());
+      }
+    }
+    return Base::TraverseNestedNameSpecifierLoc(NNSLoc);
+  }
+  bool TraverseConstructorInitializer(CXXCtorInitializer *Init) {
+    addToken(SemanticHighlightingKind::Field, Init->getMemberLocation());
+    return Base::TraverseConstructorInitializer(Init);
+  }
+
+  // Dependent expressions
+  bool VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
+    addToken(SemanticHighlightingKind::Method, E->getNameLoc());
+    return true;
+  }
+  bool VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
+    addToken(E->getNamingClass() ? SemanticHighlightingKind::StaticMethod
+                                 : SemanticHighlightingKind::Function,
+             E->getNameLoc());
+    return true;
+  }
+  bool VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
+    // For now, assume it's a static field.
+    // TODO: Perform heuristic resolution to try to make a better guess.
+    addToken(SemanticHighlightingKind::StaticField, E->getLocation());
+    return true;
+  }
+  bool VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E) {
+    addToken(E->getQualifier() ? SemanticHighlightingKind::StaticField
+                               : SemanticHighlightingKind::Field,
+             E->getMemberLoc());
+    return true;
+  }
+  bool VisitSizeOfPackExpr(SizeOfPackExpr *E) {
+    addToken(SemanticHighlightingKind::TemplateParameter, E->getPackLoc());
+    return true;
+  }
+
+private:
+  ASTContext &Context;
+  std::vector<SemanticHighlightingToken> Tokens;
+
+  bool handleReference(Decl *D, SourceLocation Loc) {
+    // Don't emit a highlighting for an empty name.
+    if (!D || isAnonymous(D)) {
+      return true;
+    }
+    if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
+      // Don't emit a highlighting for an operator name.
+      // TODO: We probably do want to emit a highlighting in the case where
+      //       the "operator" token is used explicitly. Not sure how to
+      //       distinguish this case.
+      if (ND->getDeclName().getNameKind() == DeclarationName::CXXOperatorName) {
+        return true;
+      }
+    }
+    if (auto Kind = classifyDecl(D, /*IsDeclaration=*/false)) {
+      addToken(*Kind, Loc);
+    }
+    return true;
+  }
+
+  void addToken(SemanticHighlightingKind Kind, SourceLocation Loc) {
+    if (auto Range = toRange(Loc)) {
+      Tokens.push_back({*Range, Kind});
+    }
+  }
+
+  llvm::Optional<Range> toRange(SourceLocation Loc) {
+    // TODO: There is similar logic in declToSym() that could be factored out
+    // somewhere.
+    auto &SM = Context.getSourceManager();
+    if (!SM.isWrittenInMainFile(Loc)) {
+      return llvm::None;
+    }
+    return Range{
+        sourceLocToPosition(SM, Loc),
+        sourceLocToPosition(
+            SM, Lexer::getLocForEndOfToken(Loc, 0, SM, Context.getLangOpts()))};
+  }
+};
+
+} // namespace
+
+std::vector<SemanticHighlightingToken>
+computeSemanticHighlightings(ParsedAST &AST) {
+  SemanticHighlightingVisitor Visitor{AST.getASTContext()};
+  return Visitor.collectTokens();
+}
+
+namespace {
+
+// Encode binary data into base64.
+// This was copied from compiler-rt/lib/fuzzer/FuzzerUtil.cpp.
+// TOOD: Factor this out into llvm/Support?
+std::string encodeBase64(const llvm::SmallVectorImpl<char> &U) {
+  static const char Table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                              "abcdefghijklmnopqrstuvwxyz"
+                              "0123456789+/";
+  std::string Res;
+  size_t i;
+  for (i = 0; i + 2 < U.size(); i += 3) {
+    uint32_t x = (U[i] << 16) + (U[i + 1] << 8) + U[i + 2];
+    Res += Table[(x >> 18) & 63];
+    Res += Table[(x >> 12) & 63];
+    Res += Table[(x >> 6) & 63];
+    Res += Table[x & 63];
+  }
+  if (i + 1 == U.size()) {
+    uint32_t x = (U[i] << 16);
+    Res += Table[(x >> 18) & 63];
+    Res += Table[(x >> 12) & 63];
+    Res += "==";
+  } else if (i + 2 == U.size()) {
+    uint32_t x = (U[i] << 16) + (U[i + 1] << 8);
+    Res += Table[(x >> 18) & 63];
+    Res += Table[(x >> 12) & 63];
+    Res += Table[(x >> 6) & 63];
+    Res += "=";
+  }
+  return Res;
+}
+
+// The protocol format requires integers to be encoded as big-endian.
+void write32be(uint32_t I, llvm::raw_ostream &OS) {
+  char Buf[4];
+  llvm::support::endian::write32be(Buf, I);
+  OS.write(Buf, sizeof(Buf));
+}
+void write16be(uint16_t I, llvm::raw_ostream &OS) {
+  char Buf[2];
+  llvm::support::endian::write16be(Buf, I);
+  OS.write(Buf, sizeof(Buf));
+}
+
+std::string
+encodeSHTokensForLine(const std::vector<SemanticHighlightingToken> &Tokens) {
+  llvm::SmallVector<char, 128> BinaryData;
+  llvm::raw_svector_ostream OS(BinaryData);
+  for (size_t i = 0; i < Tokens.size(); ++i) {
+    const auto &Token = Tokens[i];
+    // The caller has checked that the token's range is valid and on a single
+    // line.
+    uint32_t start = Token.R.start.character;
+    uint16_t length = Token.R.end.character - Token.R.start.character;
+    uint16_t scope = static_cast<uint16_t>(Token.Kind);
+    write32be(start, OS);
+    write16be(length, OS);
+    write16be(scope, OS);
+  }
+  return encodeBase64(BinaryData);
+}
+
+} // namespace
+
+std::vector<SemanticHighlightingInformation>
+encodeSHTokens(const std::vector<SemanticHighlightingToken> &Tokens) {
+  // Group the tokens by line.
+  llvm::DenseMap<int, std::vector<SemanticHighlightingToken>> TokensPerLine;
+  for (const auto &Token : Tokens) {
+    int Line = Token.R.start.line;
+    if (Token.R.end.line != Line) {
+      // Token's range spans multiple lines. The protocol does not support this.
+      // TODO: Give some sort of error or warning.
+      continue;
+    }
+    if (Token.R.end.character < Token.R.start.character) {
+      // Token range is invalid. TODO: Give an error or warning.
+      continue;
+    }
+    TokensPerLine[Line].push_back(Token);
+  }
+
+  // Encode each line's tokens into the protocol representation.
+  std::vector<SemanticHighlightingInformation> Infos;
+  for (const auto &Line : TokensPerLine) {
+    SemanticHighlightingInformation Info;
+    Info.line = Line.first;
+    Info.tokens = encodeSHTokensForLine(Line.second);
+    Infos.push_back(std::move(Info));
+  }
+
+  return Infos;
+}
+
+} // namespace clangd
+} // namespace clang

clang-tools-extra/clangd/TUScheduler.h

 //===--- TUScheduler.h -------------------------------------------*-C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_TUSCHEDULER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_TUSCHEDULER_H
 
 #include "ClangdUnit.h"
 #include "Function.h"
 #include "GlobalCompilationDatabase.h"
+#include "SemanticHighlighting.h"
 #include "Threading.h"
 #include "index/CanonicalIncludes.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <future>
 
 namespace clang {
public:
   /// etc. Clients are expected to process only the AST nodes from the main file
   /// in this callback (obtained via ParsedAST::getLocalTopLevelDecls) to obtain
   /// optimal performance.
   virtual void onMainAST(PathRef Path, ParsedAST &AST) {}
 
   /// Called whenever the diagnostics for \p File are produced.
   virtual void onDiagnostics(PathRef File, std::vector<Diag> Diags) {}
 
+  /// Called whenever the semantic highlightings for \p File are produced.
+  virtual void
+  onSemanticHighlighting(PathRef File,
+                         std::vector<SemanticHighlightingToken> Tokens) {}
+
   /// Called whenever the TU status is updated.
   virtual void onFileUpdated(PathRef File, const TUStatus &Status) {}
 };
 
 /// Handles running tasks for ClangdServer and managing the resources (e.g.,
 /// preambles and ASTs) for opened files.
 /// TUScheduler is not thread-safe, only one thread should be providing updates
 /// and scheduling tasks.

clang-tools-extra/clangd/TUScheduler.cpp

 // - If any reads of the AST are scheduled, we start building the AST
 //   immediately.
 
 #include "TUScheduler.h"
 #include "Cancellation.h"
 #include "Compiler.h"
 #include "GlobalCompilationDatabase.h"
 #include "Logger.h"
+#include "SemanticHighlighting.h"
 #include "Trace.h"
 #include "index/CanonicalIncludes.h"
 #include "clang/Frontend/CompilerInvocation.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Path.h"
auto Task = [=]() mutable {
     // spam us with updates.
     // Note *AST can still be null if buildAST fails.
     if (*AST) {
       {
         std::lock_guard<std::mutex> Lock(DiagsMu);
         if (ReportDiagnostics)
           Callbacks.onDiagnostics(FileName, (*AST)->getDiagnostics());
       }
+
+      // Compute semantic highlighting.
+      // TODO: Should this be inside the `DiagsMu` critical section,
+      //       or in a critical section of its own?
+      auto Highlightings = computeSemanticHighlightings(**AST);
+      Callbacks.onSemanticHighlighting(FileName, Highlightings);
+
       trace::Span Span("Running main AST callback");
       Callbacks.onMainAST(FileName, **AST);
       DiagsWereReported = true;
     }
     // Stash the AST in the cache for further use.
     IdleASTs.put(this, std::move(*AST));
   };
   startTask(TaskName, std::move(Task), WantDiags);

clang-tools-extra/clangd/unittests/CMakeLists.txt

add_unittest(ClangdUnitTests ClangdTests
   IndexActionTests.cpp
   IndexTests.cpp
   JSONTransportTests.cpp
   PrintASTTests.cpp
   QualityTests.cpp
   RenameTests.cpp
   RIFFTests.cpp
   SelectionTests.cpp
+  SemanticHighlightingTests.cpp
   SerializationTests.cpp
   SourceCodeTests.cpp
   SymbolCollectorTests.cpp
   SymbolInfoTests.cpp
   SyncAPI.cpp
   TUSchedulerTests.cpp
   TestFS.cpp
   TestIndex.cpp

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

 class ClangdVFSTest : public ::testing::Test {
 protected:
   std::string parseSourceAndDumpAST(
       PathRef SourceFileRelPath, llvm::StringRef SourceContents,
       std::vector<std::pair<PathRef, llvm::StringRef>> ExtraFiles = {},
       bool ExpectErrors = false) {
     MockFSProvider FS;
     ErrorCheckingDiagConsumer DiagConsumer;
+    NoopSemanticHighlightingConsumer SHConsumer;
     MockCompilationDatabase CDB;
-    ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+    ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                        ClangdServer::optsForTest());
     for (const auto &FileWithContents : ExtraFiles)
       FS.Files[testPath(FileWithContents.first)] = FileWithContents.second;
 
     auto SourceFilename = testPath(SourceFileRelPath);
     Server.addDocument(SourceFilename, SourceContents);
     auto Result = dumpASTWithoutMemoryLocs(Server, SourceFilename);
     EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
     EXPECT_EQ(ExpectErrors, DiagConsumer.hadErrorInLastDiags());
parseSourceAndDumpAST("foo.cpp", SourceContents, {{"foo.h", ""}},
                         /*ExpectErrors=*/true);
   parseSourceAndDumpAST("foo.cpp", SourceContents, {{"foo.h", "int a;"}},
                         /*ExpectErrors=*/false);
 }
 
 TEST_F(ClangdVFSTest, Reparse) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   const auto SourceContents = R"cpp(
 #include "foo.h"
 int b = a;
 )cpp";
 
   auto FooCpp = testPath("foo.cpp");
 
)cpp";
 
   EXPECT_EQ(DumpParse1, DumpParse2);
   EXPECT_NE(DumpParse1, DumpParseEmpty);
 }
 
 TEST_F(ClangdVFSTest, ReparseOnHeaderChange) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   const auto SourceContents = R"cpp(
 #include "foo.h"
 int b = a;
 )cpp";
 
   auto FooCpp = testPath("foo.cpp");
   auto FooH = testPath("foo.h");
TEST_F(ClangdVFSTest, PropagatesContexts) {
   struct DiagConsumer : public DiagnosticsConsumer {
     void onDiagnosticsReady(PathRef File,
                             std::vector<Diag> Diagnostics) override {
       Got = Context::current().getExisting(Secret);
     }
     int Got;
   } DiagConsumer;
   MockCompilationDatabase CDB;
+  NoopSemanticHighlightingConsumer SHConsumer;
 
   // Verify that the context is plumbed to the FS provider and diagnostics.
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
   {
     WithContextValue Entrypoint(Secret, 42);
     Server.addDocument(testPath("foo.cpp"), "void main(){}");
   }
   ASSERT_TRUE(Server.blockUntilIdleForTest());
   EXPECT_EQ(FS.Got, 42);
   EXPECT_EQ(DiagConsumer.Got, 42);
 }
 
 // Only enable this test on Unix
 #ifdef LLVM_ON_UNIX
 TEST_F(ClangdVFSTest, SearchLibDir) {
   // Checks that searches for GCC installation is done through vfs.
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
   CDB.ExtraClangFlags.insert(CDB.ExtraClangFlags.end(),
                              {"-xc++", "-target", "x86_64-linux-unknown",
                               "-m64", "--gcc-toolchain=/randomusr",
                               "-stdlib=libstdc++"});
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   // Just a random gcc version string
   SmallString<8> Version("4.9.3");
 
   // A lib dir for gcc installation
   SmallString<64> LibDir("/randomusr/lib/gcc/x86_64-linux-gnu");
   llvm::sys::path::append(LibDir, Version);
 
)cpp";
   runAddDocument(Server, FooCpp, SourceContentsWithError);
   EXPECT_TRUE(DiagConsumer.hadErrorInLastDiags());
 }
 #endif // LLVM_ON_UNIX
 
 TEST_F(ClangdVFSTest, ForceReparseCompileCommand) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto FooCpp = testPath("foo.cpp");
   const auto SourceContents1 = R"cpp(
 template <class T>
 struct foo { T x; };
 )cpp";
   const auto SourceContents2 = R"cpp(
 template <class T>
)cpp";
   EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());
   runAddDocument(Server, FooCpp, SourceContents2);
   EXPECT_FALSE(DiagConsumer.hadErrorInLastDiags());
 }
 
 TEST_F(ClangdVFSTest, ForceReparseCompileCommandDefines) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto FooCpp = testPath("foo.cpp");
   const auto SourceContents = R"cpp(
 #ifdef WITH_ERROR
 this
 #endif
 
 int main() { return 0; }
)cpp");
 
   Annotations BazSource(R"cpp(
 int hello;
 )cpp");
 
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   MultipleErrorCheckingDiagConsumer DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto FooCpp = testPath("foo.cpp");
   auto BarCpp = testPath("bar.cpp");
   auto BazCpp = testPath("baz.cpp");
 
   FS.Files[FooCpp] = "";
   FS.Files[BarCpp] = "";
   FS.Files[BazCpp] = "";
)cpp");
   Locations = runLocateSymbolAt(Server, FooCpp, FooSource.point());
   EXPECT_TRUE(bool(Locations));
   EXPECT_THAT(*Locations, ElementsAre(DeclAt(FooCpp, FooSource.range("two"))));
 }
 
 TEST_F(ClangdVFSTest, MemoryUsage) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   Path FooCpp = testPath("foo.cpp");
   const auto SourceContents = R"cpp(
 struct Something {
   int method();
 };
 )cpp";
   Path BarCpp = testPath("bar.cpp");
)cpp";
   Server.removeDocument(BarCpp);
   ASSERT_TRUE(Server.blockUntilIdleForTest());
   EXPECT_THAT(Server.getUsedBytesPerFile(), IsEmpty());
 }
 
 TEST_F(ClangdVFSTest, InvalidCompileCommand) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
 
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto FooCpp = testPath("foo.cpp");
   // clang cannot create CompilerInvocation if we pass two files in the
   // CompileCommand. We pass the file in ExtraFlags once and CDB adds another
   // one in getCompileCommand().
   CDB.ExtraClangFlags.push_back(FooCpp);
 
   // Clang can't parse command args in that case, but we shouldn't crash.
)cpp";
   };
 
   std::vector<RequestStats> ReqStats;
   ReqStats.reserve(FilesCount);
   for (unsigned FileIndex = 0; FileIndex < FilesCount; ++FileIndex)
     ReqStats.emplace_back();
 
   TestDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   {
     MockCompilationDatabase CDB;
-    ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+    ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                        ClangdServer::optsForTest());
 
     // Prepare some random distributions for the test.
     std::random_device RandGen;
 
     std::uniform_int_distribution<unsigned> FileIndexDist(0, FilesCount - 1);
     // Pass a text that contains compiler errors to addDocument in about 20% of
     // all requests.
     std::bernoulli_distribution ShouldHaveErrorsDist(0.2);
for (unsigned I = 0; I < FilesCount; ++I) {
     ASSERT_LE(Stats[I].HitsWithErrors, ReqStats[I].RequestsWithErrors);
     ASSERT_LE(Stats[I].HitsWithoutErrors, ReqStats[I].RequestsWithoutErrors);
   }
 }
 
 TEST_F(ClangdVFSTest, CheckSourceHeaderSwitch) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto SourceContents = R"cpp(
   #include "foo.h"
   int b = a;
   )cpp";
 
   auto FooCpp = testPath("foo.cpp");
   auto FooH = testPath("foo.h");
)cpp";
   auto FooCpp = testPath("foo.cpp");
   MockFSProvider FS;
   FS.Files[FooCpp] = "";
 
   std::promise<void> StartSecondPromise;
   std::future<void> StartSecond = StartSecondPromise.get_future();
 
   NoConcurrentAccessDiagConsumer DiagConsumer(std::move(StartSecondPromise));
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
   Server.addDocument(FooCpp, SourceContentsWithErrors);
   StartSecond.wait();
   Server.addDocument(FooCpp, SourceContentsWithoutErrors);
   ASSERT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
   ASSERT_EQ(DiagConsumer.Count, 2); // Sanity check - we actually ran both?
 }
 
 TEST_F(ClangdVFSTest, FormatCode) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto Path = testPath("foo.cpp");
   std::string Code = R"cpp(
 #include "x.h"
 #include "y.h"
 
 void f(  )  {}
 )cpp";
)cpp";
   auto Changed = tooling::applyAllReplacements(Code, *Replaces);
   EXPECT_TRUE(static_cast<bool>(Changed));
   EXPECT_EQ(Expected, *Changed);
 }
 
 TEST_F(ClangdVFSTest, ChangedHeaderFromISystem) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto SourcePath = testPath("source/foo.cpp");
   auto HeaderPath = testPath("headers/foo.h");
   FS.Files[HeaderPath] = "struct X { int bar; };";
   Annotations Code(R"cpp(
     #include "foo.h"
 
     int main() {
public:
     // If relative paths are used, they are resolved with testPath().
     llvm::StringMap<std::string> Files;
     llvm::StringMap<unsigned> &CountStats;
   };
 
   llvm::StringMap<unsigned> CountStats;
   ListenStatsFSProvider FS(CountStats);
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto SourcePath = testPath("foo.cpp");
   auto HeaderPath = testPath("foo.h");
   FS.Files[HeaderPath] = "struct TestSym {};";
   Annotations Code(R"cpp(
     #include "foo.h"
 
     int main() {
TEST(ClangdTests, PreambleVFSStatCache) {
   EXPECT_THAT(Completions,
               ElementsAre(Field(&CodeCompletion::Name, "TestSym")));
 }
 #endif
 
 TEST_F(ClangdVFSTest, FlagsWithPlugins) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
   CDB.ExtraClangFlags = {
       "-Xclang",
       "-add-plugin",
       "-Xclang",
       "random-plugin",
   };
   OverlayCDB OCDB(&CDB);
-  ClangdServer Server(OCDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(OCDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto FooCpp = testPath("foo.cpp");
   const auto SourceContents = "int main() { return 0; }";
   FS.Files[FooCpp] = FooCpp;
   Server.addDocument(FooCpp, SourceContents);
   auto Result = dumpASTWithoutMemoryLocs(Server, FooCpp);
   EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for diagnostics";
   EXPECT_NE(Result, "<no-ast>");
 }
 
 TEST_F(ClangdVFSTest, FallbackWhenPreambleIsNotReady) {
   MockFSProvider FS;
   ErrorCheckingDiagConsumer DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto FooCpp = testPath("foo.cpp");
-   Annotations Code(R"cpp(
     namespace ns { int xyz; }
     using namespace ns;
     int main() {
        xy^
     })cpp");
   FS.Files[FooCpp] = FooCpp;
 
   auto Opts = clangd::CodeCompleteOptions();
public:
     std::vector<std::string> ExtraClangFlags;
 
   private:
     Notification &CanReturnCommand;
   };
 
   Notification CanReturnCommand;
   DelayedCompilationDatabase CDB(CanReturnCommand);
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto FooCpp = testPath("foo.cpp");
   Annotations Code(R"cpp(
     namespace ns { int xyz; }
     using namespace ns;
     int main() {
        xy^
     })cpp");

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

 // If IndexSymbols is non-empty, an index will be built and passed to opts.
 CodeCompleteResult completions(llvm::StringRef Text,
                                std::vector<Symbol> IndexSymbols = {},
                                clangd::CodeCompleteOptions Opts = {},
                                PathRef FilePath = "foo.cpp") {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
   return completions(Server, Text, std::move(IndexSymbols), std::move(Opts),
                      FilePath);
 }
 
 // Builds a server and runs code completion.
 // If IndexSymbols is non-empty, an index will be built and passed to opts.
 CodeCompleteResult completionsNoCompile(llvm::StringRef Text,
                                         std::vector<Symbol> IndexSymbols = {},
TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
   MockCompilationDatabase CDB;
   std::string Subdir = testPath("sub");
   std::string SearchDirArg = (Twine("-I") + Subdir).str();
   CDB.ExtraClangFlags = {SearchDirArg.c_str()};
   std::string BarHeader = testPath("sub/bar.h");
   FS.Files[BarHeader] = "";
 
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
   auto BarURI = URI::create(BarHeader).toString();
   Symbol Sym = cls("ns::X");
   Sym.CanonicalDeclaration.FileURI = BarURI.c_str();
   Sym.IncludeHeaders.emplace_back(BarURI, 1);
   // Shoten include path based on search dirctory and insert.
   auto Results = completions(Server,
                              R"cpp(
           int main() { ns::^ }
       )cpp",
                              {Sym});
   EXPECT_THAT(Results.Completions,
               ElementsAre(AllOf(Named("X"), InsertInclude("\"bar.h\""))));
   // Can be disabled via option.
   CodeCompleteOptions NoInsertion;
   NoInsertion.InsertIncludes = CodeCompleteOptions::NeverInsert;
   Results = completions(Server,
-                             R"cpp(
           int main() { ns::^ }
       )cpp",
-                             {Sym}, NoInsertion);
   EXPECT_THAT(Results.Completions,
               ElementsAre(AllOf(Named("X"), Not(InsertInclude()))));
   // Duplicate based on inclusions in preamble.
   Results = completions(Server,
                         R"cpp(
           #include "sub/bar.h"  // not shortest, so should only match resolved.
           int main() { ns::^ }
       )cpp",
                         {Sym});
   EXPECT_THAT(Results.Completions, ElementsAre(AllOf(Named("X"), Labeled("X"),
                                                      Not(InsertInclude()))));
 }
 
 TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
 
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
   Symbol SymX = cls("ns::X");
   Symbol SymY = cls("ns::Y");
   std::string BarHeader = testPath("bar.h");
   auto BarURI = URI::create(BarHeader).toString();
   SymX.CanonicalDeclaration.FileURI = BarURI.c_str();
   SymY.CanonicalDeclaration.FileURI = BarURI.c_str();
   SymX.IncludeHeaders.emplace_back("<bar>", 1);
   SymY.IncludeHeaders.emplace_back("<bar>", 1);
EXPECT_THAT(Results.Completions,
               ElementsAre(AllOf(Named("X"), Not(InsertInclude())),
                           AllOf(Named("Y"), Not(InsertInclude()))));
 }
 
 TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   FS.Files[testPath("bar.h")] =
       R"cpp(namespace ns { struct preamble { int member; }; })cpp";
   auto File = testPath("foo.cpp");
   Annotations Test(R"cpp(
       #include "bar.h"
       namespace ns { int local; }
       void f() { ns::^; }
)cpp")
                      .Completions;
   EXPECT_THAT(Results, ElementsAre(Named("ifndef")));
 }
 
 TEST(CompletionTest, DynamicIndexIncludeInsertion) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   ClangdServer::Options Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
-  ClangdServer Server(CDB, FS, DiagConsumer, Opts);
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer, Opts);
 
   FS.Files[testPath("foo_header.h")] = R"cpp(
     #pragma once
     struct Foo {
        // Member doc
        int foo();
     };
   )cpp";
EXPECT_THAT(completions(Server, "Foo^ foo;").Completions,
                                            '"'),
                                 InsertInclude())));
 }
 
 TEST(CompletionTest, DynamicIndexMultiFile) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   auto Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
-  ClangdServer Server(CDB, FS, DiagConsumer, Opts);
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer, Opts);
 
   FS.Files[testPath("foo.h")] = R"cpp(
       namespace ns { class XYZ {}; void foo(int x) {} }
   )cpp";
   runAddDocument(Server, testPath("foo.cpp"), R"cpp(
       #include "foo.h"
   )cpp");
 
SignatureHelp signatures(llvm::StringRef Text, Position Point,
                          std::vector<Symbol> IndexSymbols = {}) {
   std::unique_ptr<SymbolIndex> Index;
   if (!IndexSymbols.empty())
     Index = memIndex(IndexSymbols);
 
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   ClangdServer::Options Opts = ClangdServer::optsForTest();
   Opts.StaticIndex = Index.get();
 
-  ClangdServer Server(CDB, FS, DiagConsumer, Opts);
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer, Opts);
   auto File = testPath("foo.cpp");
   runAddDocument(Server, File, Text);
   return llvm::cantFail(runSignatureHelp(Server, File, Point));
 }
 
 SignatureHelp signatures(llvm::StringRef Text,
                          std::vector<Symbol> IndexSymbols = {}) {
   Annotations Test(Text);
TEST(CompletionTest, DocumentationFromChangedFileCrash) {
   FS.Files[FooH] = R"cpp(
     // this is my documentation comment.
     int func();
   )cpp";
   FS.Files[FooCpp] = "";
 
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   Annotations Source(R"cpp(
     #include "foo.h"
     int func() {
       // This makes sure we have func from header in the AST.
     }
     int a = fun^
   )cpp");

 
 TEST(CompletionTest, NonDocComments) {
   MockFSProvider FS;
   auto FooCpp = testPath("foo.cpp");
   FS.Files[FooCpp] = "";
 
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   Annotations Source(R"cpp(
     // We ignore namespace comments, for rationale see CodeCompletionStrings.h.
     namespace comments_ns {
     }
 
     // ------------------
     int comments_foo();
EXPECT_THAT(
                            AllOf(IsDocumented(), Named("comments_qux"))));
 }
 
 TEST(CompletionTest, CompleteOnInvalidLine) {
   auto FooCpp = testPath("foo.cpp");
 
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockFSProvider FS;
   FS.Files[FooCpp] = "// empty file";
 
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
   // Run completion outside the file range.
   Position Pos;
   Pos.line = 100;
   Pos.character = 0;
   EXPECT_THAT_EXPECTED(
       runCodeComplete(Server, FooCpp, Pos, clangd::CodeCompleteOptions()),
       Failed());
 }
TEST(CompletionTest, CodeCompletionContext) {
 
   EXPECT_THAT(Results.Context, CodeCompletionContext::CCC_DotMemberAccess);
 }
 
 TEST(CompletionTest, FixItForArrowToDot) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   CodeCompleteOptions Opts;
   Opts.IncludeFixIts = true;
   Annotations TestCode(
       R"cpp(
         class Auxilary {
          public:
           void AuxFunction();
for (const auto &C : Results.Completions) {
     }
   }
 }
 
 TEST(CompletionTest, FixItForDotToArrow) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   CodeCompleteOptions Opts;
   Opts.IncludeFixIts = true;
   Annotations TestCode(
       R"cpp(
         class Auxilary {
          public:
           void AuxFunction();
TEST(CompletionTest, RenderWithFixItNonMerged) {
   EXPECT_EQ(R.textEdit->newText, "Foo::x");
   EXPECT_THAT(R.additionalTextEdits, UnorderedElementsAre(FixIt));
 }
 
 TEST(CompletionTest, CompletionTokenRange) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   constexpr const char *TestCodes[] = {
       R"cpp(
         class Auxilary {
          public:
           void AuxFunction();
         };
         void f() {
EXPECT_THAT(
                   AllOf(Sig("foo(int, int) -> int", {"int", "int"}),
                         SigDoc("Doc from sema"))));
 }
 
 TEST(SignatureHelpTest, DynamicIndexDocumentation) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   ClangdServer::Options Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
-  ClangdServer Server(CDB, FS, DiagConsumer, Opts);
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer, Opts);
 
   FS.Files[testPath("foo.h")] = R"cpp(
     struct Foo {
        // Member doc
        int foo();
     };
   )cpp";
   Annotations FileContent(R"cpp(
completions(R"cpp(
     struct Derived : Base {
       ^
     };
   )cpp");
 }
 
 TEST(GuessCompletionPrefix, Filters) {
   for (llvm::StringRef Case : {
            "[[scope::]][[ident]]^",
            "[[]][[]]^",
            "\n[[]][[]]^",
            "[[]][[ab]]^",
            "x.[[]][[ab]]^",
            "x.[[]][[]]^",
            "[[x::]][[ab]]^",
            "[[x::]][[]]^",
            "[[::x::]][[ab]]^",
            "some text [[scope::more::]][[identif]]^ier",
            "some text [[scope::]][[mor]]^e::identifier",
            "weird case foo::[[::bar::]][[baz]]^",
        }) {
     Annotations F(Case);
     auto Offset = cantFail(positionToOffset(F.code(), F.point()));
     auto ToStringRef = [&](Range R) {
       return F.code().slice(cantFail(positionToOffset(F.code(), R.start)),
                             cantFail(positionToOffset(F.code(), R.end)));
     };
     auto WantQualifier = ToStringRef(F.ranges()[0]),
          WantName = ToStringRef(F.ranges()[1]);
 
     auto Prefix = guessCompletionPrefix(F.code(), Offset);
     // Even when components are empty, check their offsets are correct.
     EXPECT_EQ(WantQualifier, Prefix.Qualifier) << Case;
     EXPECT_EQ(WantQualifier.begin(), Prefix.Qualifier.begin()) << Case;
     EXPECT_EQ(WantName, Prefix.Name) << Case;
     EXPECT_EQ(WantName.begin(), Prefix.Name.begin()) << Case;
   }
 }
 
 TEST(CompletionTest, EnableSpeculativeIndexRequest) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto File = testPath("foo.cpp");
   Annotations Test(R"cpp(
       namespace ns1 { int abc; }
       namespace ns2 { int abc; }
       void f() { ns1::ab$1^; ns1::ab$2^; }
       void f2() { ns2::ab$3^; }
   )cpp");

 TEST(CompletionTest, NoInsertIncludeIfOnePresent) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
 
   std::string FooHeader = testPath("foo.h");
   FS.Files[FooHeader] = "";
 
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   std::string DeclFile = URI::create(testPath("foo")).toString();
   Symbol sym = func("Func");
   sym.CanonicalDeclaration.FileURI = DeclFile.c_str();
   sym.IncludeHeaders.emplace_back("\"foo.h\"", 2);
   sym.IncludeHeaders.emplace_back("\"bar.h\"", 1000);
 
   EXPECT_THAT(

 }
 
 TEST(CompletionTest, MacroFromPreamble) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   std::string FooHeader = testPath("foo.h");
   FS.Files[FooHeader] = "#define CLANGD_PREAMBLE_HEADER x\n";
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
   auto Results = completions(
       R"cpp(#include "foo.h"
           #define CLANGD_PREAMBLE_MAIN x
 
           int x = 0;
           #define CLANGD_MAIN x
           void f() { CLANGD_^ }
       )cpp",
TEST(CompletionTest, IncludedCompletionKinds) {
   MockFSProvider FS;
   MockCompilationDatabase CDB;
   std::string Subdir = testPath("sub");
   std::string SearchDirArg = (Twine("-I") + Subdir).str();
   CDB.ExtraClangFlags = {SearchDirArg.c_str()};
   std::string BarHeader = testPath("sub/bar.h");
   FS.Files[BarHeader] = "";
   IgnoreDiagnostics DiagConsumer;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
   auto Results = completions(Server,
                              R"cpp(
         #include "^"
       )cpp");
   EXPECT_THAT(Results.Completions,
               AllOf(Has("sub/", CompletionItemKind::Folder),
                     Has("bar.h\"", CompletionItemKind::File)));
 }

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

ClangdServer::Options optsForTests() {
   ServerOpts.WorkspaceRoot = testRoot();
   ServerOpts.BuildDynamicSymbolIndex = true;
   return ServerOpts;
 }
 
 class WorkspaceSymbolsTest : public ::testing::Test {
 public:
   WorkspaceSymbolsTest()
-      : Server(CDB, FSProvider, DiagConsumer, optsForTests()) {
+      : Server(CDB, FSProvider, DiagConsumer, SHConsumer, optsForTests()) {
     // Make sure the test root directory is created.
     FSProvider.Files[testPath("unused")] = "";
     CDB.ExtraClangFlags = {"-xc++"};
   }
 
 protected:
   MockFSProvider FSProvider;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   ClangdServer Server;
   int Limit = 0;
 
   std::vector<SymbolInformation> getSymbols(llvm::StringRef Query) {
     EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for preamble";
     auto SymbolInfos = runWorkspaceSymbols(Server, Query, Limit);
     EXPECT_TRUE(bool(SymbolInfos)) << "workspaceSymbols returned an error";
     return *SymbolInfos;
EXPECT_THAT(
           AllOf(QName("Foo<bool, int>"), WithKind(SymbolKind::Class)),
           AllOf(QName("Foo<bool, int, 3>"), WithKind(SymbolKind::Class))));
 }
 
 namespace {
 class DocumentSymbolsTest : public ::testing::Test {
 public:
   DocumentSymbolsTest()
-      : Server(CDB, FSProvider, DiagConsumer, optsForTests()) {}
+      : Server(CDB, FSProvider, DiagConsumer, SHConsumer, optsForTests()) {}
 
 protected:
   MockFSProvider FSProvider;
   MockCompilationDatabase CDB;
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   ClangdServer Server;
 
   std::vector<DocumentSymbol> getSymbols(PathRef File) {
     EXPECT_TRUE(Server.blockUntilIdleForTest()) << "Waiting for preamble";
     auto SymbolInfos = runDocumentSymbols(Server, File);
     EXPECT_TRUE(bool(SymbolInfos)) << "documentSymbols returned an error";
     return *SymbolInfos;
   }
EXPECT_THAT(
                                                WithKind(SymbolKind::Method),
                                                Children()))))),
            AllOf(WithName("Friend"), WithKind(SymbolKind::Class), Children()),
            AllOf(WithName("f1"), WithKind(SymbolKind::Function), Children()),
            AllOf(WithName("f2"), WithKind(SymbolKind::Function), Children()),
            AllOf(WithName("KInt"), WithKind(SymbolKind::Variable), Children()),
            AllOf(WithName("kStr"), WithKind(SymbolKind::Variable), Children()),
            AllOf(WithName("f1"), WithKind(SymbolKind::Function), Children()),
-           AllOf(WithName("foo"), WithKind(SymbolKind::Namespace),
-                 Children(
-                     AllOf(WithName("int32"), WithKind(SymbolKind::Class),
-                           Children()),
-                     AllOf(WithName("int32_t"), WithKind(SymbolKind::Class),
-                           Children()),
-                     AllOf(WithName("v1"), WithKind(SymbolKind::Variable),
-                           Children()),
-                     AllOf(WithName("bar"), WithKind(SymbolKind::Namespace),
-                           Children(AllOf(WithName("v2"),
-                                          WithKind(SymbolKind::Variable),
-                                          Children()))),
-                     AllOf(WithName("baz"), WithKind(SymbolKind::Namespace),
-                           Children()),
-                     AllOf(WithName("v2"), WithKind(SymbolKind::Namespace))))}));
+           AllOf(
+               WithName("foo"), WithKind(SymbolKind::Namespace),
 }
 
 TEST_F(DocumentSymbolsTest, DeclarationDefinition) {
   std::string FilePath = testPath("foo.cpp");
   Annotations Main(R"(
       class Foo {
         void $decl[[f]]();
       };

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

+//===-- SemanticHighlightingTests.cpp----------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+#include "Annotations.h"
+#include "SemanticHighlighting.h"
+#include "TestTU.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+#include <ostream>
+
+namespace clang {
+namespace clangd {
+
+namespace {
+
+std::string kindAsString(SemanticHighlightingKind Kind) {
+  switch (Kind) {
+  case SemanticHighlightingKind::Class:
+    return "Class";
+  case SemanticHighlightingKind::Enum:
+    return "Enum";
+  case SemanticHighlightingKind::EnumClass:
+    return "EnumClass";
+  case SemanticHighlightingKind::Enumerator:
+    return "Enumerator";
+  case SemanticHighlightingKind::Field:
+    return "Field";
+  case SemanticHighlightingKind::Function:
+    return "Function";
+  case SemanticHighlightingKind::FunctionDeclaration:
+    return "FunctionDeclaration";
+  case SemanticHighlightingKind::GlobalVariable:
+    return "GlobalVariable";
+  case SemanticHighlightingKind::Label:
+    return "Label";
+  case SemanticHighlightingKind::LocalVariable:
+    return "LocalVariable";
+  case SemanticHighlightingKind::LocalVariableDeclaration:
+    return "LocalVariableDeclaration";
+  case SemanticHighlightingKind::Macro:
+    return "Macro";
+  case SemanticHighlightingKind::MacroDefinition:
+    return "MacroDefinition";
+  case SemanticHighlightingKind::Method:
+    return "Method";
+  case SemanticHighlightingKind::MethodDeclaration:
+    return "MethodDeclaration";
+  case SemanticHighlightingKind::Namespace:
+    return "Namespace";
+  case SemanticHighlightingKind::ParameterVariable:
+    return "ParameterVariable";
+  case SemanticHighlightingKind::StaticField:
+    return "StaticField";
+  case SemanticHighlightingKind::StaticMethod:
+    return "StaticMethod";
+  case SemanticHighlightingKind::StaticMethodDeclaration:
+    return "StaticMethodDeclaration";
+  case SemanticHighlightingKind::TemplateParameter:
+    return "TemplateParameter";
+  case SemanticHighlightingKind::Typedef:
+    return "Typedef";
+  case SemanticHighlightingKind::Special_LastKind:
+    return "<unknown>";
+  }
+  return "<unknown>";
+}
+
+} // namespace
+
+// Teach gtest how to print a SemanticHighlightingToken to make test debugging
+// easier. These need to not be in an anonymous namespace for gtest to find
+// them.
+std::ostream &operator<<(std::ostream &OS, const Position &Pos) {
+  return OS << Pos.line << ":" << Pos.character;
+}
+std::ostream &operator<<(std::ostream &OS, const Range &R) {
+  return OS << "[" << R.start << "," << R.end << "]";
+}
+std::ostream &operator<<(std::ostream &OS,
+                         const SemanticHighlightingToken &Token) {
+  return OS << kindAsString(Token.Kind) << " @ " << Token.R;
+}
+
+namespace {
+
+using Highlightings = std::vector<SemanticHighlightingToken>;
+
+Highlightings collectExpectedHighlightings(const Annotations &Source) {
+  Highlightings Result;
+  for (int Index = 0; Index < (int)SemanticHighlightingKind::Special_LastKind;
+       ++Index) {
+    auto Kind = static_cast<SemanticHighlightingKind>(Index);
+    for (const auto &Range : Source.ranges(kindAsString(Kind))) {
+      Result.push_back({Range, Kind});
+    }
+  }
+  return Result;
+}
+
+void compareHighlightings(Highlightings &Actual, Highlightings &Expected) {
+  std::sort(Actual.begin(), Actual.end());
+  std::sort(Expected.begin(), Expected.end());
+  EXPECT_EQ(Actual, Expected);
+}
+
+void checkHighlightings(llvm::StringRef AnnotatedSource) {
+  Annotations Source(AnnotatedSource);
+  TestTU TU = TestTU::withCode(Source.code());
+  auto AST = TU.build();
+  // dumpAST(AST, llvm::errs());
+  // Check that the AST has no errors. This is mostly for catching mistakes.
+  // If we later want to test highlighting of invalid code, we can add an
+  // option to bypass this check.
+  for (auto D : AST.getDiagnostics()) {
+    llvm::errs() << D << "\n"; // For debugging if the assert below fails.
+  }
+  ASSERT_TRUE(AST.getDiagnostics().empty());
+  auto ActualHighlightings = computeSemanticHighlightings(AST);
+  auto ExpectedHighlightings = collectExpectedHighlightings(Source);
+  compareHighlightings(ActualHighlightings, ExpectedHighlightings);
+}
+
+TEST(SemanticHighlightings, Basics) {
+  checkHighlightings(R"cpp(
+class $Class[[Waldo]] {
+  int $MethodDeclaration[[find]](int $ParameterVariable[[Param]]);
+};
+$Class[[Waldo]] $GlobalVariable[[W]];
+)cpp");
+}
+
+TEST(SemanticHighlightings, UnnamedParameters) {
+  // Test that we do not get highlightings for unnamed parameters.
+  checkHighlightings(R"cpp(
+  void $FunctionDeclaration[[foo]](int);       // unnamed function parameter
+  template <typename> class $Class[[Foo]] {};  // unnamed template parameter
+)cpp");
+}
+
+TEST(SemanticHighlightings, AnonymousTypes) {
+  // Test that we do not get highlightings for anonymous types.
+  checkHighlightings(R"cpp(
+  struct { } $GlobalVariable[[S]];             // unnamed structure
+)cpp");
+}
+
+TEST(SemanticHighlightings, Templates) {
+  checkHighlightings(R"cpp(
+template <typename $TemplateParameter[[T]]>
+void $FunctionDeclaration[[foo]]($TemplateParameter[[T]]);
+class $Class[[C]] {
+  template <typename $TemplateParameter[[T]]>
+  void $MethodDeclaration[[bar]]($TemplateParameter[[T]]);
+};
+)cpp");
+}
+
+TEST(SemanticHighlightings, DependentMethodCall) {
+  checkHighlightings(R"cpp(
+class $Class[[C]] {
+  template <typename $TemplateParameter[[T]]>
+  void $MethodDeclaration[[bar]]($TemplateParameter[[T]]);
+};
+
+template <typename $TemplateParameter[[U]]>
+void $FunctionDeclaration[[foo]]($TemplateParameter[[U]] $ParameterVariable[[u]]) {
+  $Class[[C]]().$Method[[bar]]($ParameterVariable[[u]]);
+}
+)cpp");
+}
+
+TEST(SemanticHighlightings, DependentFunctionCall) {
+  checkHighlightings(R"cpp(
+template <typename $TemplateParameter[[T]]>
+void $FunctionDeclaration[[foo]]($TemplateParameter[[T]] $ParameterVariable[[t]]) {
+  $Function[[bar]]($ParameterVariable[[t]]);
+}
+)cpp");
+}
+
+TEST(SemanticHighlightings, AlignmentSpecifier) {
+  checkHighlightings(R"cpp(
+struct $Class[[S]] { double $Field[[x]]; };
+alignas($Class[[S]]) int $GlobalVariable[[y]];
+)cpp");
+}
+
+TEST(SemanticHighlightings, AliasTemplates) {
+  checkHighlightings(R"cpp(
+template <typename $TemplateParameter[[T]], typename $TemplateParameter[[U]]>
+struct $Class[[Pair]] { };
+
+template <typename $TemplateParameter[[T]]>
+using $Typedef[[PairIntX]] = $Class[[Pair]]<int, $TemplateParameter[[T]]>;
+
+struct $Class[[Waldo]] { };
+
+int $FunctionDeclaration[[main]]() {
+  $Typedef[[PairIntX]]<$Class[[Waldo]]> $LocalVariableDeclaration[[pair]];
+}
+)cpp");
+}
+
+TEST(SemanticHighlightings, QualifiedEnum) {
+  checkHighlightings(R"cpp(
+namespace $Namespace[[N]] {
+  struct $Class[[C]] {
+    enum $Enum[[E1]] { };
+    enum class $EnumClass[[EC1]] { };
+  };
+  $Class[[C]]::$Enum[[E1]] $GlobalVariable[[e1]];
+  $Class[[C]]::$EnumClass[[EC1]] $GlobalVariable[[ec1]];
+  enum $Enum[[E2]] { };
+  enum class $EnumClass[[EC2]] { };
+}
+$Namespace[[N]]::$Class[[C]]::$Enum[[E1]] $GlobalVariable[[e1]];
+$Namespace[[N]]::$Class[[C]]::$EnumClass[[EC1]] $GlobalVariable[[ec1]];
+$Namespace[[N]]::$Enum[[E2]] $GlobalVariable[[e2]];
+$Namespace[[N]]::$EnumClass[[EC2]] $GlobalVariable[[ec2]];
+)cpp");
+}
+
+TEST(SemanticHighlightings, InheritingConstructor) {
+  checkHighlightings(R"cpp(
+class $Class[[Base]] { };
+class $Class[[Derived]] : $Class[[Base]] {
+  // FIXME: Would like the second one to be Method.
+  using $Class[[Base]]::$Class[[Base]];
+};
+)cpp");
+}
+
+TEST(SemanticHighlightings, LambdaCaptures) {
+  checkHighlightings(R"cpp(
+void $FunctionDeclaration[[foo]](int $ParameterVariable[[param]]) {
+  int $LocalVariableDeclaration[[local]];
+  [$LocalVariable[[local]], $ParameterVariable[[param]]](){}();
+}
+)cpp");
+}
+
+TEST(SemanticHighlightings, DependentType) {
+  checkHighlightings(R"cpp(
+template <typename $TemplateParameter[[T]]>
+void $FunctionDeclaration[[foo]](typename $TemplateParameter[[T]]::$Class[[Type]] $ParameterVariable[[param]]
+    = $TemplateParameter[[T]]::$StaticField[[val]]);
+)cpp");
+}
+
+// Disabled as this requires heuristic resolution.
+TEST(SemanticHighlightings, DISABLED_DependentEnum) {
+  checkHighlightings(R"cpp(
+template <typename $TemplateParameter[[T]]>
+struct $Class[[Base]] {
+  enum $Enum[[E]] { $Enumerator[[A]] };
+  enum class $EnumClass[[F]] { $Enumerator[[B]] };
+};
+template <typename $TemplateParameter[[T]]>
+struct $Class[[Derived]] : $Class[[Base]]<$TemplateParameter[[T]]> {
+  static typename $Class[[Base]]<$TemplateParameter[[T]]>::$Enum[[E]] $StaticField[[x]]
+         = $Class[[Base]]<$TemplateParameter[[T]]>::$Enumerator[[A]];
+  static typename $Class[[Base]]<$TemplateParameter[[T]]>::$EnumClass[[F]] $StaticField[[y]]
+         = $Class[[Base]]<$TemplateParameter[[T]]>::$EnumClass[[F]]::$Enumerator[[B]];
+};
+)cpp");
+}
+
+TEST(SemanticHighlightings, ExplicitSpec) {
+  checkHighlightings(R"cpp(
+template <typename $TemplateParameter[[T]]> class $Class[[C]];
+template <> class $Class[[C]]<int> {};
+)cpp");
+}
+
+TEST(SemanticHighlightings, TemplateMetaprogramming) {
+  checkHighlightings(R"cpp(
+template <unsigned... $TemplateParameter[[Indexes]]>
+struct $Class[[IndexTuple]] {
+  using $Typedef[[Next]] = $Class[[IndexTuple]]<$TemplateParameter[[Indexes]]..., sizeof...($TemplateParameter[[Indexes]])>;
+};
+template <unsigned $TemplateParameter[[N]]>
+struct $Class[[BuildIndexTuple]] {
+  using $Typedef[[Type]] = typename $Class[[BuildIndexTuple]]<$TemplateParameter[[N]] - 1>::$Class[[Type]]::$Class[[Next]];
+};
+template <>
+struct $Class[[BuildIndexTuple]]<0> {
+  using $Typedef[[Type]] = $Class[[IndexTuple]]<>;
+};
+)cpp");
+}
+
+// Disabled due to a clang bug
+// (see http://lists.llvm.org/pipermail/clangd-dev/2019-April/000400.html).
+TEST(SemanticHighlightings, DISABLED_VariableTemplates) {
+  checkHighlightings(R"cpp(
+template <typename $TemplateParameter[[T]]>
+const bool $GlobalVariable[[templ]] = true;
+struct $Class[[A]] { };
+bool $GlobalVariable[[x]] = $GlobalVariable[[templ]]<$Class[[A]]>;
+struct $Class[[S]] {
+  template <typename $TemplateParameter[[U]]>
+  static const bool $StaticField[[templ]] = true;
+  void $MethodDeclaration[[bar]]() {
+    bool $LocalVariableDeclaration[[y]] = $StaticField[[templ]]<$Class[[A]]>;
+  }
+};
+)cpp");
+}
+
+TEST(SemanticHighlightings, FunctionTemplateSpec) {
+  checkHighlightings(R"cpp(
+struct $Class[[S]] { };
+template <typename> void $FunctionDeclaration[[Waldo]]() { }
+template <> void $FunctionDeclaration[[Waldo]]<$Class[[S]]>() { }
+)cpp");
+}
+
+TEST(SemanticHighlightings, OverloadedOperator) {
+  checkHighlightings(R"cpp(
+struct $Class[[S]] {
+  int $Field[[waldo]];
+};
+struct $Class[[Iter]] {
+  // FIXME: Would like the operator symbol included in the highlighting
+  // for the method declaration, not just the operator keyword.
+  $Class[[S]] $MethodDeclaration[[operator]]*();
+};
+int $FunctionDeclaration[[main]]() {
+  $Class[[Iter]] $LocalVariableDeclaration[[it]];
+  // FIXME: Once we support highlighting of overloaded operators,
+  // there should be an overloded operator highlighting on the next line.
+  (void)(1 + (*$LocalVariable[[it]]).$Field[[waldo]]);
+}
+)cpp");
+}
+
+TEST(SemanticHighlightings, MemInitializerList) {
+  checkHighlightings(R"cpp(
+struct $Class[[S]] {
+  int $Field[[field]];
+
+  $MethodDeclaration[[S]](int $ParameterVariable[[field]])
+    : $Field[[field]]($ParameterVariable[[field]]) {}
+};
+  )cpp");
+}
+
+TEST(SemanticHighlightings, InjectedClassName) {
+  checkHighlightings(R"cpp(
+template <typename>
+struct $Class[[S]] {
+  void $MethodDeclaration[[foo]]($Class[[S]]);
+};
+  )cpp");
+}
+
+TEST(SemanticHighlightings, DependentField) {
+  checkHighlightings(R"cpp(
+template <typename $TemplateParameter[[T]]>
+void $FunctionDeclaration[[foo]]($TemplateParameter[[T]] $ParameterVariable[[t]]) {
+  $ParameterVariable[[t]].$Field[[field]];
+}
+  )cpp");
+}
+
+TEST(SemanticHighlightings, DependentStaticField) {
+  checkHighlightings(R"cpp(
+template <typename $TemplateParameter[[T]]>
+int $FunctionDeclaration[[foo]]() {
+  return $TemplateParameter[[T]]::$StaticField[[field]];
+}
+
+template <typename $TemplateParameter[[T]]>
+struct $Class[[S]] {
+  void $MethodDeclaration[[bar]]() {
+    // For some reason, clang parses this differently than the free function case
+    // (CXXDependentScopeMemberExpr vs. DependentScopeDeclRefExpr).
+    return $TemplateParameter[[T]]::$StaticField[[field]];
+  }
+};
+  )cpp");
+}
+
+TEST(SemanticHighlightings, StaticMethodWithDependentArguments) {
+  checkHighlightings(R"cpp(
+struct $Class[[A]] {
+  template <typename $TemplateParameter[[T]]>
+  static void $StaticMethodDeclaration[[foo]]($TemplateParameter[[T]]);
+};
+
+template <typename $TemplateParameter[[T]]>
+struct $Class[[B]] {
+  void $MethodDeclaration[[bar]]() {
+    $Class[[A]]::$StaticMethod[[foo]]($TemplateParameter[[T]]());
+  }
+};
+  )cpp");
+}
+
+} // namespace
+} // namespace clangd
+} // namespace clang

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

public:
     }
 
   private:
     std::mutex Mutex;
     std::vector<TUStatus> AllStatus;
   } CaptureTUStatus;
   MockFSProvider FS;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, CaptureTUStatus, ClangdServer::optsForTest());
+  NoopSemanticHighlightingConsumer SHConsumer;
+  ClangdServer Server(CDB, FS, CaptureTUStatus, SHConsumer,
+                      ClangdServer::optsForTest());
   Annotations Code("int m^ain () {}");
 
   // We schedule the following tasks in the queue:
   //   [Update] [GoToDefinition]
   Server.addDocument(testPath("foo.cpp"), Code.code(), WantDiagnostics::Yes);
   Server.locateSymbolAt(testPath("foo.cpp"), Code.point(),
                         [](Expected<std::vector<LocatedSymbol>> Result) {
                           ASSERT_TRUE((bool)Result);

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

public:
 
   std::vector<std::string> ExtraClangFlags;
 
 private:
   StringRef Directory;
   StringRef RelPathPrefix;
 };
 
+class NoopSemanticHighlightingConsumer : public SemanticHighlightingConsumer {
+public:
+  void onSemanticHighlightingReady(
+      PathRef, std::vector<SemanticHighlightingToken>) override {}
+};
+
 // Returns an absolute (fake) test directory for this OS.
 const char *testRoot();
 
 // Returns a suitable absolute path for this OS.
 std::string testPath(PathRef File);
 
 // unittest: is a scheme that refers to files relative to testRoot()
 // This anchor is used to force the linker to link in the generated object file
 // and thus register unittest: URI scheme plugin.
 extern volatile int UnittestSchemeAnchorSource;
 
 } // namespace clangd
 } // namespace clang
 #endif

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

)cpp");
   // Make the compilation paths appear as ../src/foo.cpp in the compile
   // commands.
   SmallString<32> RelPathPrefix("..");
   llvm::sys::path::append(RelPathPrefix, "src");
   std::string BuildDir = testPath("build");
   MockCompilationDatabase CDB(BuildDir, RelPathPrefix);
 
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockFSProvider FS;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   // Fill the filesystem.
   auto FooCpp = testPath("src/foo.cpp");
   FS.Files[FooCpp] = "";
   auto HeaderInPreambleH = testPath("src/header_in_preamble.h");
   FS.Files[HeaderInPreambleH] = HeaderInPreambleAnnotations.code();
   auto HeaderNotInPreambleH = testPath("src/header_not_in_preamble.h");
   FS.Files[HeaderNotInPreambleH] = HeaderNotInPreambleAnnotations.code();
for (const OneTest &Test : Tests) {
     } else
       EXPECT_EQ("", Test.ExpectedHover.str()) << Test.Input;
   }
 }
 
 TEST(GoToInclude, All) {
   MockFSProvider FS;
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto FooCpp = testPath("foo.cpp");
   const char *SourceContents = R"cpp(
   #include ^"$2^foo.h$3^"
   #include "$4^invalid.h"
   int b = a;
   // test
   int foo;
TEST(GoToInclude, All) {
   EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range())));
 }
 
 TEST(LocateSymbol, WithPreamble) {
   // Test stragety: AST should always use the latest preamble instead of last
   // good preamble.
   MockFSProvider FS;
   IgnoreDiagnostics DiagConsumer;
+  NoopSemanticHighlightingConsumer SHConsumer;
   MockCompilationDatabase CDB;
-  ClangdServer Server(CDB, FS, DiagConsumer, ClangdServer::optsForTest());
+  ClangdServer Server(CDB, FS, DiagConsumer, SHConsumer,
+                      ClangdServer::optsForTest());
 
   auto FooCpp = testPath("foo.cpp");
   // The trigger locations must be the same.
   Annotations FooWithHeader(R"cpp(#include "fo^o.h")cpp");
   Annotations FooWithoutHeader(R"cpp(double    [[fo^o]]();)cpp");
 
   FS.Files[FooCpp] = FooWithHeader.code();