[clangd] Cleanup of readability-identifier-naming

[kuhnel]

Summary

Auto-generated patch based on clang-tidy readability-identifier-naming.
Only some manual cleanup for extern "C" declarations and a GTest change was required.

I'm not sure if this cleanup is actually very useful. It cleans up clang-tidy findings to the number of warnings from clang-tidy should be lower. Since it was easy to do and required only little cleanup I thought I'd upload it for discussion.

One pattern that keeps recurring: Test matchers are also supposed to start with a lowercase letter as per LLVM convention. However GTest naming convention for matchers start with upper case. I would propose to keep stay consistent with the GTest convention there. However that would imply a lot of //NOLINT throughout these files.

To re-product this patch run:

run-clang-tidy -checks="-*,readability-identifier-naming" -fix -format ./clang-tools-extra/clangd

To convert the macro names, I was using this script with some manual cleanup afterwards:
https://gist.github.com/ChristianKuehnel/a01cc4362b07c58281554ab46235a077

[sammccall]

Generally looks good with a few nits for individual names.

The matcher cleanup is a problem though, because you haven't cleaned up the functions created using the macros MATCHER, MATCHER_P, MATCHER_P2 etc. Presumably this is because names created through macros are excluded by the clang-tidy check.
IMO as a question of style we need to change all such functions we define or none of them.

clang-tools-extra/clangd/TUScheduler.cpp

103

I don't think it makes sense to keep the K here if it has to be uppercase.

The LLVM styleguide doesn't encourage this prefix. Styleguides that do tend to use a lowercase k for readability. If we want to strictly follow the LLVM styleguide I think we should just drop it.

clang-tools-extra/clangd/fuzzer/FuzzerClangdMain.cpp

15 ↗

(On Diff #393876)

This name is always exempt, and should rather be excluded by config: https://clang.llvm.org/extra/clang-tidy/checks/readability-identifier-naming.html#cmdoption-arg-functionignoredregexp

clang-tools-extra/clangd/index/YAMLSerialization.cpp

164

We use IO rather than Io for initialisms.
There are cases where the type/name can't match, but this doesn't appear to be one of them (we use IO &IO in similar mapping function below)

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

39

Note that MATCHER_P(FileURI, F, "") { ... ] above also defines a function returning a Matcher.

I think it's OK for our functions to have different case than matcher functions from the upstream gtest (different libraries have different styles), but I don't think it's OK for matcher functions to have different case depending on whether MATCHER_P was used or not.

And I agree that //NOLINT everywhere is not a good option.

So as far as I'm concerned:

• OK: change these functions and also all the MATCHER, MATCHER_P etc instances to lowerCamelCase
• OK: ignore this style rule and check results for matcher names
• Not OK: follow the rule for explicitly-defined function but ignore it for MATCHER_Ps
• Not OK: ignore the rule and add // NOLINT to enough exceptions to silence the checker
• Bonus: teach the tidy check to flag violations introduced through macros (probably with an allowlist of macro names)

(I'm not quite sure how our convention of using UpperCamelCase for matcher factory functions got started, but I suspect it's from following upstream recipes without thinking hard about whether the new symbol is a function or a type).

228–229

this illustrates the problem: RefsAre({FileURI(...)}) or refsAre({fileURI}) make sense, but the mix does not.

273

This new name is no good, but in fact the variable is unused, just delete it

347–348

This name is also no good, and it's used exactly once - inline it

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

28

This is a magic function used by GTest, it is found via ADL and must be spelled exactly PrintTo.

This rename is dangerous because it doesn't cause tests to fail, but it causes them to have useless error messages if they fail later.

Please exclude this from the checker using the FunctionIgnoredRegexp.
Please make sure no other PrintTo functions have been renamed.

[kuhnel]

Discussion in team sync, work for myself:

• most changes are in unittests --> propose something for the matchers
• cleaning up constants makes sense
• clean up this patch, then do another round of reviews

[kuhnel]

Re-created the patch as there were too many changes in the repo.

Excluding gtest Matchers from naming checks as gtest convention does not match
LLVM convention.

[kuhnel]

clang-tools-extra/clangd/fuzzer/FuzzerClangdMain.cpp

15 ↗

(On Diff #393876)

I tried a couple of variations of the config in the global .clang-tidy file, however none of them actually ignored the function:

yaml
  - key:             readability-identifier-naming.FunctionIgnoredRegexp
    value:           "LLVMFuzzerTest.*"

Any idea what I'm doing wrong?

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

39

My proposal here is to stick with the gtest naming convention for more consistency in the naming: Matchers start with upper case letters.

Thus I added //NOLINT to all matchers I encountered.

[kuhnel]

addressed review comments

[kuhnel]

re-created patch, then updated matcher macros

[kuhnel]

fixed A_CC in BackgroundIndexTests.cpp

[sammccall]

Thanks, this is great!
Just a few cases that regex couldn't quite understand, and one bona fide bug!

clang-tools-extra/clangd/TUScheduler.cpp

103

I think this got reverted - should just be FileBeingProcessed

clang-tools-extra/clangd/XRefs.cpp

1864

this was a bug! should be VisitCoyieldExpr (capital because it's a CRTP override).

But this is is a functional bugfix, please either leave a fixme or change in a separate patch

clang-tools-extra/clangd/index/YAMLSerialization.cpp

164

This change also got lost (and in the next function)

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

117–118

id, not iD

[kuhnel]

Thx @sammccall for your patience with this cleanup.

clang-tools-extra/clangd/TUScheduler.cpp

103

Right, sorry about the backsliding there. If I were ever to do such a cleanup again, I need to really split manual and automatic steps into separate commits and keep them in a separate branch before squashing them for arc diff.

clang-tools-extra/clangd/XRefs.cpp

1864

added FIXME, feel feel free to create a patch for it

.clang-tidy

 Checks: '-*,clang-diagnostic-*,llvm-*,misc-*,-misc-unused-parameters,-misc-non-private-member-variables-in-classes,-misc-no-recursion,readability-identifier-naming'
 CheckOptions:
   - key:             readability-identifier-naming.ClassCase
     value:           CamelCase
   - key:             readability-identifier-naming.EnumCase
     value:           CamelCase
   - key:             readability-identifier-naming.FunctionCase
     value:           camelBack
+  # Exclude from scanning as this is an exported symbol used for fuzzing
+  # throughout the code base.
+  - key:             readability-identifier-naming.FunctionIgnoredRegexp
+    value:           "LLVMFuzzerTestOneInput"
   - key:             readability-identifier-naming.MemberCase
     value:           CamelCase
   - key:             readability-identifier-naming.ParameterCase
     value:           CamelCase
   - key:             readability-identifier-naming.UnionCase
     value:           CamelCase
   - key:             readability-identifier-naming.VariableCase
     value:           CamelCase
   - key:             readability-identifier-naming.IgnoreMainLikeFunctions
     value:           1
   - key:             readability-redundant-member-init.IgnoreBaseInCopyConstructors
     value:           1
   - key:             modernize-use-default-member-init.UseAssignment
     value:           1

clang-tools-extra/clangd/ClangdLSPServer.cpp

llvm::Optional<int64_t> decodeVersion(llvm::StringRef Encoded) {
   int64_t Result;
   if (llvm::to_integer(Encoded, Result, 10))
     return Result;
   if (!Encoded.empty()) // Empty can be e.g. diagnostics on close.
     elog("unexpected non-numeric version {0}", Encoded);
   return llvm::None;
 }
 
-const llvm::StringLiteral APPLY_FIX_COMMAND = "clangd.applyFix";
-const llvm::StringLiteral APPLY_TWEAK_COMMAND = "clangd.applyTweak";
+const llvm::StringLiteral ApplyFixCommand = "clangd.applyFix";
+const llvm::StringLiteral ApplyTweakCommand = "clangd.applyTweak";
 
 /// Transforms a tweak into a code action that would apply it if executed.
 /// EXPECTS: T.prepare() was called and returned true.
 CodeAction toCodeAction(const ClangdServer::TweakRef &T, const URIForFile &File,
                         Range Selection) {
   CodeAction CA;
   CA.title = T.Title;
   CA.kind = T.Kind.str();
   // This tweak may have an expensive second stage, we only run it if the user
   // actually chooses it in the UI. We reply with a command that would run the
   // corresponding tweak.
   // FIXME: for some tweaks, computing the edits is cheap and we could send them
   //        directly.
   CA.command.emplace();
   CA.command->title = T.Title;
-  CA.command->command = std::string(APPLY_TWEAK_COMMAND);
+  CA.command->command = std::string(ApplyTweakCommand);
   TweakArgs Args;
   Args.file = File;
   Args.tweakID = T.ID;
   Args.selection = Selection;
   CA.command->argument = std::move(Args);
   return CA;
 }
 

 
 static llvm::Optional<Command> asCommand(const CodeAction &Action) {
   Command Cmd;
   if (Action.command && Action.edit)
     return None; // Not representable. (We never emit these anyway).
   if (Action.command) {
     Cmd = *Action.command;
   } else if (Action.edit) {
-    Cmd.command = std::string(APPLY_FIX_COMMAND);
+    Cmd.command = std::string(ApplyFixCommand);
     Cmd.argument = *Action.edit;
   } else {
     return None;
   }
   Cmd.title = Action.title;
   if (Action.kind && *Action.kind == CodeAction::QUICKFIX_KIND)
     Cmd.title = "Apply fix: " + Cmd.title;
   return Cmd;
void ClangdLSPServer::bindMethods(LSPBinder &Bind,
   Bind.method("textDocument/selectionRange", this, &ClangdLSPServer::onSelectionRange);
   Bind.method("textDocument/documentLink", this, &ClangdLSPServer::onDocumentLink);
   Bind.method("textDocument/semanticTokens/full", this, &ClangdLSPServer::onSemanticTokens);
   Bind.method("textDocument/semanticTokens/full/delta", this, &ClangdLSPServer::onSemanticTokensDelta);
   Bind.method("clangd/inlayHints", this, &ClangdLSPServer::onInlayHints);
   Bind.method("$/memoryUsage", this, &ClangdLSPServer::onMemoryUsage);
   if (Opts.FoldingRanges)
     Bind.method("textDocument/foldingRange", this, &ClangdLSPServer::onFoldingRange);
-  Bind.command(APPLY_FIX_COMMAND, this, &ClangdLSPServer::onCommandApplyEdit);
-  Bind.command(APPLY_TWEAK_COMMAND, this, &ClangdLSPServer::onCommandApplyTweak);
+  Bind.command(ApplyFixCommand, this, &ClangdLSPServer::onCommandApplyEdit);
+  Bind.command(ApplyTweakCommand, this, &ClangdLSPServer::onCommandApplyTweak);
 
   ApplyWorkspaceEdit = Bind.outgoingMethod("workspace/applyEdit");
   PublishDiagnostics = Bind.outgoingNotification("textDocument/publishDiagnostics");
   ShowMessage = Bind.outgoingNotification("window/showMessage");
   NotifyFileStatus = Bind.outgoingNotification("textDocument/clangd.fileStatus");
   CreateWorkDoneProgress = Bind.outgoingMethod("window/workDoneProgress/create");
   BeginWorkDoneProgress = Bind.outgoingNotification("$/progress");
   ReportWorkDoneProgress = Bind.outgoingNotification("$/progress");

clang-tools-extra/clangd/SourceCode.cpp

 }
 
 bool isProtoFile(SourceLocation Loc, const SourceManager &SM) {
   auto FileName = SM.getFilename(Loc);
   if (!FileName.endswith(".proto.h") && !FileName.endswith(".pb.h"))
     return false;
   auto FID = SM.getFileID(Loc);
   // All proto generated headers should start with this line.
-  static const char *PROTO_HEADER_COMMENT =
+  static const char *ProtoHeaderComment =
       "// Generated by the protocol buffer compiler.  DO NOT EDIT!";
   // Double check that this is an actual protobuf header.
-  return SM.getBufferData(FID).startswith(PROTO_HEADER_COMMENT);
+  return SM.getBufferData(FID).startswith(ProtoHeaderComment);
 }
 
 namespace {
 
 // Is Line an #if or #ifdef directive?
 // FIXME: This makes headers with #ifdef LINUX/WINDOWS/MACOS marked as non
 // self-contained and is probably not what we want.
 bool isIf(llvm::StringRef Line) {

clang-tools-extra/clangd/TUScheduler.cpp

 namespace clang {
 namespace clangd {
 using std::chrono::steady_clock;
 
 namespace {
 class ASTWorker;
 } // namespace
 
-static clang::clangd::Key<std::string> kFileBeingProcessed;
+static clang::clangd::Key<std::string> KFileBeingProcessed;
 
 llvm::Optional<llvm::StringRef> TUScheduler::getFileBeingProcessedInContext() {
-  if (auto *File = Context::current().get(kFileBeingProcessed))
+  if (auto *File = Context::current().get(KFileBeingProcessed))
     return llvm::StringRef(*File);
   return None;
 }
 
 /// An LRU cache of idle ASTs.
 /// Because we want to limit the overall number of these we retain, the cache
 /// owns ASTs (and may evict them) while their workers are idle.
 /// Workers borrow ASTs when active, and return them when done.
if (Update && Update->ContentChanged) {
         if (R.InvalidationPolicy == TUScheduler::InvalidateOnUpdate)
           R.Invalidate();
         if (R.Update && R.Update->ContentChanged)
           break; // Older requests were already invalidated by the older update.
       }
     }
 
     // Allow this request to be cancelled if invalidated.
-    Context Ctx = Context::current().derive(kFileBeingProcessed, FileName);
+    Context Ctx = Context::current().derive(KFileBeingProcessed, FileName);
     Canceler Invalidate = nullptr;
     if (Invalidation) {
       WithContext WC(std::move(Ctx));
       std::tie(Ctx, Invalidate) = cancelableTask(
           /*Reason=*/static_cast<int>(ErrorCode::ContentModified));
     }
     // Trace the time the request spends in the queue, and the requests that
     // it's going to wait for.
Action(InputsAndPreamble{It->second->Contents,
                              Preamble.get(), Signals.get()});
     return;
   }
 
   std::shared_ptr<const ASTWorker> Worker = It->second->Worker.lock();
   auto Task = [Worker, Consistency, Name = Name.str(), File = File.str(),
                Contents = It->second->Contents,
                Command = Worker->getCurrentCompileCommand(),
-               Ctx = Context::current().derive(kFileBeingProcessed,
+               Ctx = Context::current().derive(KFileBeingProcessed,
                                                std::string(File)),
                Action = std::move(Action), this]() mutable {
     ThreadCrashReporter ScopedReporter([&Name, &Contents, &Command]() {
       llvm::errs() << "Signalled during preamble action: " << Name << "\n";
       crashDumpCompileCommand(llvm::errs(), Command);
       crashDumpFileContents(llvm::errs(), Contents);
     });
     std::shared_ptr<const PreambleData> Preamble;

clang-tools-extra/clangd/XRefs.cpp

struct Visitor : ConstStmtVisitor<Visitor, QualType> {
         return S->getDestroyedType();
       }
       QualType VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *S) {
         return S->getDestroyedType();
       }
       QualType VisitCXXThrowExpr(const CXXThrowExpr *S) {
         return S->getSubExpr()->getType();
       }
-      QualType VisitCoyieldStmt(const CoyieldExpr *S) {
+      QualType visitCoyieldStmt(const CoyieldExpr *S) {
         return type(S->getOperand());
       }
       // Treat a designated initializer like a reference to the field.
       QualType VisitDesignatedInitExpr(const DesignatedInitExpr *S) {
         // In .foo.bar we want to jump to bar's type, so find *last* field.
         for (auto &D : llvm::reverse(S->designators()))
           if (D.isFieldDesignator())
             if (const auto *FD = D.getField())

clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp

if (!fromJSON(Item, Request, Root)) {
       Root.printErrorContext(Item, llvm::errs());
       exit(1);
     }
     Requests.push_back(Request);
   }
   return Requests;
 }
 
-static void MemQueries(benchmark::State &State) {
+static void memQueries(benchmark::State &State) {
   const auto Mem = buildMem();
   const auto Requests = extractQueriesFromLogs();
   for (auto _ : State)
     for (const auto &Request : Requests)
       Mem->fuzzyFind(Request, [](const Symbol &S) {});
 }
-BENCHMARK(MemQueries);
+BENCHMARK(memQueries);
 
-static void DexQueries(benchmark::State &State) {
+static void dexQueries(benchmark::State &State) {
   const auto Dex = buildDex();
   const auto Requests = extractQueriesFromLogs();
   for (auto _ : State)
     for (const auto &Request : Requests)
       Dex->fuzzyFind(Request, [](const Symbol &S) {});
 }
-BENCHMARK(DexQueries);
+BENCHMARK(dexQueries);
 
-static void DexBuild(benchmark::State &State) {
+static void dexBuild(benchmark::State &State) {
   for (auto _ : State)
     buildDex();
 }
-BENCHMARK(DexBuild);
+BENCHMARK(dexBuild);
 
 } // namespace
 } // namespace clangd
 } // namespace clang
 
 // FIXME(kbobyrev): Add index building time benchmarks.
 // FIXME(kbobyrev): Add memory consumption "benchmarks" by manually measuring
 // in-memory index size and reporting it as time.

clang-tools-extra/clangd/fuzzer/clangd-fuzzer.cpp

 
 #include "ClangdLSPServer.h"
 #include "ClangdServer.h"
 #include "support/ThreadsafeFS.h"
 #include <cstdio>
 
 using namespace clang::clangd;
 
-extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size) {
-  if (size == 0)
+extern "C" int LLVMFuzzerTestOneInput(uint8_t *Data, size_t Size) {
+  if (Size == 0)
     return 0;
 
   // fmemopen isn't portable, but I think we only run the fuzzer on Linux.
-  std::FILE *In = fmemopen(data, size, "r");
+  std::FILE *In = fmemopen(Data, Size, "r");
   auto Transport = newJSONTransport(In, llvm::nulls(),
                                     /*InMirror=*/nullptr, /*Pretty=*/false,
                                     /*Style=*/JSONStreamStyle::Delimited);
   RealThreadsafeFS FS;
   CodeCompleteOptions CCOpts;
   ClangdLSPServer::Options Opts;
   Opts.CodeComplete.EnableSnippets = false;
   Opts.UseDirBasedCDB = false;
 
   // Initialize and run ClangdLSPServer.
   ClangdLSPServer LSPServer(*Transport, FS, Opts);
   LSPServer.run();
   return 0;
 }

clang-tools-extra/clangd/index/YAMLSerialization.cpp

static void mapping(IO &IO, SymbolLocation &Value) {
     IO.mapRequired("Start", NStart->P);
     MappingNormalization<NormalizedPosition, SymbolLocation::Position> NEnd(
         IO, Value.End);
     IO.mapRequired("End", NEnd->P);
   }
 };
 
 template <> struct MappingTraits<SymbolInfo> {
-  static void mapping(IO &io, SymbolInfo &SymInfo) {
+  static void mapping(IO &Io, SymbolInfo &SymInfo) {
     // FIXME: expose other fields?
-    io.mapRequired("Kind", SymInfo.Kind);
-    io.mapRequired("Lang", SymInfo.Lang);
+    Io.mapRequired("Kind", SymInfo.Kind);
+    Io.mapRequired("Lang", SymInfo.Lang);
   }
 };
 
 template <>
 struct MappingTraits<clang::clangd::Symbol::IncludeHeaderWithReferences> {
-  static void mapping(IO &io,
+  static void mapping(IO &Io,
                       clang::clangd::Symbol::IncludeHeaderWithReferences &Inc) {
-    io.mapRequired("Header", Inc.IncludeHeader);
-    io.mapRequired("References", Inc.References);
+    Io.mapRequired("Header", Inc.IncludeHeader);
+    Io.mapRequired("References", Inc.References);
   }
 };
 
 template <> struct MappingTraits<Symbol> {
   static void mapping(IO &IO, Symbol &Sym) {
     MappingNormalization<NormalizedSymbolID, SymbolID> NSymbolID(IO, Sym.ID);
     MappingNormalization<NormalizedSymbolFlag, Symbol::SymbolFlag> NSymbolFlag(
         IO, Sym.Flags);

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

 using ::testing::ElementsAre;
 using ::testing::Not;
 using ::testing::Pair;
 using ::testing::UnorderedElementsAre;
 
 namespace clang {
 namespace clangd {
 
-MATCHER_P(Named, N, "") { return arg.Name == N; }
-MATCHER_P(QName, N, "") { return (arg.Scope + arg.Name).str() == N; }
-MATCHER(Declared, "") {
+MATCHER_P(named, N, "") { return arg.Name == N; }
+MATCHER_P(qName, N, "") { return (arg.Scope + arg.Name).str() == N; }
+MATCHER(declared, "") {
   return !StringRef(arg.CanonicalDeclaration.FileURI).empty();
 }
-MATCHER(Defined, "") { return !StringRef(arg.Definition.FileURI).empty(); }
-MATCHER_P(FileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
+MATCHER(defined, "") { return !StringRef(arg.Definition.FileURI).empty(); }
+MATCHER_P(fileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
 ::testing::Matcher<const RefSlab &>
-RefsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
+refsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
   return ElementsAre(::testing::Pair(_, UnorderedElementsAreArray(Matchers)));
 }
 // URI cannot be empty since it references keys in the IncludeGraph.
-MATCHER(EmptyIncludeNode, "") {
+MATCHER(emptyIncludeNode, "") {
   return arg.Flags == IncludeGraphNode::SourceFlag::None && !arg.URI.empty() &&
          arg.Digest == FileDigest{{0}} && arg.DirectIncludes.empty();
 }
 
-MATCHER(HadErrors, "") {
+MATCHER(hadErrors, "") {
   return arg.Flags & IncludeGraphNode::SourceFlag::HadErrors;
 }
 
-MATCHER_P(NumReferences, N, "") { return arg.References == N; }
+MATCHER_P(numReferences, N, "") { return arg.References == N; }
 
 class MemoryShardStorage : public BackgroundIndexStorage {
   mutable std::mutex StorageMu;
   llvm::StringMap<std::string> &Storage;
   size_t &CacheHits;
 
 public:
   MemoryShardStorage(llvm::StringMap<std::string> &Storage, size_t &CacheHits)
TEST_F(BackgroundIndexTest, Config) {
   // Index the two files.
   for (auto &Cmd : Cmds) {
     std::string FullPath = testPath(Cmd.Filename);
     CDB.setCompileCommand(FullPath, std::move(Cmd));
   }
   // Wait for both files to be indexed.
   ASSERT_TRUE(Idx.blockUntilIdleForTest());
   EXPECT_THAT(runFuzzyFind(Idx, ""),
-              UnorderedElementsAre(QName("foo"), QName("foo::two"),
-                                   QName("bar"), QName("bar::one")));
+              UnorderedElementsAre(qName("foo"), qName("foo::two"),
+                                   qName("bar"), qName("bar::one")));
 }
 
 TEST_F(BackgroundIndexTest, IndexTwoFiles) {
   MockFS FS;
   // a.h yields different symbols when included by A.cc vs B.cc.
   FS.Files[testPath("root/A.h")] = R"cpp(
       void common();
       void f_b();
TEST_F(BackgroundIndexTest, IndexTwoFiles) {
   tooling::CompileCommand Cmd;
   Cmd.Filename = testPath("root/A.cc");
   Cmd.Directory = testPath("root");
   Cmd.CommandLine = {"clang++", "-DA=1", testPath("root/A.cc")};
   CDB.setCompileCommand(testPath("root/A.cc"), Cmd);
 
   ASSERT_TRUE(Idx.blockUntilIdleForTest());
   EXPECT_THAT(runFuzzyFind(Idx, ""),
-              UnorderedElementsAre(AllOf(Named("common"), NumReferences(1U)),
-                                   AllOf(Named("A_CC"), NumReferences(0U)),
-                                   AllOf(Named("g"), NumReferences(1U)),
-                                   AllOf(Named("f_b"), Declared(),
-                                         Not(Defined()), NumReferences(0U))));
+              UnorderedElementsAre(AllOf(named("common"), numReferences(1U)),
+                                   AllOf(named("A_CC"), numReferences(0U)),
+                                   AllOf(named("g"), numReferences(1U)),
+                                   AllOf(named("f_b"), declared(),
+                                         Not(defined()), numReferences(0U))));
 
   Cmd.Filename = testPath("root/B.cc");
   Cmd.CommandLine = {"clang++", Cmd.Filename};
   CDB.setCompileCommand(testPath("root/B.cc"), Cmd);
 
   ASSERT_TRUE(Idx.blockUntilIdleForTest());
   // B_CC is dropped as we don't collect symbols from A.h in this compilation.
   EXPECT_THAT(runFuzzyFind(Idx, ""),
-              UnorderedElementsAre(AllOf(Named("common"), NumReferences(5U)),
-                                   AllOf(Named("A_CC"), NumReferences(0U)),
-                                   AllOf(Named("g"), NumReferences(1U)),
-                                   AllOf(Named("f_b"), Declared(), Defined(),
-                                         NumReferences(1U))));
+              UnorderedElementsAre(AllOf(named("common"), numReferences(5U)),
+                                   AllOf(named("A_CC"), numReferences(0U)),
+                                   AllOf(named("g"), numReferences(1U)),
+                                   AllOf(named("f_b"), declared(), defined(),
+                                         numReferences(1U))));
 
   auto Syms = runFuzzyFind(Idx, "common");
-  EXPECT_THAT(Syms, UnorderedElementsAre(Named("common")));
+  EXPECT_THAT(Syms, UnorderedElementsAre(named("common")));
   auto Common = *Syms.begin();
   EXPECT_THAT(getRefs(Idx, Common.ID),
-              RefsAre({FileURI("unittest:///root/A.h"),
-                       FileURI("unittest:///root/A.cc"),
-                       FileURI("unittest:///root/B.cc"),
-                       FileURI("unittest:///root/B.cc"),
-                       FileURI("unittest:///root/B.cc"),
-                       FileURI("unittest:///root/B.cc")}));
+              refsAre({fileURI("unittest:///root/A.h"),
+                       fileURI("unittest:///root/A.cc"),
+                       fileURI("unittest:///root/B.cc"),
+                       fileURI("unittest:///root/B.cc"),
+                       fileURI("unittest:///root/B.cc"),
+                       fileURI("unittest:///root/B.cc")}));
 }
 
 TEST_F(BackgroundIndexTest, MainFileRefs) {
   MockFS FS;
   FS.Files[testPath("root/A.h")] = R"cpp(
       void header_sym();
       )cpp";
   FS.Files[testPath("root/A.cc")] =
TEST_F(BackgroundIndexTest, MainFileRefs) {
   Cmd.Filename = testPath("root/A.cc");
   Cmd.Directory = testPath("root");
   Cmd.CommandLine = {"clang++", testPath("root/A.cc")};
   CDB.setCompileCommand(testPath("root/A.cc"), Cmd);
 
   ASSERT_TRUE(Idx.blockUntilIdleForTest());
   EXPECT_THAT(
       runFuzzyFind(Idx, ""),
-      UnorderedElementsAre(AllOf(Named("header_sym"), NumReferences(1U)),
-                           AllOf(Named("main_sym"), NumReferences(1U))));
+      UnorderedElementsAre(AllOf(named("header_sym"), numReferences(1U)),
+                           AllOf(named("main_sym"), numReferences(1U))));
 }
 
 TEST_F(BackgroundIndexTest, ShardStorageTest) {
   MockFS FS;
   FS.Files[testPath("root/A.h")] = R"cpp(
       void common();
       void f_b();
       class A_CC {};
       )cpp";
-  std::string A_CC = "";
+  std::string ACc = "";
   FS.Files[testPath("root/A.cc")] = R"cpp(
       #include "A.h"
       void g() { (void)common; }
       class B_CC : public A_CC {};
       )cpp";
 
   llvm::StringMap<std::string> Storage;
   size_t CacheHits = 0;
TEST_F(BackgroundIndexTest, ShardStorageTest) {
   }
   EXPECT_EQ(CacheHits, 2U); // Check both A.cc and A.h loaded from cache.
   EXPECT_EQ(Storage.size(), 2U);
 
   auto ShardHeader = MSS.loadShard(testPath("root/A.h"));
   EXPECT_NE(ShardHeader, nullptr);
   EXPECT_THAT(
       *ShardHeader->Symbols,
-      UnorderedElementsAre(Named("common"), Named("A_CC"),
-                           AllOf(Named("f_b"), Declared(), Not(Defined()))));
+      UnorderedElementsAre(named("common"), named("A_CC"),
+                           AllOf(named("f_b"), declared(), Not(defined()))));
   for (const auto &Ref : *ShardHeader->Refs)
     EXPECT_THAT(Ref.second,
-                UnorderedElementsAre(FileURI("unittest:///root/A.h")));
+                UnorderedElementsAre(fileURI("unittest:///root/A.h")));
 
   auto ShardSource = MSS.loadShard(testPath("root/A.cc"));
   EXPECT_NE(ShardSource, nullptr);
   EXPECT_THAT(*ShardSource->Symbols,
-              UnorderedElementsAre(Named("g"), Named("B_CC")));
+              UnorderedElementsAre(named("g"), named("B_CC")));
   for (const auto &Ref : *ShardSource->Refs)
     EXPECT_THAT(Ref.second,
-                UnorderedElementsAre(FileURI("unittest:///root/A.cc")));
+                UnorderedElementsAre(fileURI("unittest:///root/A.cc")));
 
   // The BaseOf relationship between A_CC and B_CC is stored in both the file
   // containing the definition of the subject (A_CC) and the file containing
   // the definition of the object (B_CC).
   SymbolID A = findSymbol(*ShardHeader->Symbols, "A_CC").ID;
   SymbolID B = findSymbol(*ShardSource->Symbols, "B_CC").ID;
   EXPECT_THAT(*ShardHeader->Relations,
               UnorderedElementsAre(Relation{A, RelationKind::BaseOf, B}));
   EXPECT_THAT(*ShardSource->Relations,
               UnorderedElementsAre(Relation{A, RelationKind::BaseOf, B}));
 }
 
 TEST_F(BackgroundIndexTest, DirectIncludesTest) {
   MockFS FS;
   FS.Files[testPath("root/B.h")] = "";
   FS.Files[testPath("root/A.h")] = R"cpp(
       #include "B.h"
       void common();
       void f_b();
       class A_CC {};
       )cpp";
-  std::string A_CC = "#include \"A.h\"\nvoid g() { (void)common; }";
-  FS.Files[testPath("root/A.cc")] = A_CC;
+  std::string ACc = "#include \"A.h\"\nvoid g() { (void)common; }";
+  FS.Files[testPath("root/A.cc")] = ACc;
 
   llvm::StringMap<std::string> Storage;
   size_t CacheHits = 0;
   MemoryShardStorage MSS(Storage, CacheHits);
 
   tooling::CompileCommand Cmd;
   Cmd.Filename = testPath("root/A.cc");
   Cmd.Directory = testPath("root");
TEST_F(BackgroundIndexTest, DirectIncludesTest) {
   EXPECT_TRUE(ShardSource->Sources);
   EXPECT_EQ(ShardSource->Sources->size(), 2U); // A.cc, A.h
   EXPECT_THAT(
       ShardSource->Sources->lookup("unittest:///root/A.cc").DirectIncludes,
       UnorderedElementsAre("unittest:///root/A.h"));
   EXPECT_NE(ShardSource->Sources->lookup("unittest:///root/A.cc").Digest,
             FileDigest{{0}});
   EXPECT_THAT(ShardSource->Sources->lookup("unittest:///root/A.h"),
-              EmptyIncludeNode());
+              emptyIncludeNode());
 
   auto ShardHeader = MSS.loadShard(testPath("root/A.h"));
   EXPECT_TRUE(ShardHeader->Sources);
   EXPECT_EQ(ShardHeader->Sources->size(), 2U); // A.h, B.h
   EXPECT_THAT(
       ShardHeader->Sources->lookup("unittest:///root/A.h").DirectIncludes,
       UnorderedElementsAre("unittest:///root/B.h"));
   EXPECT_NE(ShardHeader->Sources->lookup("unittest:///root/A.h").Digest,
             FileDigest{{0}});
   EXPECT_THAT(ShardHeader->Sources->lookup("unittest:///root/B.h"),
-              EmptyIncludeNode());
+              emptyIncludeNode());
 }
 
 TEST_F(BackgroundIndexTest, ShardStorageLoad) {
   MockFS FS;
   FS.Files[testPath("root/A.h")] = R"cpp(
       void common();
       void f_b();
       class A_CC {};
FS.Files[testPath("root/A.h")] = R"cpp(
     CDB.setCompileCommand(testPath("root/A.cc"), Cmd);
     ASSERT_TRUE(Idx.blockUntilIdleForTest());
   }
   EXPECT_EQ(CacheHits, 2U); // Check both A.cc and A.h loaded from cache.
 
   // Check if the new symbol has arrived.
   auto ShardHeader = MSS.loadShard(testPath("root/A.h"));
   EXPECT_NE(ShardHeader, nullptr);
-  EXPECT_THAT(*ShardHeader->Symbols, Contains(Named("A_CCnew")));
+  EXPECT_THAT(*ShardHeader->Symbols, Contains(named("A_CCnew")));
 
   // Change source.
   FS.Files[testPath("root/A.cc")] =
       "#include \"A.h\"\nvoid g() { (void)common; }\nvoid f_b() {}";
   {
     CacheHits = 0;
     OverlayCDB CDB(/*Base=*/nullptr);
     BackgroundIndex Idx(FS, CDB, [&](llvm::StringRef) { return &MSS; },
                         /*Opts=*/{});
     CDB.setCompileCommand(testPath("root/A.cc"), Cmd);
     ASSERT_TRUE(Idx.blockUntilIdleForTest());
   }
   EXPECT_EQ(CacheHits, 2U); // Check both A.cc and A.h loaded from cache.
 
   // Check if the new symbol has arrived.
   ShardHeader = MSS.loadShard(testPath("root/A.h"));
   EXPECT_NE(ShardHeader, nullptr);
-  EXPECT_THAT(*ShardHeader->Symbols, Contains(Named("A_CCnew")));
+  EXPECT_THAT(*ShardHeader->Symbols, Contains(named("A_CCnew")));
   auto ShardSource = MSS.loadShard(testPath("root/A.cc"));
   EXPECT_NE(ShardSource, nullptr);
   EXPECT_THAT(*ShardSource->Symbols,
-              Contains(AllOf(Named("f_b"), Declared(), Defined())));
+              Contains(AllOf(named("f_b"), declared(), defined())));
 }
 
 TEST_F(BackgroundIndexTest, ShardStorageEmptyFile) {
   MockFS FS;
   FS.Files[testPath("root/A.h")] = R"cpp(
       void common();
       void f_b();
       class A_CC {};
BackgroundIndex Idx(FS, CDB, [&](llvm::StringRef) { return &MSS; },
                         /*Opts=*/{});
     CDB.setCompileCommand(testPath("root/A.cc"), Cmd);
     ASSERT_TRUE(Idx.blockUntilIdleForTest());
   }
   EXPECT_EQ(CacheHits, 3U);
   ShardHeader = MSS.loadShard(testPath("root/B.h"));
   EXPECT_NE(ShardHeader, nullptr);
   EXPECT_THAT(*ShardHeader->Symbols,
-              Contains(AllOf(Named("new_func"), Declared(), Not(Defined()))));
+              Contains(AllOf(named("new_func"), declared(), Not(defined()))));
 }
 
 TEST_F(BackgroundIndexTest, NoDotsInAbsPath) {
   MockFS FS;
   llvm::StringMap<std::string> Storage;
   size_t CacheHits = 0;
   MemoryShardStorage MSS(Storage, CacheHits);
   OverlayCDB CDB(/*Base=*/nullptr);
TEST_F(BackgroundIndexTest, UncompilableFiles) {
   CDB.setCompileCommand(testPath("build/../A.cc"), Cmd);
   ASSERT_TRUE(Idx.blockUntilIdleForTest());
 
   EXPECT_THAT(Storage.keys(), ElementsAre(testPath("A.cc"), testPath("A.h"),
                                           testPath("B.h"), testPath("C.h")));
 
   {
     auto Shard = MSS.loadShard(testPath("A.cc"));
-    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("foo")));
+    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(named("foo")));
     EXPECT_THAT(Shard->Sources->keys(),
                 UnorderedElementsAre("unittest:///A.cc", "unittest:///A.h",
                                      "unittest:///B.h"));
-    EXPECT_THAT(Shard->Sources->lookup("unittest:///A.cc"), HadErrors());
+    EXPECT_THAT(Shard->Sources->lookup("unittest:///A.cc"), hadErrors());
   }
 
   {
     auto Shard = MSS.loadShard(testPath("A.h"));
-    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("foo")));
+    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(named("foo")));
     EXPECT_THAT(Shard->Sources->keys(),
                 UnorderedElementsAre("unittest:///A.h"));
-    EXPECT_THAT(Shard->Sources->lookup("unittest:///A.h"), HadErrors());
+    EXPECT_THAT(Shard->Sources->lookup("unittest:///A.h"), hadErrors());
   }
 
   {
     auto Shard = MSS.loadShard(testPath("B.h"));
-    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("asdf")));
+    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(named("asdf")));
     EXPECT_THAT(Shard->Sources->keys(),
                 UnorderedElementsAre("unittest:///B.h", "unittest:///C.h"));
-    EXPECT_THAT(Shard->Sources->lookup("unittest:///B.h"), HadErrors());
+    EXPECT_THAT(Shard->Sources->lookup("unittest:///B.h"), hadErrors());
   }
 
   {
     auto Shard = MSS.loadShard(testPath("C.h"));
     EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre());
     EXPECT_THAT(Shard->Sources->keys(),
                 UnorderedElementsAre("unittest:///C.h"));
-    EXPECT_THAT(Shard->Sources->lookup("unittest:///C.h"), HadErrors());
+    EXPECT_THAT(Shard->Sources->lookup("unittest:///C.h"), hadErrors());
   }
 }
 
 TEST_F(BackgroundIndexTest, CmdLineHash) {
   MockFS FS;
   llvm::StringMap<std::string> Storage;
   size_t CacheHits = 0;
   MemoryShardStorage MSS(Storage, CacheHits);

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

 using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::Field;
 using ::testing::IsEmpty;
 using ::testing::Matcher;
 using ::testing::UnorderedElementsAre;
 
 // Helpers for matching call hierarchy data structures.
-MATCHER_P(WithName, N, "") { return arg.name == N; }
-MATCHER_P(WithSelectionRange, R, "") { return arg.selectionRange == R; }
+MATCHER_P(withName, N, "") { return arg.name == N; }
+MATCHER_P(withSelectionRange, R, "") { return arg.selectionRange == R; }
 
 template <class ItemMatcher>
-::testing::Matcher<CallHierarchyIncomingCall> From(ItemMatcher M) {
+::testing::Matcher<CallHierarchyIncomingCall> from(ItemMatcher M) {
   return Field(&CallHierarchyIncomingCall::from, M);
 }
 template <class... RangeMatchers>
-::testing::Matcher<CallHierarchyIncomingCall> FromRanges(RangeMatchers... M) {
+::testing::Matcher<CallHierarchyIncomingCall> fromRanges(RangeMatchers... M) {
   return Field(&CallHierarchyIncomingCall::fromRanges,
                UnorderedElementsAre(M...));
 }
 
 TEST(CallHierarchy, IncomingOneFileCpp) {
   Annotations Source(R"cpp(
     void call^ee(int);
     void caller1() {
Annotations Source(R"cpp(
     }
   )cpp");
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
   auto Index = TU.index();
 
   std::vector<CallHierarchyItem> Items =
       prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
-  ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+  ASSERT_THAT(Items, ElementsAre(withName("callee")));
   auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
   ASSERT_THAT(IncomingLevel1,
-              ElementsAre(AllOf(From(WithName("caller1")),
-                                FromRanges(Source.range("Callee")))));
+              ElementsAre(AllOf(from(withName("caller1")),
+                                fromRanges(Source.range("Callee")))));
   auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
   ASSERT_THAT(IncomingLevel2,
-              ElementsAre(AllOf(From(WithName("caller2")),
-                                FromRanges(Source.range("Caller1A"),
+              ElementsAre(AllOf(from(withName("caller2")),
+                                fromRanges(Source.range("Caller1A"),
                                            Source.range("Caller1B"))),
-                          AllOf(From(WithName("caller3")),
-                                FromRanges(Source.range("Caller1C")))));
+                          AllOf(from(withName("caller3")),
+                                fromRanges(Source.range("Caller1C")))));
 
   auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
   ASSERT_THAT(IncomingLevel3,
-              ElementsAre(AllOf(From(WithName("caller3")),
-                                FromRanges(Source.range("Caller2")))));
+              ElementsAre(AllOf(from(withName("caller3")),
+                                fromRanges(Source.range("Caller2")))));
 
   auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
   EXPECT_THAT(IncomingLevel4, IsEmpty());
 }
 
 TEST(CallHierarchy, IncomingOneFileObjC) {
   Annotations Source(R"objc(
     @implementation MyClass {}
Annotations Source(R"objc(
     @end
   )objc");
   TestTU TU = TestTU::withCode(Source.code());
   TU.Filename = "TestTU.m";
   auto AST = TU.build();
   auto Index = TU.index();
   std::vector<CallHierarchyItem> Items =
       prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
-  ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+  ASSERT_THAT(Items, ElementsAre(withName("callee")));
   auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
   ASSERT_THAT(IncomingLevel1,
-              ElementsAre(AllOf(From(WithName("caller1")),
-                                FromRanges(Source.range("Callee")))));
+              ElementsAre(AllOf(from(withName("caller1")),
+                                fromRanges(Source.range("Callee")))));
   auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
   ASSERT_THAT(IncomingLevel2,
-              ElementsAre(AllOf(From(WithName("caller2")),
-                                FromRanges(Source.range("Caller1A"),
+              ElementsAre(AllOf(from(withName("caller2")),
+                                fromRanges(Source.range("Caller1A"),
                                            Source.range("Caller1B"))),
-                          AllOf(From(WithName("caller3")),
-                                FromRanges(Source.range("Caller1C")))));
+                          AllOf(from(withName("caller3")),
+                                fromRanges(Source.range("Caller1C")))));
 
   auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
   ASSERT_THAT(IncomingLevel3,
-              ElementsAre(AllOf(From(WithName("caller3")),
-                                FromRanges(Source.range("Caller2")))));
+              ElementsAre(AllOf(from(withName("caller3")),
+                                fromRanges(Source.range("Caller2")))));
 
   auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
   EXPECT_THAT(IncomingLevel4, IsEmpty());
 }
 
 TEST(CallHierarchy, MainFileOnlyRef) {
   // In addition to testing that we store refs to main-file only symbols,
   // this tests that anonymous namespaces do not interfere with the
Annotations Source(R"cpp(
     }
   )cpp");
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
   auto Index = TU.index();
 
   std::vector<CallHierarchyItem> Items =
       prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
-  ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+  ASSERT_THAT(Items, ElementsAre(withName("callee")));
   auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
   ASSERT_THAT(IncomingLevel1,
-              ElementsAre(AllOf(From(WithName("caller1")),
-                                FromRanges(Source.range("Callee")))));
+              ElementsAre(AllOf(from(withName("caller1")),
+                                fromRanges(Source.range("Callee")))));
 
   auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
   EXPECT_THAT(IncomingLevel2,
-              ElementsAre(AllOf(From(WithName("caller2")),
-                                FromRanges(Source.range("Caller1")))));
+              ElementsAre(AllOf(from(withName("caller2")),
+                                fromRanges(Source.range("Caller1")))));
 }
 
 TEST(CallHierarchy, IncomingQualified) {
   Annotations Source(R"cpp(
     namespace ns {
     struct Waldo {
       void find();
     };
     void Waldo::find() {}
     void caller1(Waldo &W) {
       W.$Caller1[[f^ind]]();
     }
     void caller2(Waldo &W) {
       W.$Caller2[[find]]();
     }
     }
   )cpp");
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
   auto Index = TU.index();
 
   std::vector<CallHierarchyItem> Items =
       prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
-  ASSERT_THAT(Items, ElementsAre(WithName("Waldo::find")));
+  ASSERT_THAT(Items, ElementsAre(withName("Waldo::find")));
   auto Incoming = incomingCalls(Items[0], Index.get());
   EXPECT_THAT(Incoming,
-              ElementsAre(AllOf(From(WithName("caller1")),
-                                FromRanges(Source.range("Caller1"))),
-                          AllOf(From(WithName("caller2")),
-                                FromRanges(Source.range("Caller2")))));
+              ElementsAre(AllOf(from(withName("caller1")),
+                                fromRanges(Source.range("Caller1"))),
+                          AllOf(from(withName("caller2")),
+                                fromRanges(Source.range("Caller2")))));
 }
 
 TEST(CallHierarchy, IncomingMultiFileCpp) {
   // The test uses a .hh suffix for header files to get clang
   // to parse them in C++ mode. .h files are parsed in C mode
   // by default, which causes problems because e.g. symbol
   // USRs are different in C mode (do not include function signatures).
 
TEST(CallHierarchy, IncomingMultiFileCpp) {
   Workspace.addMainFile("caller2.cc", Caller2C.code());
   Workspace.addMainFile("caller3.cc", Caller3C.code());
 
   auto Index = Workspace.index();
 
   auto CheckCallHierarchy = [&](ParsedAST &AST, Position Pos, PathRef TUPath) {
     std::vector<CallHierarchyItem> Items =
         prepareCallHierarchy(AST, Pos, TUPath);
-    ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+    ASSERT_THAT(Items, ElementsAre(withName("callee")));
     auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
     ASSERT_THAT(IncomingLevel1,
-                ElementsAre(AllOf(From(WithName("caller1")),
-                                  FromRanges(Caller1C.range()))));
+                ElementsAre(AllOf(from(withName("caller1")),
+                                  fromRanges(Caller1C.range()))));
 
     auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
     ASSERT_THAT(
         IncomingLevel2,
-        ElementsAre(AllOf(From(WithName("caller2")),
-                          FromRanges(Caller2C.range("A"), Caller2C.range("B"))),
-                    AllOf(From(WithName("caller3")),
-                          FromRanges(Caller3C.range("Caller1")))));
+        ElementsAre(AllOf(from(withName("caller2")),
+                          fromRanges(Caller2C.range("A"), Caller2C.range("B"))),
+                    AllOf(from(withName("caller3")),
+                          fromRanges(Caller3C.range("Caller1")))));
 
     auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
     ASSERT_THAT(IncomingLevel3,
-                ElementsAre(AllOf(From(WithName("caller3")),
-                                  FromRanges(Caller3C.range("Caller2")))));
+                ElementsAre(AllOf(from(withName("caller3")),
+                                  fromRanges(Caller3C.range("Caller2")))));
 
     auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
     EXPECT_THAT(IncomingLevel4, IsEmpty());
   };
 
   // Check that invoking from a call site works.
   auto AST = Workspace.openFile("caller1.cc");
   ASSERT_TRUE(bool(AST));
TEST(CallHierarchy, IncomingMultiFileObjC) {
   Workspace.addMainFile("caller1.m", Caller1C.code());
   Workspace.addMainFile("caller2.m", Caller2C.code());
   Workspace.addMainFile("caller3.m", Caller3C.code());
   auto Index = Workspace.index();
 
   auto CheckCallHierarchy = [&](ParsedAST &AST, Position Pos, PathRef TUPath) {
     std::vector<CallHierarchyItem> Items =
         prepareCallHierarchy(AST, Pos, TUPath);
-    ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+    ASSERT_THAT(Items, ElementsAre(withName("callee")));
     auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
     ASSERT_THAT(IncomingLevel1,
-                ElementsAre(AllOf(From(WithName("caller1")),
-                                  FromRanges(Caller1C.range()))));
+                ElementsAre(AllOf(from(withName("caller1")),
+                                  fromRanges(Caller1C.range()))));
 
     auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
     ASSERT_THAT(
         IncomingLevel2,
-        ElementsAre(AllOf(From(WithName("caller2")),
-                          FromRanges(Caller2C.range("A"), Caller2C.range("B"))),
-                    AllOf(From(WithName("caller3")),
-                          FromRanges(Caller3C.range("Caller1")))));
+        ElementsAre(AllOf(from(withName("caller2")),
+                          fromRanges(Caller2C.range("A"), Caller2C.range("B"))),
+                    AllOf(from(withName("caller3")),
+                          fromRanges(Caller3C.range("Caller1")))));
 
     auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
     ASSERT_THAT(IncomingLevel3,
-                ElementsAre(AllOf(From(WithName("caller3")),
-                                  FromRanges(Caller3C.range("Caller2")))));
+                ElementsAre(AllOf(from(withName("caller3")),
+                                  fromRanges(Caller3C.range("Caller2")))));
 
     auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
     EXPECT_THAT(IncomingLevel4, IsEmpty());
   };
 
   // Check that invoking from a call site works.
   auto AST = Workspace.openFile("caller1.m");
   ASSERT_TRUE(bool(AST));
Annotations Source(R"cpp(
     int caller3 = $call3[[callee]]();
   )cpp");
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
   auto Index = TU.index();
 
   std::vector<CallHierarchyItem> Items =
       prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
-  ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+  ASSERT_THAT(Items, ElementsAre(withName("callee")));
 
   auto Incoming = incomingCalls(Items[0], Index.get());
   ASSERT_THAT(
       Incoming,
       ElementsAre(
-          AllOf(From(WithName("caller1")), FromRanges(Source.range("call1"))),
-          AllOf(From(WithName("caller2")), FromRanges(Source.range("call2"))),
-          AllOf(From(WithName("caller3")), FromRanges(Source.range("call3")))));
+          AllOf(from(withName("caller1")), fromRanges(Source.range("call1"))),
+          AllOf(from(withName("caller2")), fromRanges(Source.range("call2"))),
+          AllOf(from(withName("caller3")), fromRanges(Source.range("call3")))));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 using llvm::Succeeded;
 using testing::ElementsAre;
 
-MATCHER_P(DiagMessage, M, "") {
+MATCHER_P(diagMessage, M, "") {
   if (const auto *O = arg.getAsObject()) {
     if (const auto Msg = O->getString("message"))
       return *Msg == M;
   }
   return false;
 }
 
 class LSPTest : public ::testing::Test {
TEST_F(LSPTest, GoToDefinition) {
   EXPECT_EQ(Def.takeValue(), Want);
 }
 
 TEST_F(LSPTest, Diagnostics) {
   auto &Client = start();
   Client.didOpen("foo.cpp", "void main(int, char**);");
   EXPECT_THAT(Client.diagnostics("foo.cpp"),
               llvm::ValueIs(testing::ElementsAre(
-                  DiagMessage("'main' must return 'int' (fix available)"))));
+                  diagMessage("'main' must return 'int' (fix available)"))));
 
   Client.didChange("foo.cpp", "int x = \"42\";");
   EXPECT_THAT(Client.diagnostics("foo.cpp"),
               llvm::ValueIs(testing::ElementsAre(
-                  DiagMessage("Cannot initialize a variable of type 'int' with "
+                  diagMessage("Cannot initialize a variable of type 'int' with "
                               "an lvalue of type 'const char[3]'"))));
 
   Client.didClose("foo.cpp");
   EXPECT_THAT(Client.diagnostics("foo.cpp"), llvm::ValueIs(testing::IsEmpty()));
 }
 
 TEST_F(LSPTest, DiagnosticsHeaderSaved) {
   auto &Client = start();
   Client.didOpen("foo.cpp", R"cpp(
     #include "foo.h"
     int x = VAR;
   )cpp");
   EXPECT_THAT(Client.diagnostics("foo.cpp"),
               llvm::ValueIs(testing::ElementsAre(
-                  DiagMessage("'foo.h' file not found"),
-                  DiagMessage("Use of undeclared identifier 'VAR'"))));
+                  diagMessage("'foo.h' file not found"),
+                  diagMessage("Use of undeclared identifier 'VAR'"))));
   // Now create the header.
   FS.Files["foo.h"] = "#define VAR original";
   Client.notify(
       "textDocument/didSave",
       llvm::json::Object{{"textDocument", Client.documentID("foo.h")}});
   EXPECT_THAT(Client.diagnostics("foo.cpp"),
               llvm::ValueIs(testing::ElementsAre(
-                  DiagMessage("Use of undeclared identifier 'original'"))));
+                  diagMessage("Use of undeclared identifier 'original'"))));
   // Now modify the header from within the "editor".
   FS.Files["foo.h"] = "#define VAR changed";
   Client.notify(
       "textDocument/didSave",
       llvm::json::Object{{"textDocument", Client.documentID("foo.h")}});
   // Foo.cpp should be rebuilt with new diagnostics.
   EXPECT_THAT(Client.diagnostics("foo.cpp"),
               llvm::ValueIs(testing::ElementsAre(
-                  DiagMessage("Use of undeclared identifier 'changed'"))));
+                  diagMessage("Use of undeclared identifier 'changed'"))));
 }
 
 TEST_F(LSPTest, RecordsLatencies) {
   trace::TestTracer Tracer;
   auto &Client = start();
   llvm::StringLiteral MethodName = "method_name";
   EXPECT_THAT(Tracer.takeMetric("lsp_latency", MethodName), testing::SizeIs(0));
   llvm::consumeError(Client.call(MethodName, {}).take().takeError());

 )yaml";
   FS.Files["bar/compile_flags.txt"] = "-DFOO=BAR";
 
   auto &Client = start();
   // foo.cpp gets parsed as normal.
   Client.didOpen("foo.cpp", "int x = FOO;");
   EXPECT_THAT(Client.diagnostics("foo.cpp"),
               llvm::ValueIs(testing::ElementsAre(
-                  DiagMessage("Use of undeclared identifier 'FOO'"))));
+                  diagMessage("Use of undeclared identifier 'FOO'"))));
   // bar.cpp shows the configured compile command.
   Client.didOpen("bar.cpp", "int x = FOO;");
   EXPECT_THAT(Client.diagnostics("bar.cpp"),
               llvm::ValueIs(testing::ElementsAre(
-                  DiagMessage("Use of undeclared identifier 'BAR'"))));
+                  diagMessage("Use of undeclared identifier 'BAR'"))));
 }
 
 TEST_F(LSPTest, ModulesTest) {
   class MathModule final : public FeatureModule {
     OutgoingNotification<int> Changed;
     void initializeLSP(LSPBinder &Bind, const llvm::json::Object &ClientCaps,
                        llvm::json::Object &ServerCaps) override {
       Bind.notification("add", this, &MathModule::add);
std::unique_ptr<ASTListener> astListeners() override {
       return std::make_unique<DiagHooks>();
     }
   };
   FeatureModules.add(std::make_unique<DiagModule>());
 
   auto &Client = start();
   Client.didOpen("foo.cpp", "test;");
   EXPECT_THAT(Client.diagnostics("foo.cpp"),
-              llvm::ValueIs(testing::ElementsAre(DiagMessage(DiagMsg))));
+              llvm::ValueIs(testing::ElementsAre(diagMessage(DiagMsg))));
 }
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 using ::testing::Field;
 using ::testing::HasSubstr;
 using ::testing::IsEmpty;
 using ::testing::Not;
 using ::testing::UnorderedElementsAre;
 using ContextKind = CodeCompletionContext::Kind;
 
 // GMock helpers for matching completion items.
-MATCHER_P(Named, Name, "") { return arg.Name == Name; }
-MATCHER_P(MainFileRefs, Refs, "") { return arg.MainFileRefs == Refs; }
-MATCHER_P(ScopeRefs, Refs, "") { return arg.ScopeRefsInFile == Refs; }
-MATCHER_P(NameStartsWith, Prefix, "") {
+MATCHER_P(named, Name, "") { return arg.Name == Name; }
+MATCHER_P(mainFileRefs, Refs, "") { return arg.MainFileRefs == Refs; }
+MATCHER_P(scopeRefs, Refs, "") { return arg.ScopeRefsInFile == Refs; }
+MATCHER_P(nameStartsWith, Prefix, "") {
   return llvm::StringRef(arg.Name).startswith(Prefix);
 }
-MATCHER_P(Scope, S, "") { return arg.Scope == S; }
-MATCHER_P(Qualifier, Q, "") { return arg.RequiredQualifier == Q; }
-MATCHER_P(Labeled, Label, "") {
+MATCHER_P(scope, S, "") { return arg.Scope == S; }
+MATCHER_P(qualifier, Q, "") { return arg.RequiredQualifier == Q; }
+MATCHER_P(labeled, Label, "") {
   return arg.RequiredQualifier + arg.Name + arg.Signature == Label;
 }
-MATCHER_P(SigHelpLabeled, Label, "") { return arg.label == Label; }
-MATCHER_P(Kind, K, "") { return arg.Kind == K; }
-MATCHER_P(Doc, D, "") {
+MATCHER_P(sigHelpLabeled, Label, "") { return arg.label == Label; }
+MATCHER_P(kind, K, "") { return arg.Kind == K; }
+MATCHER_P(doc, D, "") {
   return arg.Documentation && arg.Documentation->asPlainText() == D;
 }
-MATCHER_P(ReturnType, D, "") { return arg.ReturnType == D; }
-MATCHER_P(HasInclude, IncludeHeader, "") {
+MATCHER_P(returnType, D, "") { return arg.ReturnType == D; }
+MATCHER_P(hasInclude, IncludeHeader, "") {
   return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader;
 }
-MATCHER_P(InsertInclude, IncludeHeader, "") {
+MATCHER_P(insertInclude, IncludeHeader, "") {
   return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader &&
          bool(arg.Includes[0].Insertion);
 }
-MATCHER(InsertInclude, "") {
+MATCHER(insertInclude, "") {
   return !arg.Includes.empty() && bool(arg.Includes[0].Insertion);
 }
-MATCHER_P(SnippetSuffix, Text, "") { return arg.SnippetSuffix == Text; }
-MATCHER_P(Origin, OriginSet, "") { return arg.Origin == OriginSet; }
-MATCHER_P(Signature, S, "") { return arg.Signature == S; }
-
-// Shorthand for Contains(Named(Name)).
-Matcher<const std::vector<CodeCompletion> &> Has(std::string Name) {
-  return Contains(Named(std::move(Name)));
+MATCHER_P(snippetSuffix, Text, "") { return arg.SnippetSuffix == Text; }
+MATCHER_P(origin, OriginSet, "") { return arg.Origin == OriginSet; }
+MATCHER_P(signature, S, "") { return arg.Signature == S; }
+
+// Shorthand for Contains(named(Name)).
+Matcher<const std::vector<CodeCompletion> &> has(std::string Name) {
+  return Contains(named(std::move(Name)));
 }
-Matcher<const std::vector<CodeCompletion> &> Has(std::string Name,
+Matcher<const std::vector<CodeCompletion> &> has(std::string Name,
                                                  CompletionItemKind K) {
-  return Contains(AllOf(Named(std::move(Name)), Kind(K)));
+  return Contains(AllOf(named(std::move(Name)), kind(K)));
 }
-MATCHER(IsDocumented, "") { return arg.Documentation.hasValue(); }
-MATCHER(Deprecated, "") { return arg.Deprecated; }
+MATCHER(isDocumented, "") { return arg.Documentation.hasValue(); }
+MATCHER(deprecated, "") { return arg.Deprecated; }
 
 std::unique_ptr<SymbolIndex> memIndex(std::vector<Symbol> Symbols) {
   SymbolSlab::Builder Slab;
   for (const auto &Sym : Symbols)
     Slab.insert(Sym);
   return MemIndex::build(std::move(Slab).build(), RefSlab(), RelationSlab());
 }
 

 struct MemberAccess {
   int ABG();
   int AlphaBetaGamma();
 };
 int func() { MemberAccess().ABG^ }
 )cpp",
       /*IndexSymbols=*/{}, Opts);
   EXPECT_THAT(Results.Completions,
-              ElementsAre(Named("ABG"), Named("AlphaBetaGamma")));
+              ElementsAre(named("ABG"), named("AlphaBetaGamma")));
 }
 
 TEST(DecisionForestRankingModel, ReferencesAffectRanking) {
   clangd::CodeCompleteOptions Opts;
   Opts.RankingModel = CodeCompleteOptions::DecisionForest;
   constexpr int NumReferences = 100000;
   EXPECT_THAT(
       completions("int main() { clang^ }",
                   {ns("clangA"), withReferences(NumReferences, func("clangD"))},
                   Opts)
           .Completions,
-      ElementsAre(Named("clangD"), Named("clangA")));
+      ElementsAre(named("clangD"), named("clangA")));
   EXPECT_THAT(
       completions("int main() { clang^ }",
                   {withReferences(NumReferences, ns("clangA")), func("clangD")},
                   Opts)
           .Completions,
-      ElementsAre(Named("clangA"), Named("clangD")));
+      ElementsAre(named("clangA"), named("clangD")));
 }
 
 TEST(DecisionForestRankingModel, DecisionForestScorerCallbackTest) {
   clangd::CodeCompleteOptions Opts;
   constexpr float MagicNumber = 1234.5678f;
   Opts.RankingModel = CodeCompleteOptions::DecisionForest;
   Opts.DecisionForestScorer = [&](const SymbolQualitySignals &,
                                   const SymbolRelevanceSignals &, float Base) {
struct ClassWithMembers {
   int CCC();
 };
 
 int main() { ClassWithMembers().^ }
       )cpp",
                              /*IndexSymbols=*/{}, Opts);
 
   EXPECT_TRUE(Results.HasMore);
-  EXPECT_THAT(Results.Completions, ElementsAre(Named("AAA"), Named("BBB")));
+  EXPECT_THAT(Results.Completions, ElementsAre(named("AAA"), named("BBB")));
 }
 
 TEST(CompletionTest, Filter) {
   std::string Body = R"cpp(
     #define MotorCar
     int Car;
     struct S {
       int FooBar;
       int FooBaz;
       int Qux;
     };
   )cpp";
 
   // Only items matching the fuzzy query are returned.
   EXPECT_THAT(completions(Body + "int main() { S().Foba^ }").Completions,
-              AllOf(Has("FooBar"), Has("FooBaz"), Not(Has("Qux"))));
+              AllOf(has("FooBar"), has("FooBaz"), Not(has("Qux"))));
 
   // Macros require prefix match, either from index or AST.
   Symbol Sym = var("MotorCarIndex");
   Sym.SymInfo.Kind = index::SymbolKind::Macro;
   EXPECT_THAT(
       completions(Body + "int main() { C^ }", {Sym}).Completions,
-      AllOf(Has("Car"), Not(Has("MotorCar")), Not(Has("MotorCarIndex"))));
+      AllOf(has("Car"), Not(has("MotorCar")), Not(has("MotorCarIndex"))));
   EXPECT_THAT(completions(Body + "int main() { M^ }", {Sym}).Completions,
-              AllOf(Has("MotorCar"), Has("MotorCarIndex")));
+              AllOf(has("MotorCar"), has("MotorCarIndex")));
 }
 
 void testAfterDotCompletion(clangd::CodeCompleteOptions Opts) {
   auto Results = completions(
       R"cpp(
       int global_var;
 
       int global_func();
 
       // Make sure this is not in preamble.
       #define MACRO X
 
       struct GlobalClass {};
 
       struct ClassWithMembers {
-        /// Doc for method.
+        /// doc for method.
         int method();
 
         int field;
       private:
         int private_field;
       };
 
       int test() {
         struct LocalClass {};
 
-        /// Doc for local_var.
+        /// doc for local_var.
         int local_var;
 
         ClassWithMembers().^
       }
       )cpp",
       {cls("IndexClass"), var("index_var"), func("index_func")}, Opts);
 
   EXPECT_TRUE(Results.RanParser);
   // Class members. The only items that must be present in after-dot
   // completion.
   EXPECT_THAT(Results.Completions,
-              AllOf(Has("method"), Has("field"), Not(Has("ClassWithMembers")),
-                    Not(Has("operator=")), Not(Has("~ClassWithMembers"))));
+              AllOf(has("method"), has("field"), Not(has("ClassWithMembers")),
+                    Not(has("operator=")), Not(has("~ClassWithMembers"))));
   EXPECT_IFF(Opts.IncludeIneligibleResults, Results.Completions,
-             Has("private_field"));
+             has("private_field"));
   // Global items.
   EXPECT_THAT(
       Results.Completions,
-      Not(AnyOf(Has("global_var"), Has("index_var"), Has("global_func"),
-                Has("global_func()"), Has("index_func"), Has("GlobalClass"),
-                Has("IndexClass"), Has("MACRO"), Has("LocalClass"))));
+      Not(AnyOf(has("global_var"), has("index_var"), has("global_func"),
+                has("global_func()"), has("index_func"), has("GlobalClass"),
+                has("IndexClass"), has("MACRO"), has("LocalClass"))));
   // There should be no code patterns (aka snippets) in after-dot
   // completion. At least there aren't any we're aware of.
   EXPECT_THAT(Results.Completions,
-              Not(Contains(Kind(CompletionItemKind::Snippet))));
+              Not(Contains(kind(CompletionItemKind::Snippet))));
   // Check documentation.
-  EXPECT_THAT(Results.Completions, Contains(IsDocumented()));
+  EXPECT_THAT(Results.Completions, Contains(isDocumented()));
 }
 
 void testGlobalScopeCompletion(clangd::CodeCompleteOptions Opts) {
   auto Results = completions(
       R"cpp(
       int global_var;
       int global_func();
 
       // Make sure this is not in preamble.
       #define MACRO X
 
       struct GlobalClass {};
 
       struct ClassWithMembers {
-        /// Doc for method.
+        /// doc for method.
         int method();
       };
 
       int test() {
         struct LocalClass {};
 
-        /// Doc for local_var.
+        /// doc for local_var.
         int local_var;
 
         ^
       }
       )cpp",
       {cls("IndexClass"), var("index_var"), func("index_func")}, Opts);
 
   EXPECT_TRUE(Results.RanParser);
   // Class members. Should never be present in global completions.
   EXPECT_THAT(Results.Completions,
-              Not(AnyOf(Has("method"), Has("method()"), Has("field"))));
+              Not(AnyOf(has("method"), has("method()"), has("field"))));
   // Global items.
   EXPECT_THAT(Results.Completions,
-              AllOf(Has("global_var"), Has("index_var"), Has("global_func"),
-                    Has("index_func" /* our fake symbol doesn't include () */),
-                    Has("GlobalClass"), Has("IndexClass")));
+              AllOf(has("global_var"), has("index_var"), has("global_func"),
+                    has("index_func" /* our fake symbol doesn't include () */),
+                    has("GlobalClass"), has("IndexClass")));
   // A macro.
-  EXPECT_THAT(Results.Completions, Has("MACRO"));
+  EXPECT_THAT(Results.Completions, has("MACRO"));
   // Local items. Must be present always.
   EXPECT_THAT(Results.Completions,
-              AllOf(Has("local_var"), Has("LocalClass"),
-                    Contains(Kind(CompletionItemKind::Snippet))));
+              AllOf(has("local_var"), has("LocalClass"),
+                    Contains(kind(CompletionItemKind::Snippet))));
   // Check documentation.
-  EXPECT_THAT(Results.Completions, Contains(IsDocumented()));
+  EXPECT_THAT(Results.Completions, Contains(isDocumented()));
 }
 
 TEST(CompletionTest, CompletionOptions) {
   auto Test = [&](const clangd::CodeCompleteOptions &Opts) {
     testAfterDotCompletion(Opts);
     testGlobalScopeCompletion(Opts);
   };
   // We used to test every combination of options, but that got too slow (2^N).
auto Internal = completions(R"cpp(
       class Foo {
         public: void pub();
         protected: void prot();
         private: void priv();
       };
       void Foo::pub() { this->^ }
   )cpp");
   EXPECT_THAT(Internal.Completions,
-              AllOf(Has("priv"), Has("prot"), Has("pub")));
+              AllOf(has("priv"), has("prot"), has("pub")));
 
   auto External = completions(R"cpp(
       class Foo {
         public: void pub();
         protected: void prot();
         private: void priv();
       };
       void test() {
         Foo F;
         F.^
       }
   )cpp");
   EXPECT_THAT(External.Completions,
-              AllOf(Has("pub"), Not(Has("prot")), Not(Has("priv"))));
+              AllOf(has("pub"), Not(has("prot")), Not(has("priv"))));
 }
 
 TEST(CompletionTest, Qualifiers) {
   auto Results = completions(R"cpp(
       class Foo {
         public: int foo() const;
         int bar() const;
       };
       class Bar : public Foo {
         int foo() const;
       };
       void test() { Bar().^ }
   )cpp");
   EXPECT_THAT(Results.Completions,
-              Contains(AllOf(Qualifier(""), Named("bar"))));
+              Contains(AllOf(qualifier(""), named("bar"))));
   // Hidden members are not shown.
   EXPECT_THAT(Results.Completions,
-              Not(Contains(AllOf(Qualifier("Foo::"), Named("foo")))));
+              Not(Contains(AllOf(qualifier("Foo::"), named("foo")))));
   // Private members are not shown.
   EXPECT_THAT(Results.Completions,
-              Not(Contains(AllOf(Qualifier(""), Named("foo")))));
+              Not(Contains(AllOf(qualifier(""), named("foo")))));
 }
 
 TEST(CompletionTest, InjectedTypename) {
   // These are suppressed when accessed as a member...
   EXPECT_THAT(completions("struct X{}; void foo(){ X().^ }").Completions,
-              Not(Has("X")));
+              Not(has("X")));
   EXPECT_THAT(completions("struct X{ void foo(){ this->^ } };").Completions,
-              Not(Has("X")));
+              Not(has("X")));
   // ...but accessible in other, more useful cases.
   EXPECT_THAT(completions("struct X{ void foo(){ ^ } };").Completions,
-              Has("X"));
+              has("X"));
   EXPECT_THAT(
       completions("struct Y{}; struct X:Y{ void foo(){ ^ } };").Completions,
-      Has("Y"));
+      has("Y"));
   EXPECT_THAT(
       completions(
           "template<class> struct Y{}; struct X:Y<int>{ void foo(){ ^ } };")
           .Completions,
-      Has("Y"));
+      has("Y"));
   // This case is marginal (`using X::X` is useful), we allow it for now.
   EXPECT_THAT(completions("struct X{}; void foo(){ X::^ }").Completions,
-              Has("X"));
+              has("X"));
 }
 
 TEST(CompletionTest, SkipInjectedWhenUnqualified) {
   EXPECT_THAT(completions("struct X { void f() { X^ }};").Completions,
-              ElementsAre(Named("X"), Named("~X")));
+              ElementsAre(named("X"), named("~X")));
 }
 
 TEST(CompletionTest, Snippets) {
   clangd::CodeCompleteOptions Opts;
   auto Results = completions(
       R"cpp(
       struct fake {
         int a;
         int f(int i, const float f) const;
       };
       int main() {
         fake f;
         f.^
       }
       )cpp",
       /*IndexSymbols=*/{}, Opts);
   EXPECT_THAT(
       Results.Completions,
-      HasSubsequence(Named("a"),
-                     SnippetSuffix("(${1:int i}, ${2:const float f})")));
+      HasSubsequence(named("a"),
+                     snippetSuffix("(${1:int i}, ${2:const float f})")));
 }
 
 TEST(CompletionTest, NoSnippetsInUsings) {
   clangd::CodeCompleteOptions Opts;
   Opts.EnableSnippets = true;
   auto Results = completions(
       R"cpp(
       namespace ns {
         int func(int a, int b);
       }
 
       using ns::^;
       )cpp",
       /*IndexSymbols=*/{}, Opts);
   EXPECT_THAT(Results.Completions,
-              ElementsAre(AllOf(Named("func"), Labeled("func(int a, int b)"),
-                                SnippetSuffix(""))));
+              ElementsAre(AllOf(named("func"), labeled("func(int a, int b)"),
+                                snippetSuffix(""))));
 
   // Check index completions too.
   auto Func = func("ns::func");
   Func.CompletionSnippetSuffix = "(${1:int a}, ${2: int b})";
   Func.Signature = "(int a, int b)";
   Func.ReturnType = "void";
 
   Results = completions(R"cpp(
       namespace ns {}
       using ns::^;
   )cpp",
                         /*IndexSymbols=*/{Func}, Opts);
   EXPECT_THAT(Results.Completions,
-              ElementsAre(AllOf(Named("func"), Labeled("func(int a, int b)"),
-                                SnippetSuffix(""))));
+              ElementsAre(AllOf(named("func"), labeled("func(int a, int b)"),
+                                snippetSuffix(""))));
 
   // Check all-scopes completions too.
   Opts.AllScopes = true;
   Results = completions(R"cpp(
       using ^;
   )cpp",
                         /*IndexSymbols=*/{Func}, Opts);
   EXPECT_THAT(Results.Completions,
-              Contains(AllOf(Named("func"), Labeled("ns::func(int a, int b)"),
-                             SnippetSuffix(""))));
+              Contains(AllOf(named("func"), labeled("ns::func(int a, int b)"),
+                             snippetSuffix(""))));
 }
 
 TEST(CompletionTest, Kinds) {
   auto Results = completions(
       R"cpp(
           int variable;
           struct Struct {};
           int function();
           // make sure MACRO is not included in preamble.
           #define MACRO 10
           int X = ^
       )cpp",
       {func("indexFunction"), var("indexVariable"), cls("indexClass")});
   EXPECT_THAT(Results.Completions,
-              AllOf(Has("function", CompletionItemKind::Function),
-                    Has("variable", CompletionItemKind::Variable),
-                    Has("int", CompletionItemKind::Keyword),
-                    Has("Struct", CompletionItemKind::Struct),
-                    Has("MACRO", CompletionItemKind::Text),
-                    Has("indexFunction", CompletionItemKind::Function),
-                    Has("indexVariable", CompletionItemKind::Variable),
-                    Has("indexClass", CompletionItemKind::Class)));
+              AllOf(has("function", CompletionItemKind::Function),
+                    has("variable", CompletionItemKind::Variable),
+                    has("int", CompletionItemKind::Keyword),
+                    has("Struct", CompletionItemKind::Struct),
+                    has("MACRO", CompletionItemKind::Text),
+                    has("indexFunction", CompletionItemKind::Function),
+                    has("indexVariable", CompletionItemKind::Variable),
+                    has("indexClass", CompletionItemKind::Class)));
 
   Results = completions("nam^");
   EXPECT_THAT(Results.Completions,
-              Has("namespace", CompletionItemKind::Snippet));
+              has("namespace", CompletionItemKind::Snippet));
 
   // Members of anonymous unions are of kind 'field'.
   Results = completions(
       R"cpp(
         struct X{
             union {
               void *a;
             };
         };
         auto u = X().^
       )cpp");
   EXPECT_THAT(
       Results.Completions,
-      UnorderedElementsAre(AllOf(Named("a"), Kind(CompletionItemKind::Field))));
+      UnorderedElementsAre(AllOf(named("a"), kind(CompletionItemKind::Field))));
 
   // Completion kinds for templates should not be unknown.
   Results = completions(
       R"cpp(
         template <class T> struct complete_class {};
         template <class T> void complete_function();
         template <class T> using complete_type_alias = int;
         template <class T> int complete_variable = 10;
 
         struct X {
           template <class T> static int complete_static_member = 10;
 
           static auto x = complete_^
         }
       )cpp");
   EXPECT_THAT(
       Results.Completions,
       UnorderedElementsAre(
-          AllOf(Named("complete_class"), Kind(CompletionItemKind::Class)),
-          AllOf(Named("complete_function"), Kind(CompletionItemKind::Function)),
-          AllOf(Named("complete_type_alias"),
-                Kind(CompletionItemKind::Interface)),
-          AllOf(Named("complete_variable"), Kind(CompletionItemKind::Variable)),
-          AllOf(Named("complete_static_member"),
-                Kind(CompletionItemKind::Property))));
+          AllOf(named("complete_class"), kind(CompletionItemKind::Class)),
+          AllOf(named("complete_function"), kind(CompletionItemKind::Function)),
+          AllOf(named("complete_type_alias"),
+                kind(CompletionItemKind::Interface)),
+          AllOf(named("complete_variable"), kind(CompletionItemKind::Variable)),
+          AllOf(named("complete_static_member"),
+                kind(CompletionItemKind::Property))));
 
   Results = completions(
       R"cpp(
         enum Color {
           Red
         };
         Color u = ^
       )cpp");
   EXPECT_THAT(
       Results.Completions,
-      Contains(AllOf(Named("Red"), Kind(CompletionItemKind::EnumMember))));
+      Contains(AllOf(named("Red"), kind(CompletionItemKind::EnumMember))));
 }
 
 TEST(CompletionTest, NoDuplicates) {
   auto Results = completions(
       R"cpp(
           class Adapter {
           };
 
           void f() {
             Adapter^
           }
       )cpp",
       {cls("Adapter")});
 
   // Make sure there are no duplicate entries of 'Adapter'.
-  EXPECT_THAT(Results.Completions, ElementsAre(Named("Adapter")));
+  EXPECT_THAT(Results.Completions, ElementsAre(named("Adapter")));
 }
 
 TEST(CompletionTest, ScopedNoIndex) {
   auto Results = completions(
       R"cpp(
           namespace fake { int BigBang, Babble, Box; };
           int main() { fake::ba^ }
       ")cpp");
   // Babble is a better match than BigBang. Box doesn't match at all.
   EXPECT_THAT(Results.Completions,
-              ElementsAre(Named("Babble"), Named("BigBang")));
+              ElementsAre(named("Babble"), named("BigBang")));
 }
 
 TEST(CompletionTest, Scoped) {
   auto Results = completions(
       R"cpp(
           namespace fake { int Babble, Box; };
           int main() { fake::ba^ }
       ")cpp",
       {var("fake::BigBang")});
   EXPECT_THAT(Results.Completions,
-              ElementsAre(Named("Babble"), Named("BigBang")));
+              ElementsAre(named("Babble"), named("BigBang")));
 }
 
 TEST(CompletionTest, ScopedWithFilter) {
   auto Results = completions(
       R"cpp(
           void f() { ns::x^ }
       )cpp",
       {cls("ns::XYZ"), func("ns::foo")});
-  EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("XYZ")));
+  EXPECT_THAT(Results.Completions, UnorderedElementsAre(named("XYZ")));
 }
 
 TEST(CompletionTest, ReferencesAffectRanking) {
   EXPECT_THAT(completions("int main() { abs^ }", {func("absA"), func("absB")})
                   .Completions,
-              HasSubsequence(Named("absA"), Named("absB")));
+              HasSubsequence(named("absA"), named("absB")));
   EXPECT_THAT(completions("int main() { abs^ }",
                           {func("absA"), withReferences(1000, func("absB"))})
                   .Completions,
-              HasSubsequence(Named("absB"), Named("absA")));
+              HasSubsequence(named("absB"), named("absA")));
 }
 
 TEST(CompletionTest, ContextWords) {
   auto Results = completions(R"cpp(
   enum class Color { RED, YELLOW, BLUE };
 
   // (blank lines so the definition above isn't "context")
 
   // "It was a yellow car," he said. "Big yellow car, new."
   auto Finish = Color::^
   )cpp");
   // Yellow would normally sort last (alphabetic).
   // But the recent mention should bump it up.
   ASSERT_THAT(Results.Completions,
-              HasSubsequence(Named("YELLOW"), Named("BLUE")));
+              HasSubsequence(named("YELLOW"), named("BLUE")));
 }
 
 TEST(CompletionTest, GlobalQualified) {
   auto Results = completions(
       R"cpp(
           void f() { ::^ }
       )cpp",
       {cls("XYZ")});
   EXPECT_THAT(Results.Completions,
-              AllOf(Has("XYZ", CompletionItemKind::Class),
-                    Has("f", CompletionItemKind::Function)));
+              AllOf(has("XYZ", CompletionItemKind::Class),
+                    has("f", CompletionItemKind::Function)));
 }
 
 TEST(CompletionTest, FullyQualified) {
   auto Results = completions(
       R"cpp(
           namespace ns { void bar(); }
           void f() { ::ns::^ }
       )cpp",
       {cls("ns::XYZ")});
   EXPECT_THAT(Results.Completions,
-              AllOf(Has("XYZ", CompletionItemKind::Class),
-                    Has("bar", CompletionItemKind::Function)));
+              AllOf(has("XYZ", CompletionItemKind::Class),
+                    has("bar", CompletionItemKind::Function)));
 }
 
 TEST(CompletionTest, SemaIndexMerge) {
   auto Results = completions(
       R"cpp(
           namespace ns { int local; void both(); }
           void f() { ::ns::^ }
       )cpp",
       {func("ns::both"), cls("ns::Index")});
   // We get results from both index and sema, with no duplicates.
   EXPECT_THAT(Results.Completions,
               UnorderedElementsAre(
-                  AllOf(Named("local"), Origin(SymbolOrigin::AST)),
-                  AllOf(Named("Index"), Origin(SymbolOrigin::Static)),
-                  AllOf(Named("both"),
-                        Origin(SymbolOrigin::AST | SymbolOrigin::Static))));
+                  AllOf(named("local"), origin(SymbolOrigin::AST)),
+                  AllOf(named("Index"), origin(SymbolOrigin::Static)),
+                  AllOf(named("both"),
+                        origin(SymbolOrigin::AST | SymbolOrigin::Static))));
 }
 
 TEST(CompletionTest, SemaIndexMergeWithLimit) {
   clangd::CodeCompleteOptions Opts;
   Opts.Limit = 1;
   auto Results = completions(
       R"cpp(
           namespace ns { int local; void both(); }
TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
   Symbol Sym = cls("ns::X");
   Sym.CanonicalDeclaration.FileURI = BarURI.c_str();
   Sym.IncludeHeaders.emplace_back(BarURI, 1);
   // Shorten include path based on search directory and insert.
   Annotations Test("int main() { ns::^ }");
   TU.Code = Test.code().str();
   auto Results = completions(TU, Test.point(), {Sym});
   EXPECT_THAT(Results.Completions,
-              ElementsAre(AllOf(Named("X"), InsertInclude("\"bar.h\""))));
+              ElementsAre(AllOf(named("X"), insertInclude("\"bar.h\""))));
   // Can be disabled via option.
   CodeCompleteOptions NoInsertion;
   NoInsertion.InsertIncludes = CodeCompleteOptions::NeverInsert;
   Results = completions(TU, Test.point(), {Sym}, NoInsertion);
   EXPECT_THAT(Results.Completions,
-              ElementsAre(AllOf(Named("X"), Not(InsertInclude()))));
+              ElementsAre(AllOf(named("X"), Not(insertInclude()))));
   // Duplicate based on inclusions in preamble.
   Test = Annotations(R"cpp(
           #include "sub/bar.h"  // not shortest, so should only match resolved.
           int main() { ns::^ }
       )cpp");
   TU.Code = Test.code().str();
   Results = completions(TU, Test.point(), {Sym});
-  EXPECT_THAT(Results.Completions, ElementsAre(AllOf(Named("X"), Labeled("X"),
-                                                     Not(InsertInclude()))));
+  EXPECT_THAT(Results.Completions, ElementsAre(AllOf(named("X"), labeled("X"),
+                                                     Not(insertInclude()))));
 }
 
 TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
   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);
   // Shorten include path based on search directory and insert.
   auto Results = completions(R"cpp(
           namespace ns {
             class X;
             class Y {};
           }
           int main() { ns::^ }
       )cpp",
                              {SymX, SymY});
   EXPECT_THAT(Results.Completions,
-              ElementsAre(AllOf(Named("X"), Not(InsertInclude())),
-                          AllOf(Named("Y"), Not(InsertInclude()))));
+              ElementsAre(AllOf(named("X"), Not(insertInclude())),
+                          AllOf(named("Y"), Not(insertInclude()))));
 }
 
 TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
   Annotations Test(R"cpp(
       #include "bar.h"
       namespace ns { int local; }
       void f() { ns::^; }
       void f2() { ns::preamble().$2^; }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.AdditionalFiles["bar.h"] =
       R"cpp(namespace ns { struct preamble { int member; }; })cpp";
 
   clangd::CodeCompleteOptions Opts = {};
   auto I = memIndex({var("ns::index")});
   Opts.Index = I.get();
   auto WithIndex = completions(TU, Test.point(), {}, Opts);
   EXPECT_THAT(WithIndex.Completions,
-              UnorderedElementsAre(Named("local"), Named("index")));
+              UnorderedElementsAre(named("local"), named("index")));
   auto ClassFromPreamble = completions(TU, Test.point("2"), {}, Opts);
-  EXPECT_THAT(ClassFromPreamble.Completions, Contains(Named("member")));
+  EXPECT_THAT(ClassFromPreamble.Completions, Contains(named("member")));
 
   Opts.Index = nullptr;
   auto WithoutIndex = completions(TU, Test.point(), {}, Opts);
   EXPECT_THAT(WithoutIndex.Completions,
-              UnorderedElementsAre(Named("local"), Named("preamble")));
+              UnorderedElementsAre(named("local"), named("preamble")));
 }
 
 // This verifies that we get normal preprocessor completions in the preamble.
 // This is a regression test for an old bug: if we override the preamble and
 // try to complete inside it, clang kicks our completion point just outside the
 // preamble, resulting in always getting top-level completions.
 TEST(CompletionTest, CompletionInPreamble) {
   auto Results = completions(R"cpp(
     #ifnd^ef FOO_H_
     #define BAR_H_
     #include <bar.h>
     int foo() {}
     #endif
     )cpp")
                      .Completions;
-  EXPECT_THAT(Results, ElementsAre(Named("ifndef")));
+  EXPECT_THAT(Results, ElementsAre(named("ifndef")));
 }
 
 TEST(CompletionTest, CompletionRecoveryASTType) {
   auto Results = completions(R"cpp(
     struct S { int member; };
     S overloaded(int);
     void foo() {
       // No overload matches, but we have recovery-expr with the correct type.
       overloaded().^
     })cpp")
                      .Completions;
-  EXPECT_THAT(Results, ElementsAre(Named("member")));
+  EXPECT_THAT(Results, ElementsAre(named("member")));
 }
 
 TEST(CompletionTest, DynamicIndexIncludeInsertion) {
   MockFS FS;
   MockCompilationDatabase CDB;
   ClangdServer::Options Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
   ClangdServer Server(CDB, FS, Opts);
TEST(CompletionTest, DynamicIndexIncludeInsertion) {
 
   auto File = testPath("foo.cpp");
   Annotations Test("Foo^ foo;");
   runAddDocument(Server, File, Test.code());
   auto CompletionList =
       llvm::cantFail(runCodeComplete(Server, File, Test.point(), {}));
 
   EXPECT_THAT(CompletionList.Completions,
-              ElementsAre(AllOf(Named("Foo"), HasInclude("\"foo_header.h\""),
-                                InsertInclude())));
+              ElementsAre(AllOf(named("Foo"), hasInclude("\"foo_header.h\""),
+                                insertInclude())));
 }
 
 TEST(CompletionTest, DynamicIndexMultiFile) {
   MockFS FS;
   MockCompilationDatabase CDB;
   auto Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
   ClangdServer Server(CDB, FS, Opts);
Annotations Test(R"cpp(
       }
       void f() { ns::^ }
   )cpp");
   runAddDocument(Server, File, Test.code());
 
   auto Results = cantFail(runCodeComplete(Server, File, Test.point(), {}));
   // "XYZ" and "foo" are not included in the file being completed but are still
   // visible through the index.
-  EXPECT_THAT(Results.Completions, Has("XYZ", CompletionItemKind::Class));
-  EXPECT_THAT(Results.Completions, Has("foo", CompletionItemKind::Function));
-  EXPECT_THAT(Results.Completions, Has("XXX", CompletionItemKind::Class));
+  EXPECT_THAT(Results.Completions, has("XYZ", CompletionItemKind::Class));
+  EXPECT_THAT(Results.Completions, has("foo", CompletionItemKind::Function));
+  EXPECT_THAT(Results.Completions, has("XXX", CompletionItemKind::Class));
   EXPECT_THAT(Results.Completions,
-              Contains((Named("fooooo"), Kind(CompletionItemKind::Function),
-                        Doc("Doooc"), ReturnType("void"))));
+              Contains((named("fooooo"), kind(CompletionItemKind::Function),
+                        doc("Doooc"), returnType("void"))));
 }
 
 TEST(CompletionTest, Documentation) {
   auto Results = completions(
       R"cpp(
       // Non-doxygen comment.
       __attribute__((annotate("custom_annotation"))) int foo();
       /// Doxygen comment.
       /// \param int a
       int bar(int a);
       /* Multi-line
          block comment
       */
       int baz();
 
       int x = ^
      )cpp");
   EXPECT_THAT(Results.Completions,
-              Contains(AllOf(Named("foo"),
-              Doc("Annotation: custom_annotation\nNon-doxygen comment."))));
+              Contains(AllOf(
+                  named("foo"),
+                  doc("Annotation: custom_annotation\nNon-doxygen comment."))));
   EXPECT_THAT(
       Results.Completions,
-      Contains(AllOf(Named("bar"), Doc("Doxygen comment.\n\\param int a"))));
+      Contains(AllOf(named("bar"), doc("Doxygen comment.\n\\param int a"))));
   EXPECT_THAT(Results.Completions,
-              Contains(AllOf(Named("baz"), Doc("Multi-line block comment"))));
+              Contains(AllOf(named("baz"), doc("Multi-line block comment"))));
 }
 
 TEST(CompletionTest, CommentsFromSystemHeaders) {
   MockFS FS;
   MockCompilationDatabase CDB;
 
   auto Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;

 int x = foo^
      )cpp");
   runAddDocument(Server, File, Test.code());
   auto CompletionList =
       llvm::cantFail(runCodeComplete(Server, File, Test.point(), {}));
 
   EXPECT_THAT(
       CompletionList.Completions,
-      Contains(AllOf(Named("foo"), Doc("This comment should be retained!"))));
+      Contains(AllOf(named("foo"), doc("This comment should be retained!"))));
 }
 
 TEST(CompletionTest, GlobalCompletionFiltering) {
 
   Symbol Class = cls("XYZ");
   Class.Flags = static_cast<Symbol::SymbolFlag>(
       Class.Flags & ~(Symbol::IndexedForCodeCompletion));
   Symbol Func = func("XYZ::foooo");

 TEST(CodeCompleteTest, NoColonColonAtTheEnd) {
   auto Results = completions(R"cpp(
     namespace clang { }
     void f() {
       clan^
     }
   )cpp");
 
-  EXPECT_THAT(Results.Completions, Contains(Labeled("clang")));
-  EXPECT_THAT(Results.Completions, Not(Contains(Labeled("clang::"))));
+  EXPECT_THAT(Results.Completions, Contains(labeled("clang")));
+  EXPECT_THAT(Results.Completions, Not(Contains(labeled("clang::"))));
 }
 
 TEST(CompletionTest, BacktrackCrashes) {
   // Sema calls code completion callbacks twice in these cases.
   auto Results = completions(R"cpp(
       namespace ns {
       struct FooBarBaz {};
       } // namespace ns
 
      int foo(ns::FooBar^
   )cpp");
 
-  EXPECT_THAT(Results.Completions, ElementsAre(Labeled("FooBarBaz")));
+  EXPECT_THAT(Results.Completions, ElementsAre(labeled("FooBarBaz")));
 
   // Check we don't crash in that case too.
   completions(R"cpp(
     struct FooBarBaz {};
     void test() {
       if (FooBarBaz * x^) {}
     }
 )cpp");

 }  // namespace ns
 
 int f(int input_num) {
   F(ns::^)
 }
 )cpp");
 
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(Named("X"), Named("Y")));
+              UnorderedElementsAre(named("X"), named("Y")));
 }
 
 TEST(CompletionTest, CompleteInMacroAndNamespaceWithStringification) {
   auto Results = completions(R"cpp(
 void f(const char *, int x);
 #define F(x) f(#x, x)
 
 namespace ns {
 int X;
 
 int f(int input_num) {
   F(^)
 }
 }  // namespace ns
 )cpp");
 
-  EXPECT_THAT(Results.Completions, Contains(Named("X")));
+  EXPECT_THAT(Results.Completions, Contains(named("X")));
 }
 
 TEST(CompletionTest, IgnoreCompleteInExcludedPPBranchWithRecoveryContext) {
   auto Results = completions(R"cpp(
     int bar(int param_in_bar) {
     }
 
     int foo(int param_in_foo) {

 TEST(CompletionTest, DefaultArgs) {
   clangd::CodeCompleteOptions Opts;
   std::string Context = R"cpp(
     int X(int A = 0);
     int Y(int A, int B = 0);
     int Z(int A, int B = 0, int C = 0, int D = 0);
   )cpp";
   EXPECT_THAT(completions(Context + "int y = X^", {}, Opts).Completions,
-              UnorderedElementsAre(Labeled("X(int A = 0)")));
+              UnorderedElementsAre(labeled("X(int A = 0)")));
   EXPECT_THAT(completions(Context + "int y = Y^", {}, Opts).Completions,
-              UnorderedElementsAre(AllOf(Labeled("Y(int A, int B = 0)"),
-                                         SnippetSuffix("(${1:int A})"))));
+              UnorderedElementsAre(AllOf(labeled("Y(int A, int B = 0)"),
+                                         snippetSuffix("(${1:int A})"))));
   EXPECT_THAT(completions(Context + "int y = Z^", {}, Opts).Completions,
               UnorderedElementsAre(
-                  AllOf(Labeled("Z(int A, int B = 0, int C = 0, int D = 0)"),
-                        SnippetSuffix("(${1:int A})"))));
+                  AllOf(labeled("Z(int A, int B = 0, int C = 0, int D = 0)"),
+                        snippetSuffix("(${1:int A})"))));
 }
 
 TEST(CompletionTest, NoCrashWithTemplateParamsAndPreferredTypes) {
   auto Completions = completions(R"cpp(
 template <template <class> class TT> int foo() {
   int a = ^
 }
 )cpp")
                          .Completions;
-  EXPECT_THAT(Completions, Contains(Named("TT")));
+  EXPECT_THAT(Completions, Contains(named("TT")));
 }
 
 TEST(CompletionTest, NestedTemplateHeuristics) {
   auto Completions = completions(R"cpp(
 struct Plain { int xxx; };
 template <typename T> class Templ { Plain ppp; };
 template <typename T> void foo(Templ<T> &t) {
   // Formally ppp has DependentTy, because Templ may be specialized.
   // However we sholud be able to see into it using the primary template.
   t.ppp.^
 }
 )cpp")
                          .Completions;
-  EXPECT_THAT(Completions, Contains(Named("xxx")));
+  EXPECT_THAT(Completions, Contains(named("xxx")));
 }
 
 TEST(CompletionTest, RecordCCResultCallback) {
   std::vector<CodeCompletion> RecordedCompletions;
   CodeCompleteOptions Opts;
   Opts.RecordCCResult = [&RecordedCompletions](const CodeCompletion &CC,
                                                const SymbolQualitySignals &,
                                                const SymbolRelevanceSignals &,
                                                float Score) {
     RecordedCompletions.push_back(CC);
   };
 
   completions("int xy1, xy2; int a = xy^", /*IndexSymbols=*/{}, Opts);
   EXPECT_THAT(RecordedCompletions,
-              UnorderedElementsAre(Named("xy1"), Named("xy2")));
+              UnorderedElementsAre(named("xy1"), named("xy2")));
 }
 
 TEST(CompletionTest, ASTSignals) {
   struct Completion {
     std::string Name;
     unsigned MainFileRefs;
     unsigned ScopeRefsInFile;
   };
completions(
       int xybar = 1;
       int a = xy^
       }
       )cpp",
       /*IndexSymbols=*/{var("xyindex"), var("tar::xytar"), var("bar::xybar")},
       Opts);
   EXPECT_THAT(RecordedCompletions,
               UnorderedElementsAre(
-                  AllOf(Named("xy1"), MainFileRefs(3u), ScopeRefs(0u)),
-                  AllOf(Named("xy2"), MainFileRefs(1u), ScopeRefs(0u)),
-                  AllOf(Named("xyindex"), MainFileRefs(10u), ScopeRefs(0u)),
-                  AllOf(Named("xytar"), MainFileRefs(0u), ScopeRefs(5u)),
-                  AllOf(/*both from sema and index*/ Named("xybar"),
-                        MainFileRefs(0u), ScopeRefs(3u))));
+                  AllOf(named("xy1"), mainFileRefs(3u), scopeRefs(0u)),
+                  AllOf(named("xy2"), mainFileRefs(1u), scopeRefs(0u)),
+                  AllOf(named("xyindex"), mainFileRefs(10u), scopeRefs(0u)),
+                  AllOf(named("xytar"), mainFileRefs(0u), scopeRefs(5u)),
+                  AllOf(/*both from sema and index*/ named("xybar"),
+                        mainFileRefs(0u), scopeRefs(3u))));
 }
 
 SignatureHelp
 signatures(llvm::StringRef Text, Position Point,
            std::vector<Symbol> IndexSymbols = {},
            MarkupKind DocumentationFormat = MarkupKind::PlainText) {
   std::unique_ptr<SymbolIndex> Index;
   if (!IndexSymbols.empty())

 struct ExpectedParameter {
   std::string Text;
   std::pair<unsigned, unsigned> Offsets;
 };
 llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
                               const ExpectedParameter &P) {
   return OS << P.Text;
 }
-MATCHER_P(ParamsAre, P, "") {
+MATCHER_P(paramsAre, P, "") {
   if (P.size() != arg.parameters.size())
     return false;
   for (unsigned I = 0; I < P.size(); ++I) {
     if (P[I].Text != arg.parameters[I].labelString ||
         P[I].Offsets != arg.parameters[I].labelOffsets)
       return false;
   }
   return true;
 }
-MATCHER_P(SigDoc, Doc, "") { return arg.documentation.value == Doc; }
+MATCHER_P(sigDoc, doc, "") { return arg.documentation.value == doc; }
 
 /// \p AnnotatedLabel is a signature label with ranges marking parameters, e.g.
 ///    foo([[int p1]], [[double p2]]) -> void
-Matcher<SignatureInformation> Sig(llvm::StringRef AnnotatedLabel) {
+Matcher<SignatureInformation> sig(llvm::StringRef AnnotatedLabel) {
   llvm::Annotations A(AnnotatedLabel);
   std::string Label = std::string(A.code());
   std::vector<ExpectedParameter> Parameters;
   for (auto Range : A.ranges()) {
     Parameters.emplace_back();
 
     ExpectedParameter &P = Parameters.back();
     P.Text = Label.substr(Range.Begin, Range.End - Range.Begin);
     P.Offsets.first = lspLength(llvm::StringRef(Label).substr(0, Range.Begin));
     P.Offsets.second = lspLength(llvm::StringRef(Label).substr(1, Range.End));
   }
-  return AllOf(SigHelpLabeled(Label), ParamsAre(Parameters));
+  return AllOf(sigHelpLabeled(Label), paramsAre(Parameters));
 }
 
 TEST(SignatureHelpTest, Overloads) {
   auto Results = signatures(R"cpp(
     void foo(int x, int y);
     void foo(int x, float y);
     void foo(float x, int y);
     void foo(float x, float y);
     void bar(int x, int y = 0);
     int main() { foo(^); }
   )cpp");
   EXPECT_THAT(Results.signatures,
-              UnorderedElementsAre(Sig("foo([[float x]], [[float y]]) -> void"),
-                                   Sig("foo([[float x]], [[int y]]) -> void"),
-                                   Sig("foo([[int x]], [[float y]]) -> void"),
-                                   Sig("foo([[int x]], [[int y]]) -> void")));
+              UnorderedElementsAre(sig("foo([[float x]], [[float y]]) -> void"),
+                                   sig("foo([[float x]], [[int y]]) -> void"),
+                                   sig("foo([[int x]], [[float y]]) -> void"),
+                                   sig("foo([[int x]], [[int y]]) -> void")));
   // We always prefer the first signature.
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(0, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, Constructors) {
   std::string Top = R"cpp(
     struct S {
       S(int);
       S(const S &) = delete;
     };
   )cpp";
 
   auto CheckParenInit = [&](std::string Init) {
     EXPECT_THAT(signatures(Top + Init).signatures,
-                UnorderedElementsAre(Sig("S([[int]])")))
+                UnorderedElementsAre(sig("S([[int]])")))
         << Init;
   };
   CheckParenInit("S s(^);");
   CheckParenInit("auto s = S(^);");
   CheckParenInit("auto s = new S(^);");
 
   auto CheckBracedInit = [&](std::string Init) {
     EXPECT_THAT(signatures(Top + Init).signatures,
-                UnorderedElementsAre(Sig("S{[[int]]}")))
+                UnorderedElementsAre(sig("S{[[int]]}")))
         << Init;
   };
   CheckBracedInit("S s{^};");
   CheckBracedInit("S s = {^};");
   CheckBracedInit("auto s = S{^};");
   // FIXME: doesn't work: no ExpectedType set in ParseCXXNewExpression.
   // CheckBracedInit("auto s = new S{^};");
   CheckBracedInit("int x(S); int i = x({^});");
 }
 
 TEST(SignatureHelpTest, Aggregates) {
   std::string Top = R"cpp(
     struct S {
       int a, b, c, d;
     };
   )cpp";
-  auto AggregateSig = Sig("S{[[int a]], [[int b]], [[int c]], [[int d]]}");
+  auto AggregateSig = sig("S{[[int a]], [[int b]], [[int c]], [[int d]]}");
   EXPECT_THAT(signatures(Top + "S s{^}").signatures,
-              UnorderedElementsAre(AggregateSig, Sig("S{}"),
-                                   Sig("S{[[const S &]]}"),
-                                   Sig("S{[[S &&]]}")));
+              UnorderedElementsAre(AggregateSig, sig("S{}"),
+                                   sig("S{[[const S &]]}"),
+                                   sig("S{[[S &&]]}")));
   EXPECT_THAT(signatures(Top + "S s{1,^}").signatures,
               ElementsAre(AggregateSig));
   EXPECT_EQ(signatures(Top + "S s{1,^}").activeParameter, 1);
   EXPECT_THAT(signatures(Top + "S s{.c=3,^}").signatures,
               ElementsAre(AggregateSig));
   EXPECT_EQ(signatures(Top + "S s{.c=3,^}").activeParameter, 3);
 }
 
 TEST(SignatureHelpTest, OverloadInitListRegression) {
   auto Results = signatures(R"cpp(
     struct A {int x;};
     struct B {B(A);};
     void f();
     int main() {
       B b({1});
       f(^);
     }
   )cpp");
-  EXPECT_THAT(Results.signatures, UnorderedElementsAre(Sig("f() -> void")));
+  EXPECT_THAT(Results.signatures, UnorderedElementsAre(sig("f() -> void")));
 }
 
 TEST(SignatureHelpTest, DefaultArgs) {
   auto Results = signatures(R"cpp(
     void bar(int x, int y = 0);
     void bar(float x = 0, int y = 42);
     int main() { bar(^
   )cpp");
   EXPECT_THAT(Results.signatures,
               UnorderedElementsAre(
-                  Sig("bar([[int x]], [[int y = 0]]) -> void"),
-                  Sig("bar([[float x = 0]], [[int y = 42]]) -> void")));
+                  sig("bar([[int x]], [[int y = 0]]) -> void"),
+                  sig("bar([[float x = 0]], [[int y = 42]]) -> void")));
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(0, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, ActiveArg) {
   auto Results = signatures(R"cpp(
     int baz(int a, int b, int c);
     int main() { baz(baz(1,2,3), ^); }
   )cpp");
   EXPECT_THAT(Results.signatures,
-              ElementsAre(Sig("baz([[int a]], [[int b]], [[int c]]) -> int")));
+              ElementsAre(sig("baz([[int a]], [[int b]], [[int c]]) -> int")));
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(1, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, OpeningParen) {
   llvm::StringLiteral Tests[] = {
       // Recursive function call.
       R"cpp(
TEST(SignatureHelpTest, StalePreamble) {
   TU.AdditionalFiles["a.h"] = "int foo(int x);";
   const Annotations Test(R"cpp(
     #include "a.h"
     void bar() { foo(^2); })cpp");
   TU.Code = Test.code().str();
   auto Results =
       signatureHelp(testPath(TU.Filename), Test.point(), *EmptyPreamble,
                     TU.inputs(FS), MarkupKind::PlainText);
-  EXPECT_THAT(Results.signatures, ElementsAre(Sig("foo([[int x]]) -> int")));
+  EXPECT_THAT(Results.signatures, ElementsAre(sig("foo([[int x]]) -> int")));
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(0, Results.activeParameter);
 }
 
 class IndexRequestCollector : public SymbolIndex {
 public:
   bool
   fuzzyFind(const FuzzyFindRequest &Req,
struct Foo {
       int SomeNameOfField;
       typedef int SomeNameOfTypedefField;
     };
 
     Foo::^)cpp",
       {func("::SomeNameInTheIndex"), func("::Foo::SomeNameInTheIndex")});
 
   EXPECT_THAT(Completions.Completions,
-              AllOf(Contains(Labeled("SomeNameOfField")),
-                    Contains(Labeled("SomeNameOfTypedefField")),
-                    Not(Contains(Labeled("SomeNameInTheIndex")))));
+              AllOf(Contains(labeled("SomeNameOfField")),
+                    Contains(labeled("SomeNameOfTypedefField")),
+                    Not(Contains(labeled("SomeNameInTheIndex")))));
 }
 
 TEST(CompletionTest, NoIndexCompletionsInsideDependentCode) {
   {
     auto Completions = completions(
         R"cpp(
       template <class T>
       void foo() {
         T::^
       }
       )cpp",
         {func("::SomeNameInTheIndex")});
 
     EXPECT_THAT(Completions.Completions,
-                Not(Contains(Labeled("SomeNameInTheIndex"))));
+                Not(Contains(labeled("SomeNameInTheIndex"))));
   }
 
   {
     auto Completions = completions(
         R"cpp(
       template <class T>
       void foo() {
         T::template Y<int>::^
       }
       )cpp",
         {func("::SomeNameInTheIndex")});
 
     EXPECT_THAT(Completions.Completions,
-                Not(Contains(Labeled("SomeNameInTheIndex"))));
+                Not(Contains(labeled("SomeNameInTheIndex"))));
   }
 
   {
     auto Completions = completions(
         R"cpp(
       template <class T>
       void foo() {
         T::foo::^
       }
       )cpp",
         {func("::SomeNameInTheIndex")});
 
     EXPECT_THAT(Completions.Completions,
-                Not(Contains(Labeled("SomeNameInTheIndex"))));
+                Not(Contains(labeled("SomeNameInTheIndex"))));
   }
 }
 
 TEST(CompletionTest, OverloadBundling) {
   clangd::CodeCompleteOptions Opts;
   Opts.BundleOverloads = true;
 
   std::string Context = R"cpp(
     struct X {
       // Overload with int
       int a(int) __attribute__((deprecated("", "")));
       // Overload with bool
       int a(bool);
       int b(float);
 
       X(int);
       X(float);
     };
     int GFuncC(int);
     int GFuncD(int);
   )cpp";
 
   // Member completions are bundled.
   EXPECT_THAT(completions(Context + "int y = X().^", {}, Opts).Completions,
-              UnorderedElementsAre(Labeled("a(…)"), Labeled("b(float)")));
+              UnorderedElementsAre(labeled("a(…)"), labeled("b(float)")));
 
   // Constructor completions are bundled.
   EXPECT_THAT(completions(Context + "X z = X^", {}, Opts).Completions,
-              UnorderedElementsAre(Labeled("X"), Labeled("X(…)")));
+              UnorderedElementsAre(labeled("X"), labeled("X(…)")));
 
   // Non-member completions are bundled, including index+sema.
   Symbol NoArgsGFunc = func("GFuncC");
   EXPECT_THAT(
       completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
-      UnorderedElementsAre(Labeled("GFuncC(…)"), Labeled("GFuncD(int)")));
+      UnorderedElementsAre(labeled("GFuncC(…)"), labeled("GFuncD(int)")));
 
   // Differences in header-to-insert suppress bundling.
   std::string DeclFile = URI::create(testPath("foo")).toString();
   NoArgsGFunc.CanonicalDeclaration.FileURI = DeclFile.c_str();
   NoArgsGFunc.IncludeHeaders.emplace_back("<foo>", 1);
   EXPECT_THAT(
       completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
-      UnorderedElementsAre(AllOf(Named("GFuncC"), InsertInclude("<foo>")),
-                           Labeled("GFuncC(int)"), Labeled("GFuncD(int)")));
+      UnorderedElementsAre(AllOf(named("GFuncC"), insertInclude("<foo>")),
+                           labeled("GFuncC(int)"), labeled("GFuncD(int)")));
 
   // Examine a bundled completion in detail.
   auto A =
       completions(Context + "int y = X().a^", {}, Opts).Completions.front();
   EXPECT_EQ(A.Name, "a");
   EXPECT_EQ(A.Signature, "(…)");
   EXPECT_EQ(A.BundleSize, 2u);
   EXPECT_EQ(A.Kind, CompletionItemKind::Method);
TEST(CompletionTest, DocumentationFromChangedFileCrash) {
   )cpp";
 
   clangd::CodeCompleteOptions Opts;
   CodeCompleteResult Completions =
       cantFail(runCodeComplete(Server, FooCpp, Source.point(), Opts));
   // We shouldn't crash. Unfortunately, current workaround is to not produce
   // comments for symbols from headers.
   EXPECT_THAT(Completions.Completions,
-              Contains(AllOf(Not(IsDocumented()), Named("func"))));
+              Contains(AllOf(Not(isDocumented()), named("func"))));
 }
 
 TEST(CompletionTest, NonDocComments) {
   const char *Text = R"cpp(
     // We ignore namespace comments, for rationale see CodeCompletionStrings.h.
     namespace comments_ns {
     }
 
const char *Text = R"cpp(
     int Struct<T>::comments_quux() {
       int a = comments^;
     }
   )cpp";
 
   // We should not get any of those comments in completion.
   EXPECT_THAT(
       completions(Text).Completions,
-      UnorderedElementsAre(AllOf(Not(IsDocumented()), Named("comments_foo")),
-                           AllOf(IsDocumented(), Named("comments_baz")),
-                           AllOf(IsDocumented(), Named("comments_quux")),
-                           AllOf(Not(IsDocumented()), Named("comments_ns")),
+      UnorderedElementsAre(AllOf(Not(isDocumented()), named("comments_foo")),
+                           AllOf(isDocumented(), named("comments_baz")),
+                           AllOf(isDocumented(), named("comments_quux")),
+                           AllOf(Not(isDocumented()), named("comments_ns")),
                            // FIXME(ibiryukov): the following items should have
                            // empty documentation, since they are separated from
                            // a comment with an empty line. Unfortunately, I
                            // couldn't make Sema tests pass if we ignore those.
-                           AllOf(IsDocumented(), Named("comments_bar")),
-                           AllOf(IsDocumented(), Named("comments_qux"))));
+                           AllOf(isDocumented(), named("comments_bar")),
+                           AllOf(isDocumented(), named("comments_qux"))));
 }
 
 TEST(CompletionTest, CompleteOnInvalidLine) {
   auto FooCpp = testPath("foo.cpp");
 
   MockCompilationDatabase CDB;
   MockFS FS;
   FS.Files[FooCpp] = "// empty file";
auto Results = completions(
       R"cpp(
           namespace ns { int local; void both(); }
           void f() { ::ns::^ }
       )cpp",
       {func("ns::both"), cls("ns::Index")});
   // We get results from both index and sema, with no duplicates.
   EXPECT_THAT(
       Results.Completions,
-      UnorderedElementsAre(Scope("ns::"), Scope("ns::"), Scope("ns::")));
+      UnorderedElementsAre(scope("ns::"), scope("ns::"), scope("ns::")));
 }
 
 TEST(CompletionTest, Render) {
   CodeCompletion C;
   C.Name = "x";
   C.Signature = "(bool) const";
   C.SnippetSuffix = "(${0:bool})";
   C.ReturnType = "int";
TEST(CompletionTest, IgnoreRecoveryResults) {
   auto Results = completions(
       R"cpp(
           namespace ns { int NotRecovered() { return 0; } }
           void f() {
             // Sema enters recovery mode first and then normal mode.
             if (auto x = ns::NotRecover^)
           }
       )cpp");
-  EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("NotRecovered")));
+  EXPECT_THAT(Results.Completions, UnorderedElementsAre(named("NotRecovered")));
 }
 
 TEST(CompletionTest, ScopeOfClassFieldInConstructorInitializer) {
   auto Results = completions(
       R"cpp(
         namespace ns {
           class X { public: X(); int x_; };
           X::X() : x_^(0) {}
         }
       )cpp");
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(AllOf(Scope("ns::X::"), Named("x_"))));
+              UnorderedElementsAre(AllOf(scope("ns::X::"), named("x_"))));
 }
 
 // Like other class members, constructor init lists have to parse what's below,
 // after the completion point.
 // But recovering from an incomplete constructor init list is particularly
 // tricky because the bulk of the list is not surrounded by brackets.
 TEST(CompletionTest, ConstructorInitListIncomplete) {
   auto Results = completions(
       R"cpp(
         namespace ns {
           struct X {
             X() : x^
             int xyz_;
           };
         }
       )cpp");
-  EXPECT_THAT(Results.Completions, ElementsAre(Named("xyz_")));
+  EXPECT_THAT(Results.Completions, ElementsAre(named("xyz_")));
 
   Results = completions(
       R"cpp(
         int foo();
 
         namespace ns {
           struct X {
             X() : xyz_(fo^
             int xyz_;
           };
         }
       )cpp");
-  EXPECT_THAT(Results.Completions, ElementsAre(Named("foo")));
+  EXPECT_THAT(Results.Completions, ElementsAre(named("foo")));
 }
 
 TEST(CompletionTest, CodeCompletionContext) {
   auto Results = completions(
       R"cpp(
         namespace ns {
           class X { public: X(); int x_; };
           void f() {
const auto Results = signatures(R"cpp(
     void foo(int x);
     void foo(int x, float y);
     void foo(float x, int y);
     void foo(float x, float y);
     void foo(int x, int y = 0);
     int main() { foo(^); }
   )cpp");
   EXPECT_THAT(Results.signatures,
-              ElementsAre(Sig("foo([[int x]]) -> void"),
-                          Sig("foo([[int x]], [[int y = 0]]) -> void"),
-                          Sig("foo([[float x]], [[int y]]) -> void"),
-                          Sig("foo([[int x]], [[float y]]) -> void"),
-                          Sig("foo([[float x]], [[float y]]) -> void")));
+              ElementsAre(sig("foo([[int x]]) -> void"),
+                          sig("foo([[int x]], [[int y = 0]]) -> void"),
+                          sig("foo([[float x]], [[int y]]) -> void"),
+                          sig("foo([[int x]], [[float y]]) -> void"),
+                          sig("foo([[float x]], [[float y]]) -> void")));
   // We always prefer the first signature.
   EXPECT_EQ(0, Results.activeSignature);
   EXPECT_EQ(0, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, InstantiatedSignatures) {
   StringRef Sig0 = R"cpp(
     template <class T>
     void foo(T, T, T);
 
     int main() {
       foo<int>(^);
     }
   )cpp";
 
   EXPECT_THAT(signatures(Sig0).signatures,
-              ElementsAre(Sig("foo([[T]], [[T]], [[T]]) -> void")));
+              ElementsAre(sig("foo([[T]], [[T]], [[T]]) -> void")));
 
   StringRef Sig1 = R"cpp(
     template <class T>
     void foo(T, T, T);
 
     int main() {
       foo(10, ^);
     })cpp";
 
   EXPECT_THAT(signatures(Sig1).signatures,
-              ElementsAre(Sig("foo([[T]], [[T]], [[T]]) -> void")));
+              ElementsAre(sig("foo([[T]], [[T]], [[T]]) -> void")));
 
   StringRef Sig2 = R"cpp(
     template <class ...T>
     void foo(T...);
 
     int main() {
       foo<int>(^);
     }
   )cpp";
 
   EXPECT_THAT(signatures(Sig2).signatures,
-              ElementsAre(Sig("foo([[T...]]) -> void")));
+              ElementsAre(sig("foo([[T...]]) -> void")));
 
   // It is debatable whether we should substitute the outer template parameter
   // ('T') in that case. Currently we don't substitute it in signature help, but
   // do substitute in code complete.
   // FIXME: make code complete and signature help consistent, figure out which
   // way is better.
   StringRef Sig3 = R"cpp(
     template <class T>
     struct X {
       template <class U>
       void foo(T, U);
     };
 
     int main() {
       X<int>().foo<double>(^)
     }
   )cpp";
 
   EXPECT_THAT(signatures(Sig3).signatures,
-              ElementsAre(Sig("foo([[T]], [[U]]) -> void")));
+              ElementsAre(sig("foo([[T]], [[U]]) -> void")));
 }
 
 TEST(SignatureHelpTest, IndexDocumentation) {
   Symbol Foo0 = sym("foo", index::SymbolKind::Function, "@F@\\0#");
-  Foo0.Documentation = "Doc from the index";
+  Foo0.Documentation = "doc from the index";
   Symbol Foo1 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#");
-  Foo1.Documentation = "Doc from the index";
+  Foo1.Documentation = "doc from the index";
   Symbol Foo2 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#I#");
 
   StringRef Sig0 = R"cpp(
     int foo();
     int foo(double);
 
     void test() {
       foo(^);
     }
   )cpp";
 
   EXPECT_THAT(
       signatures(Sig0, {Foo0}).signatures,
-      ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Doc from the index")),
-                  AllOf(Sig("foo([[double]]) -> int"), SigDoc(""))));
+      ElementsAre(AllOf(sig("foo() -> int"), sigDoc("doc from the index")),
+                  AllOf(sig("foo([[double]]) -> int"), sigDoc(""))));
 
   StringRef Sig1 = R"cpp(
     int foo();
     // Overriden doc from sema
     int foo(int);
-    // Doc from sema
+    // doc from sema
     int foo(int, int);
 
     void test() {
       foo(^);
     }
   )cpp";
 
   EXPECT_THAT(
       signatures(Sig1, {Foo0, Foo1, Foo2}).signatures,
       ElementsAre(
-          AllOf(Sig("foo() -> int"), SigDoc("Doc from the index")),
-          AllOf(Sig("foo([[int]]) -> int"), SigDoc("Overriden doc from sema")),
-          AllOf(Sig("foo([[int]], [[int]]) -> int"), SigDoc("Doc from sema"))));
+          AllOf(sig("foo() -> int"), sigDoc("doc from the index")),
+          AllOf(sig("foo([[int]]) -> int"), sigDoc("Overriden doc from sema")),
+          AllOf(sig("foo([[int]], [[int]]) -> int"), sigDoc("doc from sema"))));
 }
 
 TEST(SignatureHelpTest, DynamicIndexDocumentation) {
   MockFS FS;
   MockCompilationDatabase CDB;
   ClangdServer::Options Opts = ClangdServer::optsForTest();
   Opts.BuildDynamicSymbolIndex = true;
   ClangdServer Server(CDB, FS, Opts);
TEST(SignatureHelpTest, DynamicIndexDocumentation) {
   )cpp");
   auto File = testPath("test.cpp");
   Server.addDocument(File, FileContent.code());
   // Wait for the dynamic index being built.
   ASSERT_TRUE(Server.blockUntilIdleForTest());
   EXPECT_THAT(llvm::cantFail(runSignatureHelp(Server, File, FileContent.point(),
                                               MarkupKind::PlainText))
                   .signatures,
-              ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Member doc"))));
+              ElementsAre(AllOf(sig("foo() -> int"), sigDoc("Member doc"))));
 }
 
 TEST(CompletionTest, CompletionFunctionArgsDisabled) {
   CodeCompleteOptions Opts;
   Opts.EnableSnippets = true;
   Opts.EnableFunctionArgSnippets = false;
 
   {
     auto Results = completions(
         R"cpp(
       void xfoo();
       void xfoo(int x, int y);
       void f() { xfo^ })cpp",
         {}, Opts);
     EXPECT_THAT(
         Results.Completions,
-        UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("()")),
-                             AllOf(Named("xfoo"), SnippetSuffix("($0)"))));
+        UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix("()")),
+                             AllOf(named("xfoo"), snippetSuffix("($0)"))));
   }
   {
     auto Results = completions(
         R"cpp(
       void xbar();
       void f() { xba^ })cpp",
         {}, Opts);
     EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf(
-                                         Named("xbar"), SnippetSuffix("()"))));
+                                         named("xbar"), snippetSuffix("()"))));
   }
   {
     Opts.BundleOverloads = true;
     auto Results = completions(
         R"cpp(
       void xfoo();
       void xfoo(int x, int y);
       void f() { xfo^ })cpp",
         {}, Opts);
     EXPECT_THAT(
         Results.Completions,
-        UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("($0)"))));
+        UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix("($0)"))));
   }
   {
     auto Results = completions(
         R"cpp(
       template <class T, class U>
       void xfoo(int a, U b);
       void f() { xfo^ })cpp",
         {}, Opts);
     EXPECT_THAT(
         Results.Completions,
-        UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("<$1>($0)"))));
+        UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix("<$1>($0)"))));
   }
   {
     auto Results = completions(
         R"cpp(
       template <class T>
       class foo_class{};
       template <class T>
       using foo_alias = T**;
       void f() { foo_^ })cpp",
         {}, Opts);
     EXPECT_THAT(
         Results.Completions,
-        UnorderedElementsAre(AllOf(Named("foo_class"), SnippetSuffix("<$0>")),
-                             AllOf(Named("foo_alias"), SnippetSuffix("<$0>"))));
+        UnorderedElementsAre(AllOf(named("foo_class"), snippetSuffix("<$0>")),
+                             AllOf(named("foo_alias"), snippetSuffix("<$0>"))));
   }
   {
     auto Results = completions(
         R"cpp(
       #define FOO(x, y) x##f
       FO^ )cpp",
         {}, Opts);
     EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf(
-                                         Named("FOO"), SnippetSuffix("($0)"))));
+                                         named("FOO"), snippetSuffix("($0)"))));
   }
 }
 
 TEST(CompletionTest, SuggestOverrides) {
   constexpr const char *const Text(R"cpp(
   class A {
    public:
     virtual void vfunc(bool param);
     virtual void vfunc(bool param, int p);
     void func(bool param);
   };
   class B : public A {
   virtual void ttt(bool param) const;
   void vfunc(bool param, int p) override;
   };
   class C : public B {
    public:
     void vfunc(bool param) override;
     ^
   };
   )cpp");
   const auto Results = completions(Text);
   EXPECT_THAT(
       Results.Completions,
-      AllOf(Contains(AllOf(Labeled("void vfunc(bool param, int p) override"),
-                           NameStartsWith("vfunc"))),
-            Contains(AllOf(Labeled("void ttt(bool param) const override"),
-                           NameStartsWith("ttt"))),
-            Not(Contains(Labeled("void vfunc(bool param) override")))));
+      AllOf(Contains(AllOf(labeled("void vfunc(bool param, int p) override"),
+                           nameStartsWith("vfunc"))),
+            Contains(AllOf(labeled("void ttt(bool param) const override"),
+                           nameStartsWith("ttt"))),
+            Not(Contains(labeled("void vfunc(bool param) override")))));
 }
 
 TEST(CompletionTest, OverridesNonIdentName) {
   // Check the completions call does not crash.
   completions(R"cpp(
     struct Base {
       virtual ~Base() = 0;
       virtual operator int() = 0;
TEST(CompletionTest, InsertTheMostPopularHeader) {
   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);
 
   auto Results = completions("Fun^", {Sym}).Completions;
   assert(!Results.empty());
-  EXPECT_THAT(Results[0], AllOf(Named("Func"), InsertInclude("\"bar.h\"")));
+  EXPECT_THAT(Results[0], AllOf(named("Func"), insertInclude("\"bar.h\"")));
   EXPECT_EQ(Results[0].Includes.size(), 2u);
 }
 
 TEST(CompletionTest, NoInsertIncludeIfOnePresent) {
   Annotations Test(R"cpp(
     #include "foo.h"
     Fun^
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.AdditionalFiles["foo.h"] = "";
 
   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(completions(TU, Test.point(), {Sym}).Completions,
-              UnorderedElementsAre(AllOf(Named("Func"), HasInclude("\"foo.h\""),
-                                         Not(InsertInclude()))));
+              UnorderedElementsAre(AllOf(named("Func"), hasInclude("\"foo.h\""),
+                                         Not(insertInclude()))));
 }
 
 TEST(CompletionTest, MergeMacrosFromIndexAndSema) {
   Symbol Sym;
   Sym.Name = "Clangd_Macro_Test";
   Sym.ID = SymbolID("c:foo.cpp@8@macro@Clangd_Macro_Test");
   Sym.SymInfo.Kind = index::SymbolKind::Macro;
   Sym.Flags |= Symbol::IndexedForCodeCompletion;
   EXPECT_THAT(completions("#define Clangd_Macro_Test\nClangd_Macro_T^", {Sym})
                   .Completions,
-              UnorderedElementsAre(Named("Clangd_Macro_Test")));
+              UnorderedElementsAre(named("Clangd_Macro_Test")));
 }
 
 TEST(CompletionTest, MacroFromPreamble) {
   Annotations Test(R"cpp(#define CLANGD_PREAMBLE_MAIN x
 
           int x = 0;
           #define CLANGD_MAIN x
           void f() { CLANGD_^ }
       )cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.HeaderCode = "#define CLANGD_PREAMBLE_HEADER x";
   auto Results = completions(TU, Test.point(), {func("CLANGD_INDEX")});
   // We should get results from the main file, including the preamble section.
   // However no results from included files (the index should cover them).
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(Named("CLANGD_PREAMBLE_MAIN"),
-                                   Named("CLANGD_MAIN"),
-                                   Named("CLANGD_INDEX")));
+              UnorderedElementsAre(named("CLANGD_PREAMBLE_MAIN"),
+                                   named("CLANGD_MAIN"),
+                                   named("CLANGD_INDEX")));
 }
 
 TEST(CompletionTest, DeprecatedResults) {
   std::string Body = R"cpp(
     void TestClangd();
     void TestClangc() __attribute__((deprecated("", "")));
   )cpp";
 
   EXPECT_THAT(
       completions(Body + "int main() { TestClang^ }").Completions,
-      UnorderedElementsAre(AllOf(Named("TestClangd"), Not(Deprecated())),
-                           AllOf(Named("TestClangc"), Deprecated())));
+      UnorderedElementsAre(AllOf(named("TestClangd"), Not(deprecated())),
+                           AllOf(named("TestClangc"), deprecated())));
 }
 
 TEST(SignatureHelpTest, PartialSpec) {
   const auto Results = signatures(R"cpp(
       template <typename T> struct Foo {};
       template <typename T> struct Foo<T*> { Foo(T); };
       Foo<int*> F(^);)cpp");
-  EXPECT_THAT(Results.signatures, Contains(Sig("Foo([[T]])")));
+  EXPECT_THAT(Results.signatures, Contains(sig("Foo([[T]])")));
   EXPECT_EQ(0, Results.activeParameter);
 }
 
 TEST(SignatureHelpTest, InsideArgument) {
   {
     const auto Results = signatures(R"cpp(
       void foo(int x);
       void foo(int x, int y);
       int main() { foo(1+^); }
     )cpp");
     EXPECT_THAT(Results.signatures,
-                ElementsAre(Sig("foo([[int x]]) -> void"),
-                            Sig("foo([[int x]], [[int y]]) -> void")));
+                ElementsAre(sig("foo([[int x]]) -> void"),
+                            sig("foo([[int x]], [[int y]]) -> void")));
     EXPECT_EQ(0, Results.activeParameter);
   }
   {
     const auto Results = signatures(R"cpp(
       void foo(int x);
       void foo(int x, int y);
       int main() { foo(1^); }
     )cpp");
     EXPECT_THAT(Results.signatures,
-                ElementsAre(Sig("foo([[int x]]) -> void"),
-                            Sig("foo([[int x]], [[int y]]) -> void")));
+                ElementsAre(sig("foo([[int x]]) -> void"),
+                            sig("foo([[int x]], [[int y]]) -> void")));
     EXPECT_EQ(0, Results.activeParameter);
   }
   {
     const auto Results = signatures(R"cpp(
       void foo(int x);
       void foo(int x, int y);
       int main() { foo(1^0); }
     )cpp");
     EXPECT_THAT(Results.signatures,
-                ElementsAre(Sig("foo([[int x]]) -> void"),
-                            Sig("foo([[int x]], [[int y]]) -> void")));
+                ElementsAre(sig("foo([[int x]]) -> void"),
+                            sig("foo([[int x]], [[int y]]) -> void")));
     EXPECT_EQ(0, Results.activeParameter);
   }
   {
     const auto Results = signatures(R"cpp(
       void foo(int x);
       void foo(int x, int y);
       int bar(int x, int y);
       int main() { bar(foo(2, 3^)); }
     )cpp");
     EXPECT_THAT(Results.signatures,
-                ElementsAre(Sig("foo([[int x]], [[int y]]) -> void")));
+                ElementsAre(sig("foo([[int x]], [[int y]]) -> void")));
     EXPECT_EQ(1, Results.activeParameter);
   }
 }
 
 TEST(SignatureHelpTest, ConstructorInitializeFields) {
   {
     const auto Results = signatures(R"cpp(
       struct A { A(int); };
       struct B {
         B() : a_elem(^) {}
         A a_elem;
       };
     )cpp");
     EXPECT_THAT(Results.signatures,
-                UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"),
-                                     Sig("A([[const A &]])")));
+                UnorderedElementsAre(sig("A([[int]])"), sig("A([[A &&]])"),
+                                     sig("A([[const A &]])")));
   }
   {
     const auto Results = signatures(R"cpp(
       struct A { A(int); };
       struct B {
         B() : a_elem(^
         A a_elem;
       };
     )cpp");
     // FIXME: currently the parser skips over the decl of a_elem as part of the
     // (broken) init list, so we don't get signatures for the first member.
     EXPECT_THAT(Results.signatures, IsEmpty());
   }
   {
     const auto Results = signatures(R"cpp(
       struct A { A(int); };
       struct B {
         B() : a_elem(^
         int dummy_elem;
         A a_elem;
       };
     )cpp");
     EXPECT_THAT(Results.signatures,
-                UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"),
-                                     Sig("A([[const A &]])")));
+                UnorderedElementsAre(sig("A([[int]])"), sig("A([[A &&]])"),
+                                     sig("A([[const A &]])")));
   }
   {
     const auto Results = signatures(R"cpp(
       struct A {
         A(int);
       };
       struct C {
         C(int);
         C(A);
       };
       struct B {
         B() : c_elem(A(1^)) {}
         C c_elem;
       };
     )cpp");
     EXPECT_THAT(Results.signatures,
-                UnorderedElementsAre(Sig("A([[int]])"), Sig("A([[A &&]])"),
-                                     Sig("A([[const A &]])")));
+                UnorderedElementsAre(sig("A([[int]])"), sig("A([[A &&]])"),
+                                     sig("A([[const A &]])")));
   }
 }
 
 TEST(SignatureHelpTest, Variadic) {
   const std::string Header = R"cpp(
     void fun(int x, ...) {}
     void test() {)cpp";
   const std::string ExpectedSig = "fun([[int x]], [[...]]) -> void";
 
   {
     const auto Result = signatures(Header + "fun(^);}");
     EXPECT_EQ(0, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
   {
     const auto Result = signatures(Header + "fun(1, ^);}");
     EXPECT_EQ(1, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
   {
     const auto Result = signatures(Header + "fun(1, 2, ^);}");
     EXPECT_EQ(1, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
 }
 
 TEST(SignatureHelpTest, VariadicTemplate) {
   const std::string Header = R"cpp(
     template<typename T, typename ...Args>
     void fun(T t, Args ...args) {}
     void test() {)cpp";
   const std::string ExpectedSig = "fun([[T t]], [[Args args...]]) -> void";
 
   {
     const auto Result = signatures(Header + "fun(^);}");
     EXPECT_EQ(0, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
   {
     const auto Result = signatures(Header + "fun(1, ^);}");
     EXPECT_EQ(1, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
   {
     const auto Result = signatures(Header + "fun(1, 2, ^);}");
     EXPECT_EQ(1, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
 }
 
 TEST(SignatureHelpTest, VariadicMethod) {
   const std::string Header = R"cpp(
   class C {
     template<typename T, typename ...Args>
     void fun(T t, Args ...args) {}
   };
     void test() {C c; )cpp";
   const std::string ExpectedSig = "fun([[T t]], [[Args args...]]) -> void";
 
   {
     const auto Result = signatures(Header + "c.fun(^);}");
     EXPECT_EQ(0, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
   {
     const auto Result = signatures(Header + "c.fun(1, ^);}");
     EXPECT_EQ(1, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
   {
     const auto Result = signatures(Header + "c.fun(1, 2, ^);}");
     EXPECT_EQ(1, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
 }
 
 TEST(SignatureHelpTest, VariadicType) {
   const std::string Header = R"cpp(
   void fun(int x, ...) {}
   auto get_fun() { return fun; }
   void test() {
   )cpp";
   const std::string ExpectedSig = "([[int]], [[...]]) -> void";
 
   {
     const auto Result = signatures(Header + "get_fun()(^);}");
     EXPECT_EQ(0, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
   {
     const auto Result = signatures(Header + "get_fun()(1, ^);}");
     EXPECT_EQ(1, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
   {
     const auto Result = signatures(Header + "get_fun()(1, 2, ^);}");
     EXPECT_EQ(1, Result.activeParameter);
-    EXPECT_THAT(Result.signatures, UnorderedElementsAre(Sig(ExpectedSig)));
+    EXPECT_THAT(Result.signatures, UnorderedElementsAre(sig(ExpectedSig)));
   }
 }
 
 TEST(CompletionTest, IncludedCompletionKinds) {
   Annotations Test(R"cpp(#include "^)cpp");
   auto TU = TestTU::withCode(Test.code());
   TU.AdditionalFiles["sub/bar.h"] = "";
   TU.ExtraArgs.push_back("-I" + testPath("sub"));
 
   auto Results = completions(TU, Test.point());
   EXPECT_THAT(Results.Completions,
-              AllOf(Has("sub/", CompletionItemKind::Folder),
-                    Has("bar.h\"", CompletionItemKind::File)));
+              AllOf(has("sub/", CompletionItemKind::Folder),
+                    has("bar.h\"", CompletionItemKind::File)));
 }
 
 TEST(CompletionTest, NoCrashAtNonAlphaIncludeHeader) {
   completions(
       R"cpp(
         #include "./^"
       )cpp");
 }
 
 TEST(CompletionTest, NoAllScopesCompletionWhenQualified) {
   clangd::CodeCompleteOptions Opts = {};
   Opts.AllScopes = true;
 
   auto Results = completions(
       R"cpp(
     void f() { na::Clangd^ }
   )cpp",
       {cls("na::ClangdA"), cls("nx::ClangdX"), cls("Clangd3")}, Opts);
   EXPECT_THAT(Results.Completions,
               UnorderedElementsAre(
-                  AllOf(Qualifier(""), Scope("na::"), Named("ClangdA"))));
+                  AllOf(qualifier(""), scope("na::"), named("ClangdA"))));
 }
 
 TEST(CompletionTest, AllScopesCompletion) {
   clangd::CodeCompleteOptions Opts = {};
   Opts.AllScopes = true;
 
   auto Results = completions(
       R"cpp(
     namespace na {
     void f() { Clangd^ }
     }
   )cpp",
       {cls("nx::Clangd1"), cls("ny::Clangd2"), cls("Clangd3"),
        cls("na::nb::Clangd4")},
       Opts);
   EXPECT_THAT(
       Results.Completions,
-      UnorderedElementsAre(AllOf(Qualifier("nx::"), Named("Clangd1")),
-                           AllOf(Qualifier("ny::"), Named("Clangd2")),
-                           AllOf(Qualifier(""), Scope(""), Named("Clangd3")),
-                           AllOf(Qualifier("nb::"), Named("Clangd4"))));
+      UnorderedElementsAre(AllOf(qualifier("nx::"), named("Clangd1")),
+                           AllOf(qualifier("ny::"), named("Clangd2")),
+                           AllOf(qualifier(""), scope(""), named("Clangd3")),
+                           AllOf(qualifier("nb::"), named("Clangd4"))));
 }
 
 TEST(CompletionTest, NoQualifierIfShadowed) {
   clangd::CodeCompleteOptions Opts = {};
   Opts.AllScopes = true;
 
   auto Results = completions(R"cpp(
     namespace nx { class Clangd1 {}; }
     using nx::Clangd1;
     void f() { Clangd^ }
   )cpp",
                              {cls("nx::Clangd1"), cls("nx::Clangd2")}, Opts);
   // Although Clangd1 is from another namespace, Sema tells us it's in-scope and
   // needs no qualifier.
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(AllOf(Qualifier(""), Named("Clangd1")),
-                                   AllOf(Qualifier("nx::"), Named("Clangd2"))));
+              UnorderedElementsAre(AllOf(qualifier(""), named("Clangd1")),
+                                   AllOf(qualifier("nx::"), named("Clangd2"))));
 }
 
 TEST(CompletionTest, NoCompletionsForNewNames) {
   clangd::CodeCompleteOptions Opts;
   Opts.AllScopes = true;
   auto Results = completions(R"cpp(
       void f() { int n^ }
     )cpp",
auto Results = completions(R"objc(
       @property(nonatomic, setter=setXToIgnoreComplete:) int value;
       @end
       Foo *foo = [Foo new]; int y = [foo v^]
     )objc",
                              /*IndexSymbols=*/{},
                              /*Opts=*/{}, "Foo.m");
 
   auto C = Results.Completions;
-  EXPECT_THAT(C, ElementsAre(Named("value")));
-  EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
-  EXPECT_THAT(C, ElementsAre(ReturnType("int")));
-  EXPECT_THAT(C, ElementsAre(Signature("")));
-  EXPECT_THAT(C, ElementsAre(SnippetSuffix("")));
+  EXPECT_THAT(C, ElementsAre(named("value")));
+  EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+  EXPECT_THAT(C, ElementsAre(returnType("int")));
+  EXPECT_THAT(C, ElementsAre(signature("")));
+  EXPECT_THAT(C, ElementsAre(snippetSuffix("")));
 }
 
 TEST(CompletionTest, ObjectiveCMethodOneArgument) {
   auto Results = completions(R"objc(
       @interface Foo
       - (int)valueForCharacter:(char)c;
       @end
       Foo *foo = [Foo new]; int y = [foo v^]
     )objc",
                              /*IndexSymbols=*/{},
                              /*Opts=*/{}, "Foo.m");
 
   auto C = Results.Completions;
-  EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:")));
-  EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
-  EXPECT_THAT(C, ElementsAre(ReturnType("int")));
-  EXPECT_THAT(C, ElementsAre(Signature("(char)")));
-  EXPECT_THAT(C, ElementsAre(SnippetSuffix("${1:(char)}")));
+  EXPECT_THAT(C, ElementsAre(named("valueForCharacter:")));
+  EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+  EXPECT_THAT(C, ElementsAre(returnType("int")));
+  EXPECT_THAT(C, ElementsAre(signature("(char)")));
+  EXPECT_THAT(C, ElementsAre(snippetSuffix("${1:(char)}")));
 }
 
 TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromBeginning) {
   auto Results = completions(R"objc(
       @interface Foo
       + (id)fooWithValue:(int)value fooey:(unsigned int)fooey;
       @end
       id val = [Foo foo^]
     )objc",
                              /*IndexSymbols=*/{},
                              /*Opts=*/{}, "Foo.m");
 
   auto C = Results.Completions;
-  EXPECT_THAT(C, ElementsAre(Named("fooWithValue:")));
-  EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
-  EXPECT_THAT(C, ElementsAre(ReturnType("id")));
-  EXPECT_THAT(C, ElementsAre(Signature("(int) fooey:(unsigned int)")));
+  EXPECT_THAT(C, ElementsAre(named("fooWithValue:")));
+  EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+  EXPECT_THAT(C, ElementsAre(returnType("id")));
+  EXPECT_THAT(C, ElementsAre(signature("(int) fooey:(unsigned int)")));
   EXPECT_THAT(
-      C, ElementsAre(SnippetSuffix("${1:(int)} fooey:${2:(unsigned int)}")));
+      C, ElementsAre(snippetSuffix("${1:(int)} fooey:${2:(unsigned int)}")));
 }
 
 TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromMiddle) {
   auto Results = completions(R"objc(
       @interface Foo
       + (id)fooWithValue:(int)value fooey:(unsigned int)fooey;
       @end
       id val = [Foo fooWithValue:10 f^]
     )objc",
                              /*IndexSymbols=*/{},
                              /*Opts=*/{}, "Foo.m");
 
   auto C = Results.Completions;
-  EXPECT_THAT(C, ElementsAre(Named("fooey:")));
-  EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
-  EXPECT_THAT(C, ElementsAre(ReturnType("id")));
-  EXPECT_THAT(C, ElementsAre(Signature("(unsigned int)")));
-  EXPECT_THAT(C, ElementsAre(SnippetSuffix("${1:(unsigned int)}")));
+  EXPECT_THAT(C, ElementsAre(named("fooey:")));
+  EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+  EXPECT_THAT(C, ElementsAre(returnType("id")));
+  EXPECT_THAT(C, ElementsAre(signature("(unsigned int)")));
+  EXPECT_THAT(C, ElementsAre(snippetSuffix("${1:(unsigned int)}")));
 }
 
 TEST(CompletionTest, ObjectiveCSimpleMethodDeclaration) {
   auto Results = completions(R"objc(
       @interface Foo
       - (void)foo;
       @end
       @implementation Foo
       fo^
       @end
     )objc",
                              /*IndexSymbols=*/{},
                              /*Opts=*/{}, "Foo.m");
 
   auto C = Results.Completions;
-  EXPECT_THAT(C, ElementsAre(Named("foo")));
-  EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
-  EXPECT_THAT(C, ElementsAre(Qualifier("- (void)")));
+  EXPECT_THAT(C, ElementsAre(named("foo")));
+  EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+  EXPECT_THAT(C, ElementsAre(qualifier("- (void)")));
 }
 
 TEST(CompletionTest, ObjectiveCMethodDeclaration) {
   auto Results = completions(R"objc(
       @interface Foo
       - (int)valueForCharacter:(char)c secondArgument:(id)object;
       @end
       @implementation Foo
       valueFor^
       @end
     )objc",
                              /*IndexSymbols=*/{},
                              /*Opts=*/{}, "Foo.m");
 
   auto C = Results.Completions;
-  EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:")));
-  EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
-  EXPECT_THAT(C, ElementsAre(Qualifier("- (int)")));
-  EXPECT_THAT(C, ElementsAre(Signature("(char)c secondArgument:(id)object")));
+  EXPECT_THAT(C, ElementsAre(named("valueForCharacter:")));
+  EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+  EXPECT_THAT(C, ElementsAre(qualifier("- (int)")));
+  EXPECT_THAT(C, ElementsAre(signature("(char)c secondArgument:(id)object")));
 }
 
 TEST(CompletionTest, ObjectiveCMethodDeclarationPrefixTyped) {
   auto Results = completions(R"objc(
       @interface Foo
       - (int)valueForCharacter:(char)c;
       @end
       @implementation Foo
       - (int)valueFor^
       @end
     )objc",
                              /*IndexSymbols=*/{},
                              /*Opts=*/{}, "Foo.m");
 
   auto C = Results.Completions;
-  EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:")));
-  EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
-  EXPECT_THAT(C, ElementsAre(Signature("(char)c")));
+  EXPECT_THAT(C, ElementsAre(named("valueForCharacter:")));
+  EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+  EXPECT_THAT(C, ElementsAre(signature("(char)c")));
 }
 
 TEST(CompletionTest, ObjectiveCMethodDeclarationFromMiddle) {
   auto Results = completions(R"objc(
       @interface Foo
       - (int)valueForCharacter:(char)c secondArgument:(id)object;
       @end
       @implementation Foo
       - (int)valueForCharacter:(char)c second^
       @end
     )objc",
                              /*IndexSymbols=*/{},
                              /*Opts=*/{}, "Foo.m");
 
   auto C = Results.Completions;
-  EXPECT_THAT(C, ElementsAre(Named("secondArgument:")));
-  EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
-  EXPECT_THAT(C, ElementsAre(Signature("(id)object")));
+  EXPECT_THAT(C, ElementsAre(named("secondArgument:")));
+  EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+  EXPECT_THAT(C, ElementsAre(signature("(id)object")));
 }
 
 TEST(CompletionTest, CursorInSnippets) {
   clangd::CodeCompleteOptions Options;
   Options.EnableSnippets = true;
   auto Results = completions(
       R"cpp(
     void while_foo(int a, int b);
     void test() {
       whil^
     })cpp",
       /*IndexSymbols=*/{}, Options);
 
   // Last placeholder in code patterns should be $0 to put the cursor there.
   EXPECT_THAT(Results.Completions,
               Contains(AllOf(
-                  Named("while"),
-                  SnippetSuffix(" (${1:condition}) {\n${0:statements}\n}"))));
+                  named("while"),
+                  snippetSuffix(" (${1:condition}) {\n${0:statements}\n}"))));
   // However, snippets for functions must *not* end with $0.
   EXPECT_THAT(Results.Completions,
-              Contains(AllOf(Named("while_foo"),
-                             SnippetSuffix("(${1:int a}, ${2:int b})"))));
+              Contains(AllOf(named("while_foo"),
+                             snippetSuffix("(${1:int a}, ${2:int b})"))));
 }
 
 TEST(CompletionTest, WorksWithNullType) {
   auto R = completions(R"cpp(
     int main() {
       for (auto [loopVar] : y ) { // y has to be unresolved.
         int z = loopV^;
       }
     }
   )cpp");
-  EXPECT_THAT(R.Completions, ElementsAre(Named("loopVar")));
+  EXPECT_THAT(R.Completions, ElementsAre(named("loopVar")));
 }
 
 TEST(CompletionTest, UsingDecl) {
   const char *Header(R"cpp(
     void foo(int);
     namespace std {
       using ::foo;
     })cpp");
   const char *Source(R"cpp(
     void bar() {
       std::^;
     })cpp");
   auto Index = TestTU::withHeaderCode(Header).index();
   clangd::CodeCompleteOptions Opts;
   Opts.Index = Index.get();
   Opts.AllScopes = true;
   auto R = completions(Source, {}, Opts);
   EXPECT_THAT(R.Completions,
-              ElementsAre(AllOf(Scope("std::"), Named("foo"),
-                                Kind(CompletionItemKind::Reference))));
+              ElementsAre(AllOf(scope("std::"), named("foo"),
+                                kind(CompletionItemKind::Reference))));
 }
 
 TEST(CompletionTest, ScopeIsUnresolved) {
   clangd::CodeCompleteOptions Opts = {};
   Opts.AllScopes = true;
 
   auto Results = completions(R"cpp(
     namespace a {
     void f() { b::X^ }
     }
   )cpp",
                              {cls("a::b::XYZ")}, Opts);
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(AllOf(Qualifier(""), Named("XYZ"))));
+              UnorderedElementsAre(AllOf(qualifier(""), named("XYZ"))));
 }
 
 TEST(CompletionTest, NestedScopeIsUnresolved) {
   clangd::CodeCompleteOptions Opts = {};
   Opts.AllScopes = true;
 
   auto Results = completions(R"cpp(
     namespace a {
     namespace b {}
     void f() { b::c::X^ }
     }
   )cpp",
                              {cls("a::b::c::XYZ")}, Opts);
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(AllOf(Qualifier(""), Named("XYZ"))));
+              UnorderedElementsAre(AllOf(qualifier(""), named("XYZ"))));
 }
 
 // Clang parser gets confused here and doesn't report the ns:: prefix.
 // Naive behavior is to insert it again. We examine the source and recover.
 TEST(CompletionTest, NamespaceDoubleInsertion) {
   clangd::CodeCompleteOptions Opts = {};
 
   auto Results = completions(R"cpp(
     namespace foo {
     namespace ns {}
     #define M(X) < X
     M(ns::ABC^
     }
   )cpp",
                              {cls("foo::ns::ABCDE")}, Opts);
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(AllOf(Qualifier(""), Named("ABCDE"))));
+              UnorderedElementsAre(AllOf(qualifier(""), named("ABCDE"))));
 }
 
 TEST(CompletionTest, DerivedMethodsAreAlwaysVisible) {
   // Despite the fact that base method matches the ref-qualifier better,
   // completion results should only include the derived method.
   auto Completions = completions(R"cpp(
     struct deque_base {
       float size();
       double size() const;
     };
     struct deque : deque_base {
         int size() const;
     };
 
     auto x = deque().^
   )cpp")
                          .Completions;
   EXPECT_THAT(Completions,
-              ElementsAre(AllOf(ReturnType("int"), Named("size"))));
+              ElementsAre(AllOf(returnType("int"), named("size"))));
 }
 
 TEST(CompletionTest, NoCrashWithIncompleteLambda) {
   auto Completions = completions("auto&& x = []{^").Completions;
   // The completion of x itself can cause a problem: in the code completion
   // callback, its type is not known, which affects the linkage calculation.
   // A bad linkage value gets cached, and subsequently updated.
-  EXPECT_THAT(Completions, Contains(Named("x")));
+  EXPECT_THAT(Completions, Contains(named("x")));
 
   auto Signatures = signatures("auto x() { x(^").signatures;
-  EXPECT_THAT(Signatures, Contains(Sig("x() -> auto")));
+  EXPECT_THAT(Signatures, Contains(sig("x() -> auto")));
 }
 
 TEST(CompletionTest, DelayedTemplateParsing) {
   Annotations Test(R"cpp(
     int xxx;
     template <typename T> int foo() { return xx^; }
   )cpp");
   auto TU = TestTU::withCode(Test.code());
   // Even though delayed-template-parsing is on, we will disable it to provide
   // completion in templates.
   TU.ExtraArgs.push_back("-fdelayed-template-parsing");
 
   EXPECT_THAT(completions(TU, Test.point()).Completions,
-              Contains(Named("xxx")));
+              Contains(named("xxx")));
 }
 
 TEST(CompletionTest, CompletionRange) {
   const char *WithRange = "auto x = [[abc]]^";
   auto Completions = completions(WithRange);
   EXPECT_EQ(Completions.CompletionRange, Annotations(WithRange).range());
   Completions = completionsNoCompile(WithRange);
   EXPECT_EQ(Completions.CompletionRange, Annotations(WithRange).range());
auto Results = completionsNoCompile(R"cpp(
     void func() {
       int xyz;
       int abc;
       ^
     }
   )cpp");
   EXPECT_FALSE(Results.RanParser);
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(Named("void"), Named("func"), Named("int"),
-                                   Named("xyz"), Named("abc")));
+              UnorderedElementsAre(named("void"), named("func"), named("int"),
+                                   named("xyz"), named("abc")));
 }
 
 TEST(NoCompileCompletionTest, WithFilter) {
   auto Results = completionsNoCompile(R"cpp(
     void func() {
       int sym1;
       int sym2;
       int xyz1;
       int xyz2;
       sy^
     }
   )cpp");
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(Named("sym1"), Named("sym2")));
+              UnorderedElementsAre(named("sym1"), named("sym2")));
 }
 
 TEST(NoCompileCompletionTest, WithIndex) {
   std::vector<Symbol> Syms = {func("xxx"), func("a::xxx"), func("ns::b::xxx"),
                               func("c::xxx"), func("ns::d::xxx")};
   auto Results = completionsNoCompile(
       R"cpp(
         // Current-scopes, unqualified completion.
         using namespace a;
         namespace ns {
         using namespace b;
         void foo() {
         xx^
         }
         }
       )cpp",
       Syms);
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(AllOf(Qualifier(""), Scope("")),
-                                   AllOf(Qualifier(""), Scope("a::")),
-                                   AllOf(Qualifier(""), Scope("ns::b::"))));
+              UnorderedElementsAre(AllOf(qualifier(""), scope("")),
+                                   AllOf(qualifier(""), scope("a::")),
+                                   AllOf(qualifier(""), scope("ns::b::"))));
   CodeCompleteOptions Opts;
   Opts.AllScopes = true;
   Results = completionsNoCompile(
       R"cpp(
         // All-scopes unqualified completion.
         using namespace a;
         namespace ns {
         using namespace b;
         void foo() {
         xx^
         }
         }
       )cpp",
       Syms, Opts);
   EXPECT_THAT(Results.Completions,
-              UnorderedElementsAre(AllOf(Qualifier(""), Scope("")),
-                                   AllOf(Qualifier(""), Scope("a::")),
-                                   AllOf(Qualifier(""), Scope("ns::b::")),
-                                   AllOf(Qualifier("c::"), Scope("c::")),
-                                   AllOf(Qualifier("d::"), Scope("ns::d::"))));
+              UnorderedElementsAre(AllOf(qualifier(""), scope("")),
+                                   AllOf(qualifier(""), scope("a::")),
+                                   AllOf(qualifier(""), scope("ns::b::")),
+                                   AllOf(qualifier("c::"), scope("c::")),
+                                   AllOf(qualifier("d::"), scope("ns::d::"))));
   Results = completionsNoCompile(
       R"cpp(
         // Qualified completion.
         using namespace a;
         namespace ns {
         using namespace b;
         void foo() {
         b::xx^
         }
         }
       )cpp",
       Syms, Opts);
   EXPECT_THAT(Results.Completions,
-              ElementsAre(AllOf(Qualifier(""), Scope("ns::b::"))));
+              ElementsAre(AllOf(qualifier(""), scope("ns::b::"))));
   Results = completionsNoCompile(
       R"cpp(
         // Absolutely qualified completion.
         using namespace a;
         namespace ns {
         using namespace b;
         void foo() {
         ::a::xx^
         }
         }
       )cpp",
       Syms, Opts);
   EXPECT_THAT(Results.Completions,
-              ElementsAre(AllOf(Qualifier(""), Scope("a::"))));
+              ElementsAre(AllOf(qualifier(""), scope("a::"))));
 }
 
 TEST(AllowImplicitCompletion, All) {
   const char *Yes[] = {
       "foo.^bar",
       "foo->^bar",
       "foo::^bar",
       "  #  include <^foo.h>",
std::string Context = R"cpp(
     };
     template <typename T>
     struct Container {
       Container(int Size) {}
     };
   )cpp";
   EXPECT_THAT(completions(Context + "int y = fo^", {}, Opts).Completions,
               UnorderedElementsAre(
-                  AllOf(Labeled("foo(int A)"), SnippetSuffix("(${1:int A})"))));
+                  AllOf(labeled("foo(int A)"), snippetSuffix("(${1:int A})"))));
   EXPECT_THAT(
       completions(Context + "int y = fo^(42)", {}, Opts).Completions,
-      UnorderedElementsAre(AllOf(Labeled("foo(int A)"), SnippetSuffix(""))));
+      UnorderedElementsAre(AllOf(labeled("foo(int A)"), snippetSuffix(""))));
   // FIXME(kirillbobyrev): No snippet should be produced here.
   EXPECT_THAT(completions(Context + "int y = fo^o(42)", {}, Opts).Completions,
               UnorderedElementsAre(
-                  AllOf(Labeled("foo(int A)"), SnippetSuffix("(${1:int A})"))));
+                  AllOf(labeled("foo(int A)"), snippetSuffix("(${1:int A})"))));
   EXPECT_THAT(
       completions(Context + "int y = ba^", {}, Opts).Completions,
-      UnorderedElementsAre(AllOf(Labeled("bar()"), SnippetSuffix("()"))));
+      UnorderedElementsAre(AllOf(labeled("bar()"), snippetSuffix("()"))));
   EXPECT_THAT(completions(Context + "int y = ba^()", {}, Opts).Completions,
-              UnorderedElementsAre(AllOf(Labeled("bar()"), SnippetSuffix(""))));
+              UnorderedElementsAre(AllOf(labeled("bar()"), snippetSuffix(""))));
   EXPECT_THAT(
       completions(Context + "Object o = Obj^", {}, Opts).Completions,
-      Contains(AllOf(Labeled("Object(int B)"), SnippetSuffix("(${1:int B})"),
-                     Kind(CompletionItemKind::Constructor))));
+      Contains(AllOf(labeled("Object(int B)"), snippetSuffix("(${1:int B})"),
+                     kind(CompletionItemKind::Constructor))));
   EXPECT_THAT(completions(Context + "Object o = Obj^()", {}, Opts).Completions,
-              Contains(AllOf(Labeled("Object(int B)"), SnippetSuffix(""),
-                             Kind(CompletionItemKind::Constructor))));
+              Contains(AllOf(labeled("Object(int B)"), snippetSuffix(""),
+                             kind(CompletionItemKind::Constructor))));
   EXPECT_THAT(
       completions(Context + "Container c = Cont^", {}, Opts).Completions,
-      Contains(AllOf(Labeled("Container<typename T>(int Size)"),
-                     SnippetSuffix("<${1:typename T}>(${2:int Size})"),
-                     Kind(CompletionItemKind::Constructor))));
+      Contains(AllOf(labeled("Container<typename T>(int Size)"),
+                     snippetSuffix("<${1:typename T}>(${2:int Size})"),
+                     kind(CompletionItemKind::Constructor))));
   EXPECT_THAT(
       completions(Context + "Container c = Cont^()", {}, Opts).Completions,
-      Contains(AllOf(Labeled("Container<typename T>(int Size)"),
-                     SnippetSuffix("<${1:typename T}>"),
-                     Kind(CompletionItemKind::Constructor))));
+      Contains(AllOf(labeled("Container<typename T>(int Size)"),
+                     snippetSuffix("<${1:typename T}>"),
+                     kind(CompletionItemKind::Constructor))));
   EXPECT_THAT(
       completions(Context + "Container c = Cont^<int>()", {}, Opts).Completions,
-      Contains(AllOf(Labeled("Container<typename T>(int Size)"),
-                     SnippetSuffix(""),
-                     Kind(CompletionItemKind::Constructor))));
+      Contains(AllOf(labeled("Container<typename T>(int Size)"),
+                     snippetSuffix(""),
+                     kind(CompletionItemKind::Constructor))));
   EXPECT_THAT(completions(Context + "MAC^(2)", {}, Opts).Completions,
-              Contains(AllOf(Labeled("MACRO(x)"), SnippetSuffix(""),
-                             Kind(CompletionItemKind::Text))));
+              Contains(AllOf(labeled("MACRO(x)"), snippetSuffix(""),
+                             kind(CompletionItemKind::Text))));
 }
 
 TEST(CompletionTest, NoCrashDueToMacroOrdering) {
   EXPECT_THAT(completions(R"cpp(
     #define ECHO(X) X
     #define ECHO2(X) ECHO(X)
     int finish_preamble = EC^HO(2);)cpp")
                   .Completions,
-              UnorderedElementsAre(Labeled("ECHO(X)"), Labeled("ECHO2(X)")));
+              UnorderedElementsAre(labeled("ECHO(X)"), labeled("ECHO2(X)")));
 }
 
 TEST(CompletionTest, ObjCCategoryDecls) {
   TestTU TU;
   TU.ExtraArgs.push_back("-xobjective-c");
   TU.HeaderCode = R"objc(
   @interface Foo
   @end
TEST(CompletionTest, ObjCCategoryDecls) {
   {
     Annotations Test(R"objc(
   @implementation Foo (^)
   @end
   )objc");
     TU.Code = Test.code().str();
     auto Results = completions(TU, Test.point());
     EXPECT_THAT(Results.Completions,
-                UnorderedElementsAre(Labeled("FooExt1"), Labeled("FooExt2")));
+                UnorderedElementsAre(labeled("FooExt1"), labeled("FooExt2")));
   }
   {
     Annotations Test(R"objc(
   @interface Foo (^)
   @end
   )objc");
     TU.Code = Test.code().str();
     auto Results = completions(TU, Test.point());
-    EXPECT_THAT(Results.Completions, UnorderedElementsAre(Labeled("BarExt")));
+    EXPECT_THAT(Results.Completions, UnorderedElementsAre(labeled("BarExt")));
   }
 }
 
 TEST(CompletionTest, PreambleCodeComplete) {
   llvm::StringLiteral Baseline = "\n#define MACRO 12\nint num = MACRO;";
   llvm::StringLiteral ModifiedCC =
       "#include \"header.h\"\n#define MACRO 12\nint num = MACRO; int num2 = M^";
 
const std::string Code = R"cpp(
     void fun(int foo, int bar);
     void overloaded(int param_int);
     void overloaded(int param_int, int param_other);
     void overloaded(char param_char);
     int main() {
   )cpp";
 
   EXPECT_THAT(completions(Code + "fun(/*^", {}, Opts).Completions,
-              UnorderedElementsAre(Labeled("foo=")));
+              UnorderedElementsAre(labeled("foo=")));
   EXPECT_THAT(completions(Code + "fun(1, /*^", {}, Opts).Completions,
-              UnorderedElementsAre(Labeled("bar=")));
+              UnorderedElementsAre(labeled("bar=")));
   EXPECT_THAT(completions(Code + "/*^", {}, Opts).Completions, IsEmpty());
   // Test de-duplication.
   EXPECT_THAT(
       completions(Code + "overloaded(/*^", {}, Opts).Completions,
-      UnorderedElementsAre(Labeled("param_int="), Labeled("param_char=")));
+      UnorderedElementsAre(labeled("param_int="), labeled("param_char=")));
   // Comment already has some text in it.
   EXPECT_THAT(completions(Code + "fun(/*  ^", {}, Opts).Completions,
-              UnorderedElementsAre(Labeled("foo=")));
+              UnorderedElementsAre(labeled("foo=")));
   EXPECT_THAT(completions(Code + "fun(/* f^", {}, Opts).Completions,
-              UnorderedElementsAre(Labeled("foo=")));
+              UnorderedElementsAre(labeled("foo=")));
   EXPECT_THAT(completions(Code + "fun(/* x^", {}, Opts).Completions, IsEmpty());
   EXPECT_THAT(completions(Code + "fun(/* f ^", {}, Opts).Completions,
               IsEmpty());
 }
 
 TEST(SignatureHelp, DocFormat) {
   Annotations Code(R"cpp(
     // Comment `with` markup.
TEST(SignatureHelp, TemplateArguments) {
   std::string Top = R"cpp(
     template <typename T, int> bool foo(char);
     template <int I, int> bool foo(float);
   )cpp";
 
   auto First = signatures(Top + "bool x = foo<^");
   EXPECT_THAT(
       First.signatures,
-      UnorderedElementsAre(Sig("foo<[[typename T]], [[int]]>() -> bool"),
-                           Sig("foo<[[int I]], [[int]]>() -> bool")));
+      UnorderedElementsAre(sig("foo<[[typename T]], [[int]]>() -> bool"),
+                           sig("foo<[[int I]], [[int]]>() -> bool")));
   EXPECT_EQ(First.activeParameter, 0);
 
   auto Second = signatures(Top + "bool x = foo<1, ^");
   EXPECT_THAT(Second.signatures,
-              ElementsAre(Sig("foo<[[int I]], [[int]]>() -> bool")));
+              ElementsAre(sig("foo<[[int I]], [[int]]>() -> bool")));
   EXPECT_EQ(Second.activeParameter, 1);
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

TEST(CommandMangler, ClangPath) {
   Cmd = {"foo/unknown-binary", "foo.cc"};
   Mangler.adjust(Cmd, "foo.cc");
   EXPECT_EQ("foo/unknown-binary", Cmd.front());
 }
 
 // Only run the PATH/symlink resolving test on unix, we need to fiddle
 // with permissions and environment variables...
 #ifdef LLVM_ON_UNIX
-MATCHER(Ok, "") {
+MATCHER(ok, "") {
   if (arg) {
     *result_listener << arg.message();
     return false;
   }
   return true;
 }
 
 TEST(CommandMangler, ClangPathResolve) {
   // Set up filesystem:
   //   /temp/
   //     bin/
   //       foo -> temp/lib/bar
   //     lib/
   //       bar
   llvm::SmallString<256> TempDir;
   ASSERT_THAT(llvm::sys::fs::createUniqueDirectory("ClangPathResolve", TempDir),
-              Ok());
+              ok());
   // /var/tmp is a symlink on Mac. Resolve it so we're asserting the right path.
-  ASSERT_THAT(llvm::sys::fs::real_path(TempDir.str(), TempDir), Ok());
+  ASSERT_THAT(llvm::sys::fs::real_path(TempDir.str(), TempDir), ok());
   auto CleanDir = llvm::make_scope_exit(
       [&] { llvm::sys::fs::remove_directories(TempDir); });
-  ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/bin"), Ok());
-  ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/lib"), Ok());
+  ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/bin"), ok());
+  ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/lib"), ok());
   int FD;
-  ASSERT_THAT(llvm::sys::fs::openFileForWrite(TempDir + "/lib/bar", FD), Ok());
-  ASSERT_THAT(llvm::sys::Process::SafelyCloseFileDescriptor(FD), Ok());
+  ASSERT_THAT(llvm::sys::fs::openFileForWrite(TempDir + "/lib/bar", FD), ok());
+  ASSERT_THAT(llvm::sys::Process::SafelyCloseFileDescriptor(FD), ok());
   ::chmod((TempDir + "/lib/bar").str().c_str(), 0755); // executable
   ASSERT_THAT(
       llvm::sys::fs::create_link(TempDir + "/lib/bar", TempDir + "/bin/foo"),
-      Ok());
+      ok());
 
   // Test the case where the driver is an absolute path to a symlink.
   auto Mangler = CommandMangler::forTests();
   Mangler.ClangPath = testPath("fake/clang");
   std::vector<std::string> Cmd = {(TempDir + "/bin/foo").str(), "foo.cc"};
   Mangler.adjust(Cmd, "foo.cc");
   // Directory based on resolved symlink, basename preserved.
   EXPECT_EQ((TempDir + "/lib/foo").str(), Cmd.front());

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

TEST_F(ConfigCompileTests, CompilationDatabase) {
 
   // Relative path not allowed without directory set.
   Frag.CompileFlags.CompilationDatabase.emplace("Something");
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
             Config::CDBSearchSpec::Ancestors)
       << "default value";
   EXPECT_THAT(Diags.Diagnostics,
-              ElementsAre(DiagMessage(
+              ElementsAre(diagMessage(
                   "CompilationDatabase must be an absolute path, because this "
                   "fragment is not associated with any directory.")));
 
   // Relative path allowed if directory is set.
   Frag.Source.Directory = testRoot();
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.CompileFlags.CDBSearch.Policy,
             Config::CDBSearchSpec::FixedDir);
TEST_F(ConfigCompileTests, Index) {
 
   Frag = {};
   Frag.Index.Background.emplace("Foo");
   EXPECT_TRUE(compileAndApply());
   EXPECT_EQ(Conf.Index.Background, Config::BackgroundPolicy::Build)
       << "by default";
   EXPECT_THAT(
       Diags.Diagnostics,
-      ElementsAre(DiagMessage(
+      ElementsAre(diagMessage(
           "Invalid Background value 'Foo'. Valid values are Build, Skip.")));
 }
 
 TEST_F(ConfigCompileTests, PathSpecMatch) {
   auto BarPath = llvm::sys::path::convert_to_slash(testPath("foo/bar.h"));
   Parm.Path = BarPath;
 
   struct {
EXPECT_EQ(
       Conf.Diagnostics.ClangTidy.Checks,
       "bugprone-use-after-move,llvm-*,-llvm-include-order,-readability-*");
   EXPECT_THAT(Diags.Diagnostics, IsEmpty());
 #else // !CLANGD_TIDY_CHECKS
   EXPECT_EQ(Conf.Diagnostics.ClangTidy.Checks, "llvm-*,-readability-*");
   EXPECT_THAT(
       Diags.Diagnostics,
       ElementsAre(
-          DiagMessage(
+          diagMessage(
               "clang-tidy check 'bugprone-use-after-move' was not found"),
-          DiagMessage("clang-tidy check 'llvm-include-order' was not found")));
+          diagMessage("clang-tidy check 'llvm-include-order' was not found")));
 #endif
 }
 
 TEST_F(ConfigCompileTests, TidyBadChecks) {
   auto &Tidy = Frag.Diagnostics.ClangTidy;
   Tidy.Add.emplace_back("unknown-check");
   Tidy.Remove.emplace_back("*");
   Tidy.Remove.emplace_back("llvm-includeorder");
   EXPECT_TRUE(compileAndApply());
   // Ensure bad checks are stripped from the glob.
   EXPECT_EQ(Conf.Diagnostics.ClangTidy.Checks, "-*");
   EXPECT_THAT(
       Diags.Diagnostics,
       ElementsAre(
-          AllOf(DiagMessage("clang-tidy check 'unknown-check' was not found"),
-                DiagKind(llvm::SourceMgr::DK_Warning)),
+          AllOf(diagMessage("clang-tidy check 'unknown-check' was not found"),
+                diagKind(llvm::SourceMgr::DK_Warning)),
           AllOf(
-              DiagMessage("clang-tidy check 'llvm-includeorder' was not found"),
-              DiagKind(llvm::SourceMgr::DK_Warning))));
+              diagMessage("clang-tidy check 'llvm-includeorder' was not found"),
+              diagKind(llvm::SourceMgr::DK_Warning))));
 }
 
 TEST_F(ConfigCompileTests, ExternalServerNeedsTrusted) {
   Fragment::IndexBlock::ExternalBlock External;
   External.Server.emplace("xxx");
   Frag.Index.External = std::move(External);
   compileAndApply();
   EXPECT_THAT(
       Diags.Diagnostics,
-      ElementsAre(DiagMessage(
+      ElementsAre(diagMessage(
           "Remote index may not be specified by untrusted configuration. "
           "Copy this into user config to use it.")));
   EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
 }
 
 TEST_F(ConfigCompileTests, ExternalBlockWarnOnMultipleSource) {
   Frag.Source.Trusted = true;
   Fragment::IndexBlock::ExternalBlock External;
   External.File.emplace("");
   External.Server.emplace("");
   Frag.Index.External = std::move(External);
   compileAndApply();
 #ifdef CLANGD_ENABLE_REMOTE
   EXPECT_THAT(
       Diags.Diagnostics,
       Contains(
-          AllOf(DiagMessage("Exactly one of File, Server or None must be set."),
-                DiagKind(llvm::SourceMgr::DK_Error))));
+          AllOf(diagMessage("Exactly one of File, Server or None must be set."),
+                diagKind(llvm::SourceMgr::DK_Error))));
 #else
   ASSERT_TRUE(Conf.Index.External.hasValue());
   EXPECT_EQ(Conf.Index.External->Kind, Config::ExternalIndexSpec::File);
 #endif
 }
 
 TEST_F(ConfigCompileTests, ExternalBlockDisableWithNone) {
   compileAndApply();
   EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
 
   Fragment::IndexBlock::ExternalBlock External;
   External.IsNone = true;
   Frag.Index.External = std::move(External);
   compileAndApply();
   EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
 }
 
 TEST_F(ConfigCompileTests, ExternalBlockErrOnNoSource) {
   Frag.Index.External.emplace(Fragment::IndexBlock::ExternalBlock{});
   compileAndApply();
   EXPECT_THAT(
       Diags.Diagnostics,
       Contains(
-          AllOf(DiagMessage("Exactly one of File, Server or None must be set."),
-                DiagKind(llvm::SourceMgr::DK_Error))));
+          AllOf(diagMessage("Exactly one of File, Server or None must be set."),
+                diagKind(llvm::SourceMgr::DK_Error))));
 }
 
 TEST_F(ConfigCompileTests, ExternalBlockDisablesBackgroundIndex) {
   auto BazPath = testPath("foo/bar/baz.h", llvm::sys::path::Style::posix);
   Parm.Path = BazPath;
   Frag.Index.Background.emplace("Build");
   Fragment::IndexBlock::ExternalBlock External;
   External.File.emplace(testPath("foo"));
TEST_F(ConfigCompileTests, ExternalBlockMountPoint) {
   BarPath = llvm::sys::path::convert_to_slash(BarPath);
   Parm.Path = BarPath;
   // Non-absolute MountPoint without a directory raises an error.
   Frag = GetFrag("", "foo");
   compileAndApply();
   ASSERT_THAT(
       Diags.Diagnostics,
       ElementsAre(
-          AllOf(DiagMessage("MountPoint must be an absolute path, because this "
+          AllOf(diagMessage("MountPoint must be an absolute path, because this "
                             "fragment is not associated with any directory."),
-                DiagKind(llvm::SourceMgr::DK_Error))));
+                diagKind(llvm::SourceMgr::DK_Error))));
   EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
 
   auto FooPath = testPath("foo/", llvm::sys::path::Style::posix);
   FooPath = llvm::sys::path::convert_to_slash(FooPath);
   // Ok when relative.
   Frag = GetFrag(testRoot(), "foo/");
   compileAndApply();
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());

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

 // cache their results.
 TEST(ProviderTest, Combine) {
   CapturedDiags Diags;
   FakeProvider Foo("foo");
   FakeProvider Bar("bar");
   auto Combined = Provider::combine({&Foo, &Bar});
   Config Cfg = Combined->getConfig(Params(), Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
-              ElementsAre(DiagMessage("foo"), DiagMessage("bar")));
+              ElementsAre(diagMessage("foo"), diagMessage("bar")));
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo1", "bar1"));
   Diags.Diagnostics.clear();
 
   Cfg = Combined->getConfig(Params(), Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
-              ElementsAre(DiagMessage("foo"), DiagMessage("bar")));
+              ElementsAre(diagMessage("foo"), diagMessage("bar")));
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo2", "bar2"));
 }
 
 const char *AddFooWithErr = R"yaml(
 CompileFlags:
   Add: foo
   Unknown: 42
 )yaml";

 TEST(ProviderTest, FromYAMLFile) {
   MockFS FS;
   FS.Files["foo.yaml"] = AddFooWithErr;
 
   CapturedDiags Diags;
   auto P = Provider::fromYAMLFile(testPath("foo.yaml"), /*Directory=*/"", FS);
   auto Cfg = P->getConfig(Params(), Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
-              ElementsAre(DiagMessage("Unknown CompileFlags key 'Unknown'")));
+              ElementsAre(diagMessage("Unknown CompileFlags key 'Unknown'")));
   EXPECT_THAT(Diags.Files, ElementsAre(testPath("foo.yaml")));
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
   Diags.clear();
 
   Cfg = P->getConfig(Params(), Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty()) << "Cached, not re-parsed";
   EXPECT_THAT(Diags.Files, IsEmpty());
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
 
   FS.Files["foo.yaml"] = AddFooWithTypoErr;
   Cfg = P->getConfig(Params(), Diags.callback());
   EXPECT_THAT(
       Diags.Diagnostics,
-      ElementsAre(DiagMessage(
+      ElementsAre(diagMessage(
           "Unknown CompileFlags key 'Removr'; did you mean 'Remove'?")));
   EXPECT_THAT(Diags.Files, ElementsAre(testPath("foo.yaml")));
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
   Diags.clear();
 
   FS.Files["foo.yaml"] = AddBarBaz;
   Cfg = P->getConfig(Params(), Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty()) << "New config, no errors";
TEST(ProviderTest, FromAncestorRelativeYAMLFiles) {
 
   auto Cfg = P->getConfig(Params(), Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty());
   EXPECT_THAT(Diags.Files, IsEmpty());
   EXPECT_THAT(getAddedArgs(Cfg), IsEmpty());
 
   Cfg = P->getConfig(ABCParams, Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
-              ElementsAre(DiagMessage("Unknown CompileFlags key 'Unknown'")));
+              ElementsAre(diagMessage("Unknown CompileFlags key 'Unknown'")));
   // FIXME: fails on windows: paths have mixed slashes like C:\a/b\c.yaml
   EXPECT_THAT(Diags.Files,
               ElementsAre(testPath("a/foo.yaml"), testPath("a/b/c/foo.yaml")));
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo", "bar", "baz"));
   Diags.clear();
 
   Cfg = P->getConfig(AParams, Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty()) << "Cached config";
TEST(ProviderTest, Staleness) {
   MustBeFresh.FreshTime = StartTime + std::chrono::hours(1);
   CapturedDiags Diags;
   auto P = Provider::fromYAMLFile(testPath("foo.yaml"), /*Directory=*/"", FS);
 
   // Initial query always reads, regardless of policy.
   FS.Files["foo.yaml"] = AddFooWithErr;
   auto Cfg = P->getConfig(StaleOK, Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
-              ElementsAre(DiagMessage("Unknown CompileFlags key 'Unknown'")));
+              ElementsAre(diagMessage("Unknown CompileFlags key 'Unknown'")));
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
   Diags.clear();
 
   // Stale value reused by policy.
   FS.Files["foo.yaml"] = AddBarBaz;
   Cfg = P->getConfig(StaleOK, Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty()) << "Cached, not re-parsed";
   EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));

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

struct CapturedDiags {
   std::vector<std::string> Files; // Filename from diagnostics including notes.
 
   void clear() {
     Diagnostics.clear();
     Files.clear();
   }
 };
 
-MATCHER_P(DiagMessage, M, "") { return arg.Message == M; }
-MATCHER_P(DiagKind, K, "") { return arg.Kind == K; }
-MATCHER_P(DiagPos, P, "") { return arg.Pos == P; }
-MATCHER_P(DiagRange, R, "") { return arg.Rng == R; }
+MATCHER_P(diagMessage, M, "") { return arg.Message == M; }
+MATCHER_P(diagKind, K, "") { return arg.Kind == K; }
+MATCHER_P(diagPos, P, "") { return arg.Pos == P; }
+MATCHER_P(diagRange, R, "") { return arg.Rng == R; }
 
 inline Position toPosition(llvm::SMLoc L, const llvm::SourceMgr &SM) {
   auto LineCol = SM.getLineAndColumn(L);
   Position P;
   P.line = LineCol.first - 1;
   P.character = LineCol.second - 1;
   return P;
 }

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

 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Testing/Support/SupportHelpers.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace config {
+
+// PrintTo is a magic identifier of GTest
+// NOLINTNEXTLINE (readability-identifier-naming)
 template <typename T> void PrintTo(const Located<T> &V, std::ostream *OS) {
   *OS << ::testing::PrintToString(*V);
 }
 
 namespace {
 using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::IsEmpty;
 
-MATCHER_P(Val, Value, "") {
+MATCHER_P(val, Value, "") {
   if (*arg == Value)
     return true;
   *result_listener << "value is " << *arg;
   return false;
 }
 
 MATCHER_P2(PairVal, Value1, Value2, "") {
   if (*arg.first == Value1 && *arg.second == Value2)
CheckOptions:
       example-check.ExampleOption: 0
   UnusedIncludes: Strict
   )yaml";
   auto Results = Fragment::parseYAML(YAML, "config.yaml", Diags.callback());
   EXPECT_THAT(Diags.Diagnostics, IsEmpty());
   EXPECT_THAT(Diags.Files, ElementsAre("config.yaml"));
   ASSERT_EQ(Results.size(), 4u);
   EXPECT_FALSE(Results[0].If.HasUnrecognizedCondition);
-  EXPECT_THAT(Results[0].If.PathMatch, ElementsAre(Val("abc")));
-  EXPECT_THAT(Results[0].CompileFlags.Add, ElementsAre(Val("foo"), Val("bar")));
+  EXPECT_THAT(Results[0].If.PathMatch, ElementsAre(val("abc")));
+  EXPECT_THAT(Results[0].CompileFlags.Add, ElementsAre(val("foo"), val("bar")));
 
-  EXPECT_THAT(Results[1].CompileFlags.Add, ElementsAre(Val("b\naz\n")));
+  EXPECT_THAT(Results[1].CompileFlags.Add, ElementsAre(val("b\naz\n")));
 
   ASSERT_TRUE(Results[2].Index.Background);
   EXPECT_EQ("Skip", *Results[2].Index.Background.getValue());
   EXPECT_THAT(Results[3].Diagnostics.ClangTidy.CheckOptions,
               ElementsAre(PairVal("IgnoreMacros", "true"),
                           PairVal("example-check.ExampleOption", "0")));
   EXPECT_TRUE(Results[3].Diagnostics.UnusedIncludes);
   EXPECT_EQ("Strict", *Results[3].Diagnostics.UnusedIncludes.getValue());

 ---
 CompileFlags: {$unexpected^
 )yaml");
   auto Results =
       Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
 
   ASSERT_THAT(
       Diags.Diagnostics,
-      ElementsAre(AllOf(DiagMessage("Unknown If key 'UnknownCondition'"),
-                        DiagKind(llvm::SourceMgr::DK_Warning),
-                        DiagPos(YAML.range("unknown").start),
-                        DiagRange(YAML.range("unknown"))),
-                  AllOf(DiagMessage("Unexpected token. Expected Key, Flow "
+      ElementsAre(AllOf(diagMessage("Unknown If key 'UnknownCondition'"),
+                        diagKind(llvm::SourceMgr::DK_Warning),
+                        diagPos(YAML.range("unknown").start),
+                        diagRange(YAML.range("unknown"))),
+                  AllOf(diagMessage("Unexpected token. Expected Key, Flow "
                                     "Entry, or Flow Mapping End."),
-                        DiagKind(llvm::SourceMgr::DK_Error),
-                        DiagPos(YAML.point("unexpected")),
-                        DiagRange(llvm::None))));
+                        diagKind(llvm::SourceMgr::DK_Error),
+                        diagPos(YAML.point("unexpected")),
+                        diagRange(llvm::None))));
 
   ASSERT_EQ(Results.size(), 1u); // invalid fragment discarded.
-  EXPECT_THAT(Results.front().CompileFlags.Add, ElementsAre(Val("first")));
+  EXPECT_THAT(Results.front().CompileFlags.Add, ElementsAre(val("first")));
   EXPECT_TRUE(Results.front().If.HasUnrecognizedCondition);
 }
 
 TEST(ParseYAML, Invalid) {
   CapturedDiags Diags;
   const char *YAML = R"yaml(
 If:
 
 horrible
 ---
 - 1
   )yaml";
   auto Results = Fragment::parseYAML(YAML, "config.yaml", Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
-              ElementsAre(DiagMessage("If should be a dictionary"),
-                          DiagMessage("Config should be a dictionary")));
+              ElementsAre(diagMessage("If should be a dictionary"),
+                          diagMessage("Config should be a dictionary")));
   ASSERT_THAT(Results, IsEmpty());
 }
 
 TEST(ParseYAML, ExternalBlockNone) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Index:
   External: None
External:
     File: "foo"
     Server: ^"bar"
     MountPoint: "baz"
   )yaml");
   auto Results =
       Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
   ASSERT_EQ(Results.size(), 1u);
   ASSERT_TRUE(Results[0].Index.External);
-  EXPECT_THAT(*Results[0].Index.External.getValue()->File, Val("foo"));
-  EXPECT_THAT(*Results[0].Index.External.getValue()->MountPoint, Val("baz"));
+  EXPECT_THAT(*Results[0].Index.External.getValue()->File, val("foo"));
+  EXPECT_THAT(*Results[0].Index.External.getValue()->MountPoint, val("baz"));
   ASSERT_THAT(Diags.Diagnostics, IsEmpty());
-  EXPECT_THAT(*Results[0].Index.External.getValue()->Server, Val("bar"));
+  EXPECT_THAT(*Results[0].Index.External.getValue()->Server, val("bar"));
 }
 
 TEST(ParseYAML, AllScopes) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Completion:
   AllScopes: True
   )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].Completion.AllScopes, llvm::ValueIs(Val(true)));
+  EXPECT_THAT(Results[0].Completion.AllScopes, llvm::ValueIs(val(true)));
 }
 
 TEST(ParseYAML, AllScopesWarn) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Completion:
   AllScopes: $diagrange[[Truex]]
   )yaml");
   auto Results =
       Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
   EXPECT_THAT(Diags.Diagnostics,
-              ElementsAre(AllOf(DiagMessage("AllScopes should be a boolean"),
-                                DiagKind(llvm::SourceMgr::DK_Warning),
-                                DiagPos(YAML.range("diagrange").start),
-                                DiagRange(YAML.range("diagrange")))));
+              ElementsAre(AllOf(diagMessage("AllScopes should be a boolean"),
+                                diagKind(llvm::SourceMgr::DK_Warning),
+                                diagPos(YAML.range("diagrange").start),
+                                diagRange(YAML.range("diagrange")))));
   ASSERT_EQ(Results.size(), 1u);
   EXPECT_THAT(Results[0].Completion.AllScopes, testing::Eq(llvm::None));
 }
 
 TEST(ParseYAML, ShowAKA) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 Hover:
   ShowAKA: True
   )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].Hover.ShowAKA, llvm::ValueIs(Val(true)));
+  EXPECT_THAT(Results[0].Hover.ShowAKA, llvm::ValueIs(val(true)));
 }
 
 TEST(ParseYAML, InlayHints) {
   CapturedDiags Diags;
   Annotations YAML(R"yaml(
 InlayHints:
   Enabled: No
   ParameterNames: 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].InlayHints.Enabled, llvm::ValueIs(Val(false)));
-  EXPECT_THAT(Results[0].InlayHints.ParameterNames, llvm::ValueIs(Val(true)));
+  EXPECT_THAT(Results[0].InlayHints.Enabled, llvm::ValueIs(val(false)));
+  EXPECT_THAT(Results[0].InlayHints.ParameterNames, llvm::ValueIs(val(true)));
   EXPECT_EQ(Results[0].InlayHints.DeducedTypes, llvm::None);
 }
 
 } // namespace
 } // namespace config
 } // namespace clangd
 } // namespace clang

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

 using ::testing::ElementsAre;
 using ::testing::Field;
 using ::testing::IsEmpty;
 using ::testing::Pair;
 using ::testing::SizeIs;
 using ::testing::UnorderedElementsAre;
 using testing::UnorderedElementsAreArray;
 
-::testing::Matcher<const Diag &> WithFix(::testing::Matcher<Fix> FixMatcher) {
+::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher) {
   return Field(&Diag::Fixes, ElementsAre(FixMatcher));
 }
 
-::testing::Matcher<const Diag &> WithFix(::testing::Matcher<Fix> FixMatcher1,
+::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher1,
                                          ::testing::Matcher<Fix> FixMatcher2) {
   return Field(&Diag::Fixes, UnorderedElementsAre(FixMatcher1, FixMatcher2));
 }
 
 ::testing::Matcher<const Diag &>
-WithNote(::testing::Matcher<Note> NoteMatcher) {
+withNote(::testing::Matcher<Note> NoteMatcher) {
   return Field(&Diag::Notes, ElementsAre(NoteMatcher));
 }
 
 ::testing::Matcher<const Diag &>
-WithNote(::testing::Matcher<Note> NoteMatcher1,
+withNote(::testing::Matcher<Note> NoteMatcher1,
          ::testing::Matcher<Note> NoteMatcher2) {
   return Field(&Diag::Notes, UnorderedElementsAre(NoteMatcher1, NoteMatcher2));
 }
 
 ::testing::Matcher<const Diag &>
-WithTag(::testing::Matcher<DiagnosticTag> TagMatcher) {
+withTag(::testing::Matcher<DiagnosticTag> TagMatcher) {
   return Field(&Diag::Tags, Contains(TagMatcher));
 }
 
-MATCHER_P(HasRange, Range, "") { return arg.Range == Range; }
+MATCHER_P(hasRange, Range, "") { return arg.Range == Range; }
 
 MATCHER_P2(Diag, Range, Message,
            "Diag at " + llvm::to_string(Range) + " = [" + Message + "]") {
   return arg.Range == Range && arg.Message == Message;
 }
 
 MATCHER_P3(Fix, Range, Replacement, Message,
            "Fix " + llvm::to_string(Range) + " => " +
                ::testing::PrintToString(Replacement) + " = [" + Message + "]") {
   return arg.Message == Message && arg.Edits.size() == 1 &&
          arg.Edits[0].range == Range && arg.Edits[0].newText == Replacement;
 }
 
-MATCHER_P(FixMessage, Message, "") { return arg.Message == Message; }
+MATCHER_P(fixMessage, Message, "") { return arg.Message == Message; }
 
-MATCHER_P(EqualToLSPDiag, LSPDiag,
+MATCHER_P(equalToLSPDiag, LSPDiag,
           "LSP diagnostic " + llvm::to_string(LSPDiag)) {
   if (toJSON(arg) != toJSON(LSPDiag)) {
     *result_listener << llvm::formatv("expected:\n{0:2}\ngot\n{1:2}",
                                       toJSON(LSPDiag), toJSON(arg))
                             .str();
     return false;
   }
   return true;
 }
 
-MATCHER_P(DiagSource, S, "") { return arg.Source == S; }
-MATCHER_P(DiagName, N, "") { return arg.Name == N; }
-MATCHER_P(DiagSeverity, S, "") { return arg.Severity == S; }
+MATCHER_P(diagSource, S, "") { return arg.Source == S; }
+MATCHER_P(diagName, N, "") { return arg.Name == N; }
+MATCHER_P(diagSeverity, S, "") { return arg.Severity == S; }
 
-MATCHER_P(EqualToFix, Fix, "LSP fix " + llvm::to_string(Fix)) {
+MATCHER_P(equalToFix, Fix, "LSP fix " + llvm::to_string(Fix)) {
   if (arg.Message != Fix.Message)
     return false;
   if (arg.Edits.size() != Fix.Edits.size())
     return false;
   for (std::size_t I = 0; I < arg.Edits.size(); ++I) {
     if (arg.Edits[I].range != Fix.Edits[I].range ||
         arg.Edits[I].newText != Fix.Edits[I].newText)
       return false;
   }
   return true;
 }
 
 // Helper function to make tests shorter.
-Position pos(int line, int character) {
+Position pos(int Line, int Character) {
   Position Res;
-  Res.line = line;
-  Res.character = character;
+  Res.line = Line;
+  Res.character = Character;
   return Res;
 }
 
 // Normally returns the provided diagnostics matcher.
 // If clang-tidy checks are not linked in, returns a matcher for no diagnostics!
 // This is intended for tests where the diagnostics come from clang-tidy checks.
 // We don't #ifdef each individual test as it's intrusive and we want to ensure
 // that as much of the test is still compiled an run as possible.
o]]();
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(
       *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 '*'"))),
+                withFix(Fix(Test.range("insertstar"), "*", "insert '*'"))),
           // This range spans lines.
           AllOf(Diag(Test.range("typo"),
                      "use of undeclared identifier 'goo'; did you mean 'foo'?"),
-                DiagSource(Diag::Clang), DiagName("undeclared_var_use_suggest"),
-                WithFix(
+                diagSource(Diag::Clang), diagName("undeclared_var_use_suggest"),
+                withFix(
                     Fix(Test.range("typo"), "foo", "change 'go\\…' to 'foo'")),
                 // This is a pretty normal range.
-                WithNote(Diag(Test.range("decl"), "'foo' declared here"))),
+                withNote(Diag(Test.range("decl"), "'foo' declared here"))),
           // This range is zero-width and insertion. Therefore make sure we are
           // not expanding it into other tokens. Since we are not going to
           // replace those.
           AllOf(Diag(Test.range("semicolon"), "expected ';' after expression"),
-                WithFix(Fix(Test.range("semicolon"), ";", "insert ';'"))),
+                withFix(Fix(Test.range("semicolon"), ";", "insert ';'"))),
           // This range isn't provided by clang, we expand to the token.
           Diag(Test.range("unk"), "use of undeclared identifier 'unknown'"),
           Diag(Test.range("type"),
                "cannot initialize a variable of type 'double' with an lvalue "
                "of type 'const char[4]'"),
           Diag(Test.range("nomember"), "no member named 'y' in 'Foo'"),
           Diag(Test.range("nomembernamespace"),
                "no member named 'test' in namespace 'test'"),
           AllOf(Diag(Test.range("macro"),
                      "use of undeclared identifier 'fod'; did you mean 'foo'?"),
-                WithFix(Fix(Test.range("macroarg"), "foo",
+                withFix(Fix(Test.range("macroarg"), "foo",
                             "change 'fod' to 'foo'")))));
 }
 
 // Verify that the -Wswitch case-not-covered diagnostic range covers the
 // whole expression. This is important because the "populate-switch" tweak
 // fires for the full expression range (see tweaks/PopulateSwitchTests.cpp).
 // The quickfix flow only works end-to-end if the tweak can be triggered on
 // the diagnostic's range.
EXPECT_THAT(*TU.build().getDiagnostics(),
                                "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(),
               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
-                                WithFix(Fix(Test.range(), "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(),
       ElementsAre(AllOf(
           Diag(Test.range(), "return type of 'main' is not 'int'"),
-          WithFix(Fix(Test.range(), "int", "change return type to '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(),
               ElementsAre(::testing::AllOf(
                   Diag(Test.range(), "'not-found.h' file not found"),
-                  DiagSource(Diag::Clang), DiagName("pp_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(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Test.range(),
                "floating point literal has suffix 'f', which is not uppercase"),
-          DiagSource(Diag::ClangTidy)))));
+          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(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Test.range(),
                "floating point literal has suffix 'f', which is not uppercase"),
-          DiagSource(Diag::ClangTidy)))));
+          diagSource(Diag::ClangTidy)))));
 }
 
 TEST(DiagnosticsTest, ClangTidy) {
   Annotations Test(R"cpp(
     #include $deprecated[["assert.h"]]
 
     #define $macrodef[[SQUARE]](X) (X)*(X)
     int $main[[main]]() {
TU.ClangTidyProvider = addTidyChecks("bugprone-sizeof-expression,"
                                        "misc-no-recursion");
   TU.ExtraArgs.push_back("-Wno-unsequenced");
   EXPECT_THAT(
       *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>",
+                diagSource(Diag::ClangTidy),
+                diagName("modernize-deprecated-headers"),
+                withFix(Fix(Test.range("deprecated"), "<cassert>",
                             "change '\"assert.h\"' to '<cassert>'"))),
           Diag(Test.range("doubled"),
                "suspicious usage of 'sizeof(sizeof(...))'"),
           AllOf(Diag(Test.range("macroarg"),
                      "side effects in the 1st macro argument 'X' are "
                      "repeated in "
                      "macro expansion"),
-                DiagSource(Diag::ClangTidy),
-                DiagName("bugprone-macro-repeated-side-effects"),
-                WithNote(Diag(Test.range("macrodef"),
+                diagSource(Diag::ClangTidy),
+                diagName("bugprone-macro-repeated-side-effects"),
+                withNote(Diag(Test.range("macrodef"),
                               "macro 'SQUARE' defined here"))),
           AllOf(Diag(Test.range("main"),
                      "use a trailing return type for this function"),
-                DiagSource(Diag::ClangTidy),
-                DiagName("modernize-use-trailing-return-type"),
+                diagSource(Diag::ClangTidy),
+                diagName("modernize-use-trailing-return-type"),
                 // Verify there's no "[check-name]" suffix in the message.
-                WithFix(FixMessage(
+                withFix(fixMessage(
                     "use a trailing return type for this function"))),
           Diag(Test.range("foo"),
                "function 'foo' is within a recursive call chain"),
           Diag(Test.range("bar"),
                "function 'bar' is within a recursive call chain"))));
 }
 
 TEST(DiagnosticsTest, ClangTidyEOF) {
   // clang-format off
   Annotations Test(R"cpp(
   [[#]]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(),
       ifTidyChecks(Contains(
           AllOf(Diag(Test.range(), "#includes are not sorted properly"),
-                DiagSource(Diag::ClangTidy), DiagName("llvm-include-order")))));
+                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(),
       ElementsAre(AllOf(
           Diag(Main.range(), "in template: base specifier must name a class"),
-          WithNote(Diag(Header.range(), "error occurred here"),
+          withNote(Diag(Header.range(), "error occurred here"),
                    Diag(Main.range(), "in instantiation of template class "
                                       "'Derived<int>' requested here")))));
 }
 
 TEST(DiagnosticTest, MakeUnique) {
   // We usually miss diagnostics from header functions as we don't parse them.
   // std::make_unique is an exception.
   Annotations Main(R"cpp(
Annotations Main(R"cpp(
     }
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider = addTidyChecks("modernize-loop-convert");
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
           Diag(Main.range(), "use range-based for loop instead"),
-          DiagSource(Diag::ClangTidy), DiagName("modernize-loop-convert")))));
+          diagSource(Diag::ClangTidy), diagName("modernize-loop-convert")))));
 }
 
 TEST(DiagnosticTest, RespectsDiagnosticConfig) {
   Annotations Main(R"cpp(
     // error-ok
     void x() {
       [[unknown]]();
       $ret[[return]] 42;
TEST(DiagnosticTest, ClangTidySuppressionComment) {
   )cpp");
   TestTU TU = TestTU::withCode(Main.code());
   TU.ClangTidyProvider = addTidyChecks("bugprone-integer-division");
   EXPECT_THAT(
       *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")))));
+          diagSource(Diag::ClangTidy),
+          diagName("bugprone-integer-division")))));
 }
 
 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(),
       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)))));
+          diagSource(Diag::ClangTidy), diagName("bugprone-integer-division"),
+          diagSeverity(DiagnosticsEngine::Error)))));
 }
 
 TidyProvider addClangArgs(std::vector<llvm::StringRef> ExtraArgs) {
   return [ExtraArgs = std::move(ExtraArgs)](tidy::ClangTidyOptions &Opts,
                                             llvm::StringRef) {
     if (!Opts.ExtraArgs)
       Opts.ExtraArgs.emplace();
     for (llvm::StringRef Arg : ExtraArgs)
       Opts.ExtraArgs->emplace_back(Arg);
   };
 }
 
 TEST(DiagnosticTest, ClangTidyEnablesClangWarning) {
   Annotations Main(R"cpp( // error-ok
     static void [[foo]]() {}
   )cpp");
   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));
+            diagName("-Wunused-function"), diagSource(Diag::Clang),
+            diagSeverity(DiagnosticsEngine::Warning));
 
   // Check the -Wunused warning isn't initially on.
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 
   // We enable warnings based on clang-tidy extra args.
   TU.ClangTidyProvider = addClangArgs({"-Wunused"});
   EXPECT_THAT(*TU.build().getDiagnostics(), ElementsAre(UnusedFooWarning));
 
   // But we don't respect other args.
   TU.ClangTidyProvider = addClangArgs({"-Wunused", "-Dfoo=bar"});
   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"});
   EXPECT_THAT(*TU.build().getDiagnostics(),
-              ElementsAre(DiagSeverity(DiagnosticsEngine::Warning)));
+              ElementsAre(diagSeverity(DiagnosticsEngine::Warning)));
 
   // But clang-tidy extra args won't *downgrade* errors to warnings either.
   TU.ExtraArgs = {"-Wunused", "-Werror"};
   TU.ClangTidyProvider = addClangArgs({"-Wunused"});
   EXPECT_THAT(*TU.build().getDiagnostics(),
-              ElementsAre(DiagSeverity(DiagnosticsEngine::Error)));
+              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"});
   EXPECT_THAT(*TU.build().getDiagnostics(),
-              ElementsAre(DiagSeverity(DiagnosticsEngine::Warning)));
+              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"});
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
 
   // Overriding only works in the proper order.
int main() {
       // error-ok
       int somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier;
       [[omereallyreallyreallyreallyreallyreallyreallyreallylongidentifier]]= 10;
     }
   )cpp");
   TestTU TU = TestTU::withCode(Source.code());
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
-      ElementsAre(WithFix(Fix(
+      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(),
-              ElementsAre(WithFix(
+              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(),
-      ElementsAre(WithFix((Fix(Source.range(), "\n", "insert '\\n'")))));
+      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
     }

 // 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(),
-              ElementsAre(DiagName("pp_including_mainfile_in_preamble")));
+              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"
auto TU = TestTU::withCode(R"cpp(
     #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(),
-              ElementsAre(DiagName("pp_including_mainfile_in_preamble")));
+              ElementsAre(diagName("pp_including_mainfile_in_preamble")));
   EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
 }
 
 TEST(DiagnosticsTest, InsideMacros) {
   Annotations Test(R"cpp(
     #define TEN 10
     #define RET(x) return x + 10
 
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(),
               ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
-                                Not(WithFix(_)))));
+                                Not(withFix(_)))));
 }
 
 TEST(DiagnosticsTest, PragmaSystemHeader) {
   Annotations Test("#pragma clang [[system_header]]\n");
   auto TU = TestTU::withCode(Test.code());
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       ElementsAre(AllOf(
toLSPDiags(D, MainFile, Opts,
              [&](clangd::Diagnostic LSPDiag, ArrayRef<clangd::Fix> Fixes) {
                LSPDiags.push_back(
                    {std::move(LSPDiag),
                     std::vector<clangd::Fix>(Fixes.begin(), Fixes.end())});
              });
 
   EXPECT_THAT(
       LSPDiags,
-      ElementsAre(Pair(EqualToLSPDiag(MainLSP), ElementsAre(EqualToFix(F))),
-                  Pair(EqualToLSPDiag(NoteInMainLSP), IsEmpty())));
+      ElementsAre(Pair(equalToLSPDiag(MainLSP), ElementsAre(equalToFix(F))),
+                  Pair(equalToLSPDiag(NoteInMainLSP), IsEmpty())));
   EXPECT_EQ(LSPDiags[0].first.code, "undeclared_var_use");
   EXPECT_EQ(LSPDiags[0].first.source, "clang");
   EXPECT_EQ(LSPDiags[1].first.code, "");
   EXPECT_EQ(LSPDiags[1].first.source, "");
 
   // Same thing, but don't flatten notes into the main list.
   LSPDiags.clear();
   Opts.EmitRelatedLocations = true;
main.cpp:2:3: error: something terrible happened)";
   NoteInMainDRI.location.range = NoteInMain.Range;
   NoteInMainDRI.location.uri = MainFile;
   MainLSP.relatedInformation = {NoteInMainDRI};
   DiagnosticRelatedInformation NoteInHeaderDRI;
   NoteInHeaderDRI.message = "Declared somewhere in the header file";
   NoteInHeaderDRI.location.range = NoteInHeader.Range;
   NoteInHeaderDRI.location.uri = HeaderFile;
   MainLSP.relatedInformation = {NoteInMainDRI, NoteInHeaderDRI};
-  EXPECT_THAT(LSPDiags, ElementsAre(Pair(EqualToLSPDiag(MainLSP),
-                                         ElementsAre(EqualToFix(F)))));
+  EXPECT_THAT(LSPDiags, ElementsAre(Pair(equalToLSPDiag(MainLSP),
+                                         ElementsAre(equalToFix(F)))));
 }
 
 struct SymbolWithHeader {
   std::string QName;
   std::string DeclaringFile;
   std::string IncludeHeader;
 };
 
std::vector<std::pair<llvm::StringRef, llvm::StringRef>> Tests{
       {"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(),
-        ElementsAre(AllOf(DiagName(Case.first), HasRange(Main.range()),
-                          WithFix(Fix(Range{}, "#include \"x.h\"\n",
+        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) {
   Symbol Sym = enm("X");
   Sym.Flags |= Symbol::IndexedForCodeCompletion;
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(),
-                Contains(AllOf(DiagName(Case.first), HasRange(Main.range()),
-                               WithFix(Fix(Range{}, "#include \"x.h\"\n",
+                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) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace ns {
auto Index = buildIndexWithSymbol(
        SymbolWithHeader{"Global", "unittest:///global.h", "\"global.h\""},
        SymbolWithHeader{"ns::Foo", "unittest:///foo.h", "\"foo.h\""}});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       *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",
+                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'"),
-                DiagName("typename_nested_not_found"),
-                WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                diagName("typename_nested_not_found"),
+                withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Include \"x.h\" for symbol ns::X"))),
           AllOf(Diag(Test.range("qualified2"),
                      "no member named 'X' in namespace 'ns'"),
-                DiagName("no_member"),
-                WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                diagName("no_member"),
+                withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Include \"x.h\" for symbol ns::X"))),
           AllOf(Diag(Test.range("global"),
                      "no type named 'Global' in the global namespace"),
-                DiagName("typename_nested_not_found"),
-                WithFix(Fix(Test.range("insert"), "#include \"global.h\"\n",
+                diagName("typename_nested_not_found"),
+                withFix(Fix(Test.range("insert"), "#include \"global.h\"\n",
                             "Include \"global.h\" for symbol Global"))),
           AllOf(Diag(Test.range("template"),
                      "no template named 'Foo' in namespace 'ns'"),
-                DiagName("no_member_template"),
-                WithFix(Fix(Test.range("insert"), "#include \"foo.h\"\n",
+                diagName("no_member_template"),
+                withFix(Fix(Test.range("insert"), "#include \"foo.h\"\n",
                             "Include \"foo.h\" for symbol ns::Foo")))));
 }
 
 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(),
               UnorderedElementsAre(AllOf(
                   Diag(Test.range("unqualified"), "unknown type name 'X'"),
-                  DiagName("unknown_typename"),
-                  WithFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
+                  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() {  ns::$[[scope]]::X_Y();  }
   auto Index = buildIndexWithSymbol(
       SymbolWithHeader{"ns::scope::X_Y", "unittest:///x.h", "\"x.h\""});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       *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",
+                diagName("no_member"),
+                withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Include \"x.h\" for symbol ns::scope::X_Y")))));
 }
 
 TEST(IncludeFixerTest, UnresolvedSpecifierWithSemaCorrection) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace clang {
 void f() {
   // "clangd::" will be corrected to "clang::" by Sema.
auto Index = buildIndexWithSymbol(
        SymbolWithHeader{"clang::clangd::ns::Y", "unittest:///y.h", "\"y.h\""}});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       *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
+                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'"),
-                DiagName("typename_nested_not_found"),
-                WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                diagName("typename_nested_not_found"),
+                withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Include \"x.h\" for symbol clang::clangd::X"))),
           AllOf(
               Diag(Test.range("q2"), "use of undeclared identifier 'clangd'; "
                                      "did you mean 'clang'?"),
-              DiagName("undeclared_var_use_suggest"),
-              WithFix(_, // change clangd to clang
+              diagName("undeclared_var_use_suggest"),
+              withFix(_, // change clangd to clang
                       Fix(Test.range("insert"), "#include \"y.h\"\n",
                           "Include \"y.h\" for symbol clang::clangd::ns::Y"))),
           AllOf(Diag(Test.range("ns"),
                      "no member named 'ns' in namespace 'clang'"),
-                DiagName("no_member"),
-                WithFix(
+                diagName("no_member"),
+                withFix(
                     Fix(Test.range("insert"), "#include \"y.h\"\n",
                         "Include \"y.h\" for symbol clang::clangd::ns::Y")))));
 }
 
 TEST(IncludeFixerTest, SpecifiedScopeIsNamespaceAlias) {
   Annotations Test(R"cpp(// error-ok
 $insert[[]]namespace a {}
 namespace b = a;
 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(),
               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",
+                  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(
     template <typename T> struct Templ {
       template <typename U>
       typename U::type operator=(const U &);
TEST(IncludeFixerTest, HeaderNamedInDiag) {
   auto Index = buildIndexWithSymbol({});
   TU.ExternalIndex = Index.get();
 
   EXPECT_THAT(
       *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",
+          withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
                       "Include <stdio.h> for symbol printf")))));
 }
 
 TEST(IncludeFixerTest, CImplicitFunctionDecl) {
   Annotations Test("void x() { [[foo]](); }");
   auto TU = TestTU::withCode(Test.code());
   TU.Filename = "test.c";
 
   Symbol Sym = func("foo");
   Sym.Flags |= Symbol::IndexedForCodeCompletion;
   Sym.CanonicalDeclaration.FileURI = "unittest:///foo.h";
   Sym.IncludeHeaders.emplace_back("\"foo.h\"", 1);
 
   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(),
       ElementsAre(AllOf(
           Diag(Test.range(),
                "implicit declaration of function 'foo' is invalid in C99"),
-          WithFix(Fix(Range{}, "#include \"foo.h\"\n",
+          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(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(), "in included file: C++ requires a "
                                      "type specifier for all declarations"),
-                  WithNote(Diag(Header.range(), "error occurred here")))));
+                  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\""},
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(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(), "in included file: C++ requires "
                                      "a type specifier for all declarations"),
-                  WithNote(Diag(Header.range(), "error occurred here")))));
+                  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() {} }
Annotations Header(R"cpp(
     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(),
               UnorderedElementsAre(AllOf(
                   Diag(Main.range(),
                        "in included file: use of undeclared identifier 'NOOO'"),
-                  WithNote(Diag(Header.range(), "error occurred here")))));
+                  withNote(Diag(Header.range(), "error occurred here")))));
 }
 
 TEST(DiagsInHeaders, ErrorFromMacroExpansion) {
   Annotations Main(R"cpp(
   void bar() {
     int fo; // error-ok
     #include [["a.h"]]
   })cpp");
TEST(Diagnostics, Tags) {
   void foo() {
     int $unused[[x]];
     $deprecated[[bar]]();
   })cpp");
   TU.Code = Test.code().str();
   EXPECT_THAT(*TU.build().getDiagnostics(),
               UnorderedElementsAre(
                   AllOf(Diag(Test.range("unused"), "unused variable 'x'"),
-                        WithTag(DiagnosticTag::Unnecessary)),
+                        withTag(DiagnosticTag::Unnecessary)),
                   AllOf(Diag(Test.range("deprecated"), "'bar' is deprecated"),
-                        WithTag(DiagnosticTag::Deprecated))));
+                        withTag(DiagnosticTag::Deprecated))));
 }
 
 TEST(DiagnosticsTest, IncludeCleaner) {
   Annotations Test(R"cpp(
 $fix[[  $diag[[#include "unused.h"]]
 ]]
   #include "used.h"
 
]]
   EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
   Config Cfg;
   Cfg.Diagnostics.UnusedIncludes = Config::UnusedIncludesPolicy::Strict;
   WithContextValue WithCfg(Config::Key, std::move(Cfg));
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
       UnorderedElementsAre(AllOf(
           Diag(Test.range("diag"), "included header unused.h is not used"),
-          WithTag(DiagnosticTag::Unnecessary), DiagSource(Diag::Clangd),
-          WithFix(Fix(Test.range("fix"), "", "remove #include directive")))));
+          withTag(DiagnosticTag::Unnecessary), diagSource(Diag::Clangd),
+          withFix(Fix(Test.range("fix"), "", "remove #include directive")))));
   Cfg.Diagnostics.SuppressAll = true;
   WithContextValue SuppressAllWithCfg(Config::Key, std::move(Cfg));
   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());
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 
 namespace clang {
 namespace clangd {
 namespace {
 using testing::Contains;
 using testing::Not;
 using testing::SizeIs;
 
-MATCHER_P(WithDetail, str, "") { return arg.detail == str; }
+MATCHER_P(withDetail, str, "") { return arg.detail == str; }
 
 TEST(DumpASTTests, BasicInfo) {
   std::pair</*Code=*/std::string, /*Expected=*/std::string> Cases[] = {
       {R"cpp(
 float root(int *x) {
   return *x + 1;
 }
       )cpp",

 
 TEST(DumpASTTests, NoRange) {
   auto TU = TestTU::withHeaderCode("void funcFromHeader();");
   TU.Code = "int varFromSource;";
   ParsedAST AST = TU.build();
   auto Node = dumpAST(
       DynTypedNode::create(*AST.getASTContext().getTranslationUnitDecl()),
       AST.getTokens(), AST.getASTContext());
-  ASSERT_THAT(Node.children, Contains(WithDetail("varFromSource")));
-  ASSERT_THAT(Node.children, Not(Contains(WithDetail("funcFromHeader"))));
+  ASSERT_THAT(Node.children, Contains(withDetail("varFromSource")));
+  ASSERT_THAT(Node.children, Not(Contains(withDetail("funcFromHeader"))));
   EXPECT_THAT(Node.arcana, testing::StartsWith("TranslationUnitDecl "));
   ASSERT_FALSE(Node.range.hasValue())
       << "Expected no range for translation unit";
 }
 
 TEST(DumpASTTests, Arcana) {
   ParsedAST AST = TestTU::withCode("int x;").build();
   auto Node = dumpAST(DynTypedNode::create(findDecl(AST, "x")), AST.getTokens(),

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

protected:
 
   QualType typeOf(llvm::StringRef Name) {
     return cast<ValueDecl>(decl(Name))->getType().getCanonicalType();
   }
 
   /// An overload for convenience.
   llvm::Optional<OpaqueType> fromCompletionResult(const NamedDecl *D) {
     return OpaqueType::fromCompletionResult(
-        ASTCtx(), CodeCompletionResult(D, CCP_Declaration));
+        astCtx(), CodeCompletionResult(D, CCP_Declaration));
   }
 
   /// A set of DeclNames whose type match each other computed by
   /// OpaqueType::fromCompletionResult.
   using EquivClass = std::set<std::string>;
 
   Matcher<std::map<std::string, EquivClass>>
-  ClassesAre(llvm::ArrayRef<EquivClass> Classes) {
+  classesAre(llvm::ArrayRef<EquivClass> Classes) {
     using MapEntry = std::map<std::string, EquivClass>::value_type;
 
     std::vector<Matcher<MapEntry>> Elements;
     Elements.reserve(Classes.size());
     for (auto &Cls : Classes)
       Elements.push_back(Field(&MapEntry::second, Cls));
     return UnorderedElementsAreArray(Elements);
   }
 
   // Groups \p Decls into equivalence classes based on the result of
   // 'OpaqueType::fromCompletionResult'.
   std::map<std::string, EquivClass>
   buildEquivClasses(llvm::ArrayRef<llvm::StringRef> DeclNames) {
     std::map<std::string, EquivClass> Classes;
     for (llvm::StringRef Name : DeclNames) {
-      auto Type = OpaqueType::fromType(ASTCtx(), typeOf(Name));
+      auto Type = OpaqueType::fromType(astCtx(), typeOf(Name));
       Classes[std::string(Type->raw())].insert(std::string(Name));
     }
     return Classes;
   }
 
-  ASTContext &ASTCtx() { return AST->getASTContext(); }
+  ASTContext &astCtx() { return AST->getASTContext(); }
 
 private:
   // Set after calling build().
   llvm::Optional<ParsedAST> AST;
 };
 
 TEST_F(ExpectedTypeConversionTest, BasicTypes) {
   build(R"cpp(
build(R"cpp(
 
     // user-defined types.
     struct X {};
     X user_type;
   )cpp");
 
   EXPECT_THAT(buildEquivClasses({"b", "i", "ui", "ll", "f", "d", "iptr", "bptr",
                                  "user_type"}),
-              ClassesAre({{"b"},
+              classesAre({{"b"},
                           {"i", "ui", "ll"},
                           {"f", "d"},
                           {"iptr"},
                           {"bptr"},
                           {"user_type"}}));
 }
 
 TEST_F(ExpectedTypeConversionTest, ReferencesDontMatter) {
TEST_F(ExpectedTypeConversionTest, FunctionReturns) {
   build(R"cpp(
      int returns_int();
      int* returns_ptr();
 
      int int_;
      int* int_ptr;
   )cpp");
 
-  OpaqueType IntTy = *OpaqueType::fromType(ASTCtx(), typeOf("int_"));
+  OpaqueType IntTy = *OpaqueType::fromType(astCtx(), typeOf("int_"));
   EXPECT_EQ(fromCompletionResult(decl("returns_int")), IntTy);
 
-  OpaqueType IntPtrTy = *OpaqueType::fromType(ASTCtx(), typeOf("int_ptr"));
+  OpaqueType IntPtrTy = *OpaqueType::fromType(astCtx(), typeOf("int_ptr"));
   EXPECT_EQ(fromCompletionResult(decl("returns_ptr")), IntPtrTy);
 }
 
 TEST_F(ExpectedTypeConversionTest, Templates) {
   build(R"cpp(
 template <class T>
 int* returns_not_dependent();
 template <class T>
 T* returns_dependent();
 
 template <class T>
 int* var_not_dependent = nullptr;
 template <class T>
 T* var_dependent = nullptr;
 
 int* int_ptr_;
   )cpp");
 
-  auto IntPtrTy = *OpaqueType::fromType(ASTCtx(), typeOf("int_ptr_"));
+  auto IntPtrTy = *OpaqueType::fromType(astCtx(), typeOf("int_ptr_"));
   EXPECT_EQ(fromCompletionResult(decl("returns_not_dependent")), IntPtrTy);
   EXPECT_EQ(fromCompletionResult(decl("returns_dependent")), llvm::None);
 
   EXPECT_EQ(fromCompletionResult(decl("var_not_dependent")), IntPtrTy);
   EXPECT_EQ(fromCompletionResult(decl("var_dependent")), llvm::None);
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 using ::testing::AllOf;
 using ::testing::Contains;
 using ::testing::ElementsAre;
 using ::testing::Gt;
 using ::testing::IsEmpty;
 using ::testing::Pair;
 using ::testing::UnorderedElementsAre;
 
-MATCHER_P(RefRange, Range, "") {
+MATCHER_P(refRange, Range, "") {
   return std::make_tuple(arg.Location.Start.line(), arg.Location.Start.column(),
                          arg.Location.End.line(), arg.Location.End.column()) ==
          std::make_tuple(Range.start.line, Range.start.character,
                          Range.end.line, Range.end.character);
 }
-MATCHER_P(FileURI, F, "") { return llvm::StringRef(arg.Location.FileURI) == F; }
-MATCHER_P(DeclURI, U, "") {
+MATCHER_P(fileURI, F, "") { return llvm::StringRef(arg.Location.FileURI) == F; }
+MATCHER_P(declURI, U, "") {
   return llvm::StringRef(arg.CanonicalDeclaration.FileURI) == U;
 }
-MATCHER_P(DefURI, U, "") {
+MATCHER_P(defURI, U, "") {
   return llvm::StringRef(arg.Definition.FileURI) == U;
 }
-MATCHER_P(QName, N, "") { return (arg.Scope + arg.Name).str() == N; }
-MATCHER_P(NumReferences, N, "") { return arg.References == N; }
+MATCHER_P(qName, N, "") { return (arg.Scope + arg.Name).str() == N; }
+MATCHER_P(numReferences, N, "") { return arg.References == N; }
 MATCHER_P(hasOrign, O, "") { return bool(arg.Origin & O); }
 
 namespace clang {
 namespace clangd {
 namespace {
 ::testing::Matcher<const RefSlab &>
-RefsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
+refsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
   return ElementsAre(::testing::Pair(_, UnorderedElementsAreArray(Matchers)));
 }
 
 Symbol symbol(llvm::StringRef ID) {
   Symbol Sym;
   Sym.ID = SymbolID(ID);
   Sym.Name = ID;
   return Sym;
 }
 
 std::unique_ptr<SymbolSlab> numSlab(int Begin, int End) {
   SymbolSlab::Builder Slab;
-  for (int i = Begin; i <= End; i++)
-    Slab.insert(symbol(std::to_string(i)));
+  for (int I = Begin; I <= End; I++)
+    Slab.insert(symbol(std::to_string(I)));
   return std::make_unique<SymbolSlab>(std::move(Slab).build());
 }
 
 std::unique_ptr<RefSlab> refSlab(const SymbolID &ID, const char *Path) {
   RefSlab::Builder Slab;
   Ref R;
   R.Location.FileURI = Path;
   R.Kind = RefKind::Reference;

 
 TEST(FileSymbolsTest, UpdateAndGet) {
   FileSymbols FS(IndexContents::All);
   EXPECT_THAT(runFuzzyFind(*FS.buildIndex(IndexType::Light), ""), IsEmpty());
 
   FS.update("f1", numSlab(1, 3), refSlab(SymbolID("1"), "f1.cc"), nullptr,
             false);
   EXPECT_THAT(runFuzzyFind(*FS.buildIndex(IndexType::Light), ""),
-              UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
+              UnorderedElementsAre(qName("1"), qName("2"), qName("3")));
   EXPECT_THAT(getRefs(*FS.buildIndex(IndexType::Light), SymbolID("1")),
-              RefsAre({FileURI("f1.cc")}));
+              refsAre({fileURI("f1.cc")}));
 }
 
 TEST(FileSymbolsTest, Overlap) {
   FileSymbols FS(IndexContents::All);
   FS.update("f1", numSlab(1, 3), nullptr, nullptr, false);
   FS.update("f2", numSlab(3, 5), nullptr, nullptr, false);
   for (auto Type : {IndexType::Light, IndexType::Heavy})
     EXPECT_THAT(runFuzzyFind(*FS.buildIndex(Type), ""),
-                UnorderedElementsAre(QName("1"), QName("2"), QName("3"),
-                                     QName("4"), QName("5")));
+                UnorderedElementsAre(qName("1"), qName("2"), qName("3"),
+                                     qName("4"), qName("5")));
 }
 
 TEST(FileSymbolsTest, MergeOverlap) {
   FileSymbols FS(IndexContents::All);
   auto OneSymboSlab = [](Symbol Sym) {
     SymbolSlab::Builder S;
     S.insert(Sym);
     return std::make_unique<SymbolSlab>(std::move(S).build());
   };
   auto X1 = symbol("x");
   X1.CanonicalDeclaration.FileURI = "file:///x1";
   auto X2 = symbol("x");
   X2.Definition.FileURI = "file:///x2";
 
   FS.update("f1", OneSymboSlab(X1), nullptr, nullptr, false);
   FS.update("f2", OneSymboSlab(X2), nullptr, nullptr, false);
   for (auto Type : {IndexType::Light, IndexType::Heavy})
     EXPECT_THAT(
         runFuzzyFind(*FS.buildIndex(Type, DuplicateHandling::Merge), "x"),
         UnorderedElementsAre(
-            AllOf(QName("x"), DeclURI("file:///x1"), DefURI("file:///x2"))));
+            AllOf(qName("x"), declURI("file:///x1"), defURI("file:///x2"))));
 }
 
 TEST(FileSymbolsTest, SnapshotAliveAfterRemove) {
   FileSymbols FS(IndexContents::All);
 
   SymbolID ID("1");
   FS.update("f1", numSlab(1, 3), refSlab(ID, "f1.cc"), nullptr, false);
 
   auto Symbols = FS.buildIndex(IndexType::Light);
   EXPECT_THAT(runFuzzyFind(*Symbols, ""),
-              UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
-  EXPECT_THAT(getRefs(*Symbols, ID), RefsAre({FileURI("f1.cc")}));
+              UnorderedElementsAre(qName("1"), qName("2"), qName("3")));
+  EXPECT_THAT(getRefs(*Symbols, ID), refsAre({fileURI("f1.cc")}));
 
   FS.update("f1", nullptr, nullptr, nullptr, false);
   auto Empty = FS.buildIndex(IndexType::Light);
   EXPECT_THAT(runFuzzyFind(*Empty, ""), IsEmpty());
   EXPECT_THAT(getRefs(*Empty, ID), ElementsAre());
 
   EXPECT_THAT(runFuzzyFind(*Symbols, ""),
-              UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
-  EXPECT_THAT(getRefs(*Symbols, ID), RefsAre({FileURI("f1.cc")}));
+              UnorderedElementsAre(qName("1"), qName("2"), qName("3")));
+  EXPECT_THAT(getRefs(*Symbols, ID), refsAre({fileURI("f1.cc")}));
 }
 
 // Adds Basename.cpp, which includes Basename.h, which contains Code.
 void update(FileIndex &M, llvm::StringRef Basename, llvm::StringRef Code) {
   TestTU File;
   File.Filename = (Basename + ".cpp").str();
   File.HeaderFilename = (Basename + ".h").str();
   File.HeaderCode = std::string(Code);
   auto AST = File.build();
   M.updatePreamble(testPath(File.Filename), /*Version=*/"null",
                    AST.getASTContext(), AST.getPreprocessor(),
                    AST.getCanonicalIncludes());
 }
 
 TEST(FileIndexTest, CustomizedURIScheme) {
   FileIndex M;
   update(M, "f", "class string {};");
 
-  EXPECT_THAT(runFuzzyFind(M, ""), ElementsAre(DeclURI("unittest:///f.h")));
+  EXPECT_THAT(runFuzzyFind(M, ""), ElementsAre(declURI("unittest:///f.h")));
 }
 
 TEST(FileIndexTest, IndexAST) {
   FileIndex M;
   update(M, "f1", "namespace ns { void f() {} class X {}; }");
 
   FuzzyFindRequest Req;
   Req.Query = "";
   Req.Scopes = {"ns::"};
   EXPECT_THAT(runFuzzyFind(M, Req),
-              UnorderedElementsAre(QName("ns::f"), QName("ns::X")));
+              UnorderedElementsAre(qName("ns::f"), qName("ns::X")));
 }
 
 TEST(FileIndexTest, NoLocal) {
   FileIndex M;
   update(M, "f1", "namespace ns { void f() { int local = 0; } class X {}; }");
 
   EXPECT_THAT(
       runFuzzyFind(M, ""),
-      UnorderedElementsAre(QName("ns"), QName("ns::f"), QName("ns::X")));
+      UnorderedElementsAre(qName("ns"), qName("ns::f"), qName("ns::X")));
 }
 
 TEST(FileIndexTest, IndexMultiASTAndDeduplicate) {
   FileIndex M;
   update(M, "f1", "namespace ns { void f() {} class X {}; }");
   update(M, "f2", "namespace ns { void ff() {} class X {}; }");
 
   FuzzyFindRequest Req;
   Req.Scopes = {"ns::"};
   EXPECT_THAT(
       runFuzzyFind(M, Req),
-      UnorderedElementsAre(QName("ns::f"), QName("ns::X"), QName("ns::ff")));
+      UnorderedElementsAre(qName("ns::f"), qName("ns::X"), qName("ns::ff")));
 }
 
 TEST(FileIndexTest, ClassMembers) {
   FileIndex M;
   update(M, "f1", "class X { static int m1; int m2; static void f(); };");
 
   EXPECT_THAT(runFuzzyFind(M, ""),
-              UnorderedElementsAre(QName("X"), QName("X::m1"), QName("X::m2"),
-                                   QName("X::f")));
+              UnorderedElementsAre(qName("X"), qName("X::m1"), qName("X::m2"),
+                                   qName("X::f")));
 }
 
 TEST(FileIndexTest, IncludeCollected) {
   FileIndex M;
   update(
       M, "f",
       "// IWYU pragma: private, include <the/good/header.h>\nclass string {};");
 

 vector<Ty> make_vector(Arg A) {}
 )cpp";
 
   FileIndex M;
   update(M, "f", Source);
 
   auto Symbols = runFuzzyFind(M, "");
   EXPECT_THAT(Symbols,
-              UnorderedElementsAre(QName("vector"), QName("make_vector")));
+              UnorderedElementsAre(qName("vector"), qName("make_vector")));
   auto It = Symbols.begin();
   Symbol Vector = *It++;
   Symbol MakeVector = *It++;
   if (MakeVector.Name == "vector")
     std::swap(MakeVector, Vector);
 
   EXPECT_EQ(Vector.Signature, "<class Ty>");
   EXPECT_EQ(Vector.CompletionSnippetSuffix, "<${1:class Ty}>");
TEST(FileIndexTest, RebuildWithPreamble) {
 
   // Check the index contains symbols from the preamble, but not from the main
   // file.
   FuzzyFindRequest Req;
   Req.Query = "";
   Req.Scopes = {"", "ns_in_header::"};
 
   EXPECT_THAT(runFuzzyFind(Index, Req),
-              UnorderedElementsAre(QName("ns_in_header"),
-                                   QName("ns_in_header::func_in_header")));
+              UnorderedElementsAre(qName("ns_in_header"),
+                                   qName("ns_in_header::func_in_header")));
 }
 
 TEST(FileIndexTest, Refs) {
   const char *HeaderCode = "class Foo {};";
   Annotations MainCode(R"cpp(
   void f() {
     $foo[[Foo]] foo;
   }
TEST(FileIndexTest, Refs) {
   TestTU Test2;
   Test2.HeaderCode = HeaderCode;
   Test2.Code = std::string(MainCode.code());
   Test2.Filename = "test2.cc";
   AST = Test2.build();
   Index.updateMain(testPath(Test2.Filename), AST);
 
   EXPECT_THAT(getRefs(Index, Foo.ID),
-              RefsAre({AllOf(RefRange(MainCode.range("foo")),
-                             FileURI("unittest:///test.cc")),
-                       AllOf(RefRange(MainCode.range("foo")),
-                             FileURI("unittest:///test2.cc"))}));
+              refsAre({AllOf(refRange(MainCode.range("foo")),
+                             fileURI("unittest:///test.cc")),
+                       AllOf(refRange(MainCode.range("foo")),
+                             fileURI("unittest:///test2.cc"))}));
 }
 
 TEST(FileIndexTest, MacroRefs) {
   Annotations HeaderCode(R"cpp(
     #define $def1[[HEADER_MACRO]](X) (X+1)
   )cpp");
   Annotations MainCode(R"cpp(
   #define $def2[[MAINFILE_MACRO]](X) (X+1)
TEST(FileIndexTest, MacroRefs) {
   Test.HeaderCode = std::string(HeaderCode.code());
   Test.Code = std::string(MainCode.code());
   Test.Filename = "test.cc";
   auto AST = Test.build();
   Index.updateMain(testPath(Test.Filename), AST);
 
   auto HeaderMacro = findSymbol(Test.headerSymbols(), "HEADER_MACRO");
   EXPECT_THAT(getRefs(Index, HeaderMacro.ID),
-              RefsAre({AllOf(RefRange(MainCode.range("ref1")),
-                             FileURI("unittest:///test.cc"))}));
+              refsAre({AllOf(refRange(MainCode.range("ref1")),
+                             fileURI("unittest:///test.cc"))}));
 
   auto MainFileMacro = findSymbol(Test.headerSymbols(), "MAINFILE_MACRO");
   EXPECT_THAT(getRefs(Index, MainFileMacro.ID),
-              RefsAre({AllOf(RefRange(MainCode.range("def2")),
-                             FileURI("unittest:///test.cc")),
-                       AllOf(RefRange(MainCode.range("ref2")),
-                             FileURI("unittest:///test.cc"))}));
+              refsAre({AllOf(refRange(MainCode.range("def2")),
+                             fileURI("unittest:///test.cc")),
+                       AllOf(refRange(MainCode.range("ref2")),
+                             fileURI("unittest:///test.cc"))}));
 }
 
 TEST(FileIndexTest, CollectMacros) {
   FileIndex M;
   update(M, "f", "#define CLANGD 1");
-  EXPECT_THAT(runFuzzyFind(M, ""), Contains(QName("CLANGD")));
+  EXPECT_THAT(runFuzzyFind(M, ""), Contains(qName("CLANGD")));
 }
 
 TEST(FileIndexTest, Relations) {
   TestTU TU;
   TU.Filename = "f.cpp";
   TU.HeaderFilename = "f.h";
   TU.HeaderCode = "class A {}; class B : public A {};";
   auto AST = TU.build();
TEST(FileIndexTest, ReferencesInMainFileWithPreamble) {
   TU.Code = std::string(Main.code());
   auto AST = TU.build();
   FileIndex Index;
   Index.updateMain(testPath(TU.Filename), AST);
 
   // Expect to see references in main file, references in headers are excluded
   // because we only index main AST.
   EXPECT_THAT(getRefs(Index, findSymbol(TU.headerSymbols(), "Foo").ID),
-              RefsAre({RefRange(Main.range())}));
+              refsAre({refRange(Main.range())}));
 }
 
 TEST(FileIndexTest, MergeMainFileSymbols) {
   const char *CommonHeader = "void foo();";
   TestTU Header = TestTU::withCode(CommonHeader);
   TestTU Cpp = TestTU::withCode("void foo() {}");
   Cpp.Filename = "foo.cpp";
   Cpp.HeaderFilename = "foo.h";
   Cpp.HeaderCode = CommonHeader;
 
   FileIndex Index;
   auto HeaderAST = Header.build();
   auto CppAST = Cpp.build();
   Index.updateMain(testPath("foo.h"), HeaderAST);
   Index.updateMain(testPath("foo.cpp"), CppAST);
 
   auto Symbols = runFuzzyFind(Index, "");
   // Check foo is merged, foo in Cpp wins (as we see the definition there).
-  EXPECT_THAT(Symbols, ElementsAre(AllOf(DeclURI("unittest:///foo.h"),
-                                         DefURI("unittest:///foo.cpp"),
+  EXPECT_THAT(Symbols, ElementsAre(AllOf(declURI("unittest:///foo.h"),
+                                         defURI("unittest:///foo.cpp"),
                                          hasOrign(SymbolOrigin::Merge))));
 }
 
 TEST(FileSymbolsTest, CountReferencesNoRefSlabs) {
   FileSymbols FS(IndexContents::All);
   FS.update("f1", numSlab(1, 3), nullptr, nullptr, true);
   FS.update("f2", numSlab(1, 3), nullptr, nullptr, false);
   EXPECT_THAT(
       runFuzzyFind(*FS.buildIndex(IndexType::Light, DuplicateHandling::Merge),
                    ""),
-      UnorderedElementsAre(AllOf(QName("1"), NumReferences(0u)),
-                           AllOf(QName("2"), NumReferences(0u)),
-                           AllOf(QName("3"), NumReferences(0u))));
+      UnorderedElementsAre(AllOf(qName("1"), numReferences(0u)),
+                           AllOf(qName("2"), numReferences(0u)),
+                           AllOf(qName("3"), numReferences(0u))));
 }
 
 TEST(FileSymbolsTest, CountReferencesWithRefSlabs) {
   FileSymbols FS(IndexContents::All);
   FS.update("f1cpp", numSlab(1, 3), refSlab(SymbolID("1"), "f1.cpp"), nullptr,
             true);
   FS.update("f1h", numSlab(1, 3), refSlab(SymbolID("1"), "f1.h"), nullptr,
             false);
   FS.update("f2cpp", numSlab(1, 3), refSlab(SymbolID("2"), "f2.cpp"), nullptr,
             true);
   FS.update("f2h", numSlab(1, 3), refSlab(SymbolID("2"), "f2.h"), nullptr,
             false);
   FS.update("f3cpp", numSlab(1, 3), refSlab(SymbolID("3"), "f3.cpp"), nullptr,
             true);
   FS.update("f3h", numSlab(1, 3), refSlab(SymbolID("3"), "f3.h"), nullptr,
             false);
   EXPECT_THAT(
       runFuzzyFind(*FS.buildIndex(IndexType::Light, DuplicateHandling::Merge),
                    ""),
-      UnorderedElementsAre(AllOf(QName("1"), NumReferences(1u)),
-                           AllOf(QName("2"), NumReferences(1u)),
-                           AllOf(QName("3"), NumReferences(1u))));
+      UnorderedElementsAre(AllOf(qName("1"), numReferences(1u)),
+                           AllOf(qName("2"), numReferences(1u)),
+                           AllOf(qName("3"), numReferences(1u))));
 }
 
 TEST(FileIndexTest, StalePreambleSymbolsDeleted) {
   FileIndex M;
   TestTU File;
   File.HeaderFilename = "a.h";
 
   File.Filename = "f1.cpp";
   File.HeaderCode = "int a;";
   auto AST = File.build();
   M.updatePreamble(testPath(File.Filename), /*Version=*/"null",
                    AST.getASTContext(), AST.getPreprocessor(),
                    AST.getCanonicalIncludes());
-  EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(QName("a")));
+  EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(qName("a")));
 
   File.Filename = "f2.cpp";
   File.HeaderCode = "int b;";
   AST = File.build();
   M.updatePreamble(testPath(File.Filename), /*Version=*/"null",
                    AST.getASTContext(), AST.getPreprocessor(),
                    AST.getCanonicalIncludes());
-  EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(QName("b")));
+  EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(qName("b")));
 }
 
 // Verifies that concurrent calls to updateMain don't "lose" any updates.
 TEST(FileIndexTest, Threadsafety) {
   FileIndex M;
   Notification Go;
 
   constexpr int Count = 10;
TEST(FileShardedIndexTest, Sharding) {
 
   FileShardedIndex ShardedIndex(std::move(IF));
   ASSERT_THAT(ShardedIndex.getAllSources(),
               UnorderedElementsAre(AHeaderUri, BHeaderUri, BSourceUri));
 
   {
     auto Shard = ShardedIndex.getShard(AHeaderUri);
     ASSERT_TRUE(Shard);
-    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(QName("1")));
+    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(qName("1")));
     EXPECT_THAT(*Shard->Refs, IsEmpty());
     EXPECT_THAT(
         *Shard->Relations,
         UnorderedElementsAre(Relation{Sym1.ID, RelationKind::BaseOf, Sym2.ID},
                              Relation{Sym2.ID, RelationKind::BaseOf, Sym1.ID},
                              Relation{Sym3.ID, RelationKind::BaseOf, Sym1.ID}));
     ASSERT_THAT(Shard->Sources->keys(), UnorderedElementsAre(AHeaderUri));
     EXPECT_THAT(Shard->Sources->lookup(AHeaderUri).DirectIncludes, IsEmpty());
     EXPECT_TRUE(Shard->Cmd.hasValue());
   }
   {
     auto Shard = ShardedIndex.getShard(BHeaderUri);
     ASSERT_TRUE(Shard);
-    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(QName("2")));
+    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(qName("2")));
     EXPECT_THAT(*Shard->Refs, IsEmpty());
     EXPECT_THAT(
         *Shard->Relations,
         UnorderedElementsAre(Relation{Sym1.ID, RelationKind::BaseOf, Sym2.ID},
                              Relation{Sym2.ID, RelationKind::BaseOf, Sym1.ID}));
     ASSERT_THAT(Shard->Sources->keys(),
                 UnorderedElementsAre(BHeaderUri, AHeaderUri));
     EXPECT_THAT(Shard->Sources->lookup(BHeaderUri).DirectIncludes,
                 UnorderedElementsAre(AHeaderUri));
     EXPECT_TRUE(Shard->Cmd.hasValue());
   }
   {
     auto Shard = ShardedIndex.getShard(BSourceUri);
     ASSERT_TRUE(Shard);
-    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(QName("2")));
+    EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(qName("2")));
     EXPECT_THAT(*Shard->Refs, UnorderedElementsAre(Pair(Sym1.ID, _)));
     EXPECT_THAT(*Shard->Relations, IsEmpty());
     ASSERT_THAT(Shard->Sources->keys(),
                 UnorderedElementsAre(BSourceUri, BHeaderUri));
     EXPECT_THAT(Shard->Sources->lookup(BSourceUri).DirectIncludes,
                 UnorderedElementsAre(BHeaderUri));
     EXPECT_TRUE(Shard->Cmd.hasValue());
   }

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

 using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::ElementsAreArray;
 using ::testing::Field;
 using ::testing::IsEmpty;
 using ::testing::UnorderedElementsAre;
 
 // GMock helpers for matching SymbolInfos items.
-MATCHER_P(QName, Name, "") {
+MATCHER_P(qName, Name, "") {
   if (arg.containerName.empty())
     return arg.name == Name;
   return (arg.containerName + "::" + arg.name) == Name;
 }
-MATCHER_P(WithName, N, "") { return arg.name == N; }
-MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
-MATCHER_P(WithDetail, Detail, "") { return arg.detail == Detail; }
-MATCHER_P(SymRange, Range, "") { return arg.range == Range; }
+MATCHER_P(withName, N, "") { return arg.name == N; }
+MATCHER_P(withKind, Kind, "") { return arg.kind == Kind; }
+MATCHER_P(withDetail, Detail, "") { return arg.detail == Detail; }
+MATCHER_P(symRange, Range, "") { return arg.range == Range; }
 
 // GMock helpers for matching DocumentSymbol.
-MATCHER_P(SymNameRange, Range, "") { return arg.selectionRange == Range; }
+MATCHER_P(symNameRange, Range, "") { return arg.selectionRange == Range; }
 template <class... ChildMatchers>
-::testing::Matcher<DocumentSymbol> Children(ChildMatchers... ChildrenM) {
+::testing::Matcher<DocumentSymbol> children(ChildMatchers... ChildrenM) {
   return Field(&DocumentSymbol::children, UnorderedElementsAre(ChildrenM...));
 }
 
 std::vector<SymbolInformation> getSymbols(TestTU &TU, llvm::StringRef Query,
                                           int Limit = 0) {
   auto SymbolInfos = getWorkspaceSymbols(Query, Limit, TU.index().get(),
                                          testPath(TU.Filename));
   EXPECT_TRUE(bool(SymbolInfos)) << "workspaceSymbols returned an error";
   return *SymbolInfos;
 }
 
 TEST(WorkspaceSymbols, Macros) {
   TestTU TU;
   TU.Code = R"cpp(
        #define MACRO X
        )cpp";
 
   // LSP's SymbolKind doesn't have a "Macro" kind, and
   // indexSymbolKindToSymbolKind() currently maps macros
   // to SymbolKind::String.
   EXPECT_THAT(getSymbols(TU, "macro"),
-              ElementsAre(AllOf(QName("MACRO"), WithKind(SymbolKind::String))));
+              ElementsAre(AllOf(qName("MACRO"), withKind(SymbolKind::String))));
 }
 
 TEST(WorkspaceSymbols, NoLocals) {
   TestTU TU;
   TU.Code = R"cpp(
       void test(int FirstParam, int SecondParam) {
         struct LocalClass {};
         int local_var;
       })cpp";
-  EXPECT_THAT(getSymbols(TU, "l"), ElementsAre(QName("LocalClass")));
+  EXPECT_THAT(getSymbols(TU, "l"), ElementsAre(qName("LocalClass")));
   EXPECT_THAT(getSymbols(TU, "p"), IsEmpty());
 }
 
 TEST(WorkspaceSymbols, Globals) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
       int global_var;
 
       int global_func();
 
       struct GlobalStruct {};)cpp";
   TU.Code = R"cpp(
       #include "foo.h"
       )cpp";
   EXPECT_THAT(getSymbols(TU, "global"),
               UnorderedElementsAre(
-                  AllOf(QName("GlobalStruct"), WithKind(SymbolKind::Struct)),
-                  AllOf(QName("global_func"), WithKind(SymbolKind::Function)),
-                  AllOf(QName("global_var"), WithKind(SymbolKind::Variable))));
+                  AllOf(qName("GlobalStruct"), withKind(SymbolKind::Struct)),
+                  AllOf(qName("global_func"), withKind(SymbolKind::Function)),
+                  AllOf(qName("global_var"), withKind(SymbolKind::Variable))));
 }
 
 TEST(WorkspaceSymbols, Unnamed) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
       struct {
         int InUnnamed;
       } UnnamedStruct;)cpp";
   TU.Code = R"cpp(
       #include "foo.h"
       )cpp";
   EXPECT_THAT(getSymbols(TU, "UnnamedStruct"),
-              ElementsAre(AllOf(QName("UnnamedStruct"),
-                                WithKind(SymbolKind::Variable))));
+              ElementsAre(AllOf(qName("UnnamedStruct"),
+                                withKind(SymbolKind::Variable))));
   EXPECT_THAT(getSymbols(TU, "InUnnamed"),
-              ElementsAre(AllOf(QName("(anonymous struct)::InUnnamed"),
-                                WithKind(SymbolKind::Field))));
+              ElementsAre(AllOf(qName("(anonymous struct)::InUnnamed"),
+                                withKind(SymbolKind::Field))));
 }
 
 TEST(WorkspaceSymbols, InMainFile) {
   TestTU TU;
   TU.Code = R"cpp(
       int test() {}
       static void test2() {}
       )cpp";
   EXPECT_THAT(getSymbols(TU, "test"),
-              ElementsAre(QName("test"), QName("test2")));
+              ElementsAre(qName("test"), qName("test2")));
 }
 
 TEST(WorkspaceSymbols, Namespaces) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
       namespace ans1 {
         int ai1;
         namespace ans2 {
           int ai2;
           namespace ans3 {
             int ai3;
           }
         }
       }
       )cpp";
   TU.Code = R"cpp(
       #include "foo.h"
       )cpp";
   EXPECT_THAT(getSymbols(TU, "a"),
               UnorderedElementsAre(
-                  QName("ans1"), QName("ans1::ai1"), QName("ans1::ans2"),
-                  QName("ans1::ans2::ai2"), QName("ans1::ans2::ans3"),
-                  QName("ans1::ans2::ans3::ai3")));
-  EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(QName("ans1")));
-  EXPECT_THAT(getSymbols(TU, "::a"), ElementsAre(QName("ans1")));
+                  qName("ans1"), qName("ans1::ai1"), qName("ans1::ans2"),
+                  qName("ans1::ans2::ai2"), qName("ans1::ans2::ans3"),
+                  qName("ans1::ans2::ans3::ai3")));
+  EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(qName("ans1")));
+  EXPECT_THAT(getSymbols(TU, "::a"), ElementsAre(qName("ans1")));
   EXPECT_THAT(getSymbols(TU, "ans1::"),
-              UnorderedElementsAre(QName("ans1::ai1"), QName("ans1::ans2"),
-                                   QName("ans1::ans2::ai2"),
-                                   QName("ans1::ans2::ans3"),
-                                   QName("ans1::ans2::ans3::ai3")));
+              UnorderedElementsAre(qName("ans1::ai1"), qName("ans1::ans2"),
+                                   qName("ans1::ans2::ai2"),
+                                   qName("ans1::ans2::ans3"),
+                                   qName("ans1::ans2::ans3::ai3")));
   EXPECT_THAT(getSymbols(TU, "ans2::"),
-              UnorderedElementsAre(QName("ans1::ans2::ai2"),
-                                   QName("ans1::ans2::ans3"),
-                                   QName("ans1::ans2::ans3::ai3")));
-  EXPECT_THAT(getSymbols(TU, "::ans1"), ElementsAre(QName("ans1")));
+              UnorderedElementsAre(qName("ans1::ans2::ai2"),
+                                   qName("ans1::ans2::ans3"),
+                                   qName("ans1::ans2::ans3::ai3")));
+  EXPECT_THAT(getSymbols(TU, "::ans1"), ElementsAre(qName("ans1")));
   EXPECT_THAT(getSymbols(TU, "::ans1::"),
-              UnorderedElementsAre(QName("ans1::ai1"), QName("ans1::ans2")));
-  EXPECT_THAT(getSymbols(TU, "::ans1::ans2"), ElementsAre(QName("ans1::ans2")));
+              UnorderedElementsAre(qName("ans1::ai1"), qName("ans1::ans2")));
+  EXPECT_THAT(getSymbols(TU, "::ans1::ans2"), ElementsAre(qName("ans1::ans2")));
   EXPECT_THAT(getSymbols(TU, "::ans1::ans2::"),
-              ElementsAre(QName("ans1::ans2::ai2"), QName("ans1::ans2::ans3")));
+              ElementsAre(qName("ans1::ans2::ai2"), qName("ans1::ans2::ans3")));
 
   // Ensure sub-sequence matching works.
   EXPECT_THAT(getSymbols(TU, "ans1::ans3::ai"),
-              UnorderedElementsAre(QName("ans1::ans2::ans3::ai3")));
+              UnorderedElementsAre(qName("ans1::ans2::ans3::ai3")));
 }
 
 TEST(WorkspaceSymbols, AnonymousNamespace) {
   TestTU TU;
   TU.Code = R"cpp(
       namespace {
       void test() {}
       }
       )cpp";
-  EXPECT_THAT(getSymbols(TU, "test"), ElementsAre(QName("test")));
+  EXPECT_THAT(getSymbols(TU, "test"), ElementsAre(qName("test")));
 }
 
 TEST(WorkspaceSymbols, MultiFile) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
       int foo() {
       }
       )cpp";
   TU.AdditionalFiles["foo2.h"] = R"cpp(
       int foo2() {
       }
       )cpp";
   TU.Code = R"cpp(
       #include "foo.h"
       #include "foo2.h"
       )cpp";
   EXPECT_THAT(getSymbols(TU, "foo"),
-              UnorderedElementsAre(QName("foo"), QName("foo2")));
+              UnorderedElementsAre(qName("foo"), qName("foo2")));
 }
 
 TEST(WorkspaceSymbols, GlobalNamespaceQueries) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
       int foo() {
       }
       class Foo {
         int a;
       };
       namespace ns {
       int foo2() {
       }
       }
       )cpp";
   TU.Code = R"cpp(
       #include "foo.h"
       )cpp";
   EXPECT_THAT(getSymbols(TU, "::"),
               UnorderedElementsAre(
-                  AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
-                  AllOf(QName("foo"), WithKind(SymbolKind::Function)),
-                  AllOf(QName("ns"), WithKind(SymbolKind::Namespace))));
+                  AllOf(qName("Foo"), withKind(SymbolKind::Class)),
+                  AllOf(qName("foo"), withKind(SymbolKind::Function)),
+                  AllOf(qName("ns"), withKind(SymbolKind::Namespace))));
   EXPECT_THAT(getSymbols(TU, ":"), IsEmpty());
   EXPECT_THAT(getSymbols(TU, ""),
-              UnorderedElementsAre(QName("foo"), QName("Foo"), QName("Foo::a"),
-                                   QName("ns"), QName("ns::foo2")));
+              UnorderedElementsAre(qName("foo"), qName("Foo"), qName("Foo::a"),
+                                   qName("ns"), qName("ns::foo2")));
 }
 
 TEST(WorkspaceSymbols, Enums) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
     enum {
       Red
     };
namespace ns {
       enum class Color4 {
         White
       };
     }
       )cpp";
   TU.Code = R"cpp(
       #include "foo.h"
       )cpp";
-  EXPECT_THAT(getSymbols(TU, "Red"), ElementsAre(QName("Red")));
-  EXPECT_THAT(getSymbols(TU, "::Red"), ElementsAre(QName("Red")));
-  EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(QName("Green")));
-  EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(QName("Green")));
+  EXPECT_THAT(getSymbols(TU, "Red"), ElementsAre(qName("Red")));
+  EXPECT_THAT(getSymbols(TU, "::Red"), ElementsAre(qName("Red")));
+  EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(qName("Green")));
+  EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(qName("Green")));
   EXPECT_THAT(getSymbols(TU, "Color2::Yellow"),
-              ElementsAre(QName("Color2::Yellow")));
-  EXPECT_THAT(getSymbols(TU, "Yellow"), ElementsAre(QName("Color2::Yellow")));
+              ElementsAre(qName("Color2::Yellow")));
+  EXPECT_THAT(getSymbols(TU, "Yellow"), ElementsAre(qName("Color2::Yellow")));
 
-  EXPECT_THAT(getSymbols(TU, "ns::Black"), ElementsAre(QName("ns::Black")));
-  EXPECT_THAT(getSymbols(TU, "ns::Blue"), ElementsAre(QName("ns::Blue")));
+  EXPECT_THAT(getSymbols(TU, "ns::Black"), ElementsAre(qName("ns::Black")));
+  EXPECT_THAT(getSymbols(TU, "ns::Blue"), ElementsAre(qName("ns::Blue")));
   EXPECT_THAT(getSymbols(TU, "ns::Color4::White"),
-              ElementsAre(QName("ns::Color4::White")));
+              ElementsAre(qName("ns::Color4::White")));
 }
 
 TEST(WorkspaceSymbols, Ranking) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
       namespace ns{}
       void func();
       )cpp";
   TU.Code = R"cpp(
       #include "foo.h"
       )cpp";
-  EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(QName("func"), QName("ns")));
+  EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(qName("func"), qName("ns")));
 }
 
 TEST(WorkspaceSymbols, RankingPartialNamespace) {
   TestTU TU;
   TU.Code = R"cpp(
     namespace ns1 {
       namespace ns2 { struct Foo {}; }
     }
     namespace ns2 { struct FooB {}; })cpp";
   EXPECT_THAT(getSymbols(TU, "ns2::f"),
-              ElementsAre(QName("ns2::FooB"), QName("ns1::ns2::Foo")));
+              ElementsAre(qName("ns2::FooB"), qName("ns1::ns2::Foo")));
 }
 
 TEST(WorkspaceSymbols, WithLimit) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
       int foo;
       int foo2;
       )cpp";
   TU.Code = R"cpp(
       #include "foo.h"
       )cpp";
   // Foo is higher ranked because of exact name match.
   EXPECT_THAT(getSymbols(TU, "foo"),
               UnorderedElementsAre(
-                  AllOf(QName("foo"), WithKind(SymbolKind::Variable)),
-                  AllOf(QName("foo2"), WithKind(SymbolKind::Variable))));
+                  AllOf(qName("foo"), withKind(SymbolKind::Variable)),
+                  AllOf(qName("foo2"), withKind(SymbolKind::Variable))));
 
-  EXPECT_THAT(getSymbols(TU, "foo", 1), ElementsAre(QName("foo")));
+  EXPECT_THAT(getSymbols(TU, "foo", 1), ElementsAre(qName("foo")));
 }
 
 TEST(WorkspaceSymbols, TempSpecs) {
   TestTU TU;
   TU.ExtraArgs = {"-xc++"};
   TU.Code = R"cpp(
       template <typename T, typename U, int X = 5> class Foo {};
       template <typename T> class Foo<int, T> {};
       template <> class Foo<bool, int> {};
       template <> class Foo<bool, int, 3> {};
       )cpp";
   // Foo is higher ranked because of exact name match.
   EXPECT_THAT(
       getSymbols(TU, "Foo"),
       UnorderedElementsAre(
-          AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
-          AllOf(QName("Foo<int, T>"), WithKind(SymbolKind::Class)),
-          AllOf(QName("Foo<bool, int>"), WithKind(SymbolKind::Class)),
-          AllOf(QName("Foo<bool, int, 3>"), WithKind(SymbolKind::Class))));
+          AllOf(qName("Foo"), withKind(SymbolKind::Class)),
+          AllOf(qName("Foo<int, T>"), withKind(SymbolKind::Class)),
+          AllOf(qName("Foo<bool, int>"), withKind(SymbolKind::Class)),
+          AllOf(qName("Foo<bool, int, 3>"), withKind(SymbolKind::Class))));
 }
 
 std::vector<DocumentSymbol> getSymbols(ParsedAST AST) {
   auto SymbolInfos = getDocumentSymbols(AST);
   EXPECT_TRUE(bool(SymbolInfos)) << "documentSymbols returned an error";
   return *SymbolInfos;
 }
 
Annotations Main(R"(
       using bar::v2;
       } // namespace foo
     )");
 
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAreArray(
-          {AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
-                 WithDetail("class"), Children()),
-           AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
-                 WithDetail("class"),
-                 Children(
-                     AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
-                           WithDetail("()"), Children()),
-                     AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
-                           WithDetail("(int)"), Children()),
-                     AllOf(WithName("f"), WithKind(SymbolKind::Method),
-                           WithDetail("void ()"), Children()),
-                     AllOf(WithName("operator="), WithKind(SymbolKind::Method),
-                           WithDetail("Foo &(const Foo &)"), Children()),
-                     AllOf(WithName("~Foo"), WithKind(SymbolKind::Constructor),
-                           WithDetail(""), Children()),
-                     AllOf(WithName("Nested"), WithKind(SymbolKind::Class),
-                           WithDetail("class"),
-                           Children(AllOf(
-                               WithName("f"), WithKind(SymbolKind::Method),
-                               WithDetail("void ()"), Children()))))),
-           AllOf(WithName("Friend"), WithKind(SymbolKind::Class),
-                 WithDetail("class"), Children()),
-           AllOf(WithName("f1"), WithKind(SymbolKind::Function),
-                 WithDetail("void ()"), Children()),
-           AllOf(WithName("f2"), WithKind(SymbolKind::Function),
-                 WithDetail("void ()"), Children()),
-           AllOf(WithName("KInt"), WithKind(SymbolKind::Variable),
-                 WithDetail("const int"), Children()),
-           AllOf(WithName("kStr"), WithKind(SymbolKind::Variable),
-                 WithDetail("const char *"), Children()),
-           AllOf(WithName("f1"), WithKind(SymbolKind::Function),
-                 WithDetail("void ()"), Children()),
+          {AllOf(withName("Foo"), withKind(SymbolKind::Class),
+                 withDetail("class"), children()),
+           AllOf(withName("Foo"), withKind(SymbolKind::Class),
+                 withDetail("class"),
+                 children(
+                     AllOf(withName("Foo"), withKind(SymbolKind::Constructor),
+                           withDetail("()"), children()),
+                     AllOf(withName("Foo"), withKind(SymbolKind::Constructor),
+                           withDetail("(int)"), children()),
+                     AllOf(withName("f"), withKind(SymbolKind::Method),
+                           withDetail("void ()"), children()),
+                     AllOf(withName("operator="), withKind(SymbolKind::Method),
+                           withDetail("Foo &(const Foo &)"), children()),
+                     AllOf(withName("~Foo"), withKind(SymbolKind::Constructor),
+                           withDetail(""), children()),
+                     AllOf(withName("Nested"), withKind(SymbolKind::Class),
+                           withDetail("class"),
+                           children(AllOf(
+                               withName("f"), withKind(SymbolKind::Method),
+                               withDetail("void ()"), children()))))),
+           AllOf(withName("Friend"), withKind(SymbolKind::Class),
+                 withDetail("class"), children()),
+           AllOf(withName("f1"), withKind(SymbolKind::Function),
+                 withDetail("void ()"), children()),
+           AllOf(withName("f2"), withKind(SymbolKind::Function),
+                 withDetail("void ()"), children()),
+           AllOf(withName("KInt"), withKind(SymbolKind::Variable),
+                 withDetail("const int"), children()),
+           AllOf(withName("kStr"), withKind(SymbolKind::Variable),
+                 withDetail("const char *"), children()),
+           AllOf(withName("f1"), withKind(SymbolKind::Function),
+                 withDetail("void ()"), children()),
            AllOf(
-               WithName("foo"), WithKind(SymbolKind::Namespace), WithDetail(""),
-               Children(AllOf(WithName("int32"), WithKind(SymbolKind::Class),
-                              WithDetail("type alias"), Children()),
-                        AllOf(WithName("int32_t"), WithKind(SymbolKind::Class),
-                              WithDetail("type alias"), Children()),
-                        AllOf(WithName("v1"), WithKind(SymbolKind::Variable),
-                              WithDetail("int"), Children()),
-                        AllOf(WithName("bar"), WithKind(SymbolKind::Namespace),
-                              WithDetail(""),
-                              Children(AllOf(WithName("v2"),
-                                             WithKind(SymbolKind::Variable),
-                                             WithDetail("int"), Children()))),
-                        AllOf(WithName("baz"), WithKind(SymbolKind::Namespace),
-                              WithDetail(""), Children()),
-                        AllOf(WithName("v2"), WithKind(SymbolKind::Namespace),
-                              WithDetail(""))))}));
+               withName("foo"), withKind(SymbolKind::Namespace), withDetail(""),
+               children(AllOf(withName("int32"), withKind(SymbolKind::Class),
+                              withDetail("type alias"), children()),
+                        AllOf(withName("int32_t"), withKind(SymbolKind::Class),
+                              withDetail("type alias"), children()),
+                        AllOf(withName("v1"), withKind(SymbolKind::Variable),
+                              withDetail("int"), children()),
+                        AllOf(withName("bar"), withKind(SymbolKind::Namespace),
+                              withDetail(""),
+                              children(AllOf(withName("v2"),
+                                             withKind(SymbolKind::Variable),
+                                             withDetail("int"), children()))),
+                        AllOf(withName("baz"), withKind(SymbolKind::Namespace),
+                              withDetail(""), children()),
+                        AllOf(withName("v2"), withKind(SymbolKind::Namespace),
+                              withDetail(""))))}));
 }
 
 TEST(DocumentSymbols, DeclarationDefinition) {
   TestTU TU;
   Annotations Main(R"(
       class Foo {
         void $decl[[f]]();
       };
       void Foo::$def[[f]]() {
       }
     )");
 
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
-          AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
-                WithDetail("class"),
-                Children(AllOf(WithName("f"), WithKind(SymbolKind::Method),
-                               WithDetail("void ()"),
-                               SymNameRange(Main.range("decl"))))),
-          AllOf(WithName("Foo::f"), WithKind(SymbolKind::Method),
-                WithDetail("void ()"), SymNameRange(Main.range("def")))));
+          AllOf(withName("Foo"), withKind(SymbolKind::Class),
+                withDetail("class"),
+                children(AllOf(withName("f"), withKind(SymbolKind::Method),
+                               withDetail("void ()"),
+                               symNameRange(Main.range("decl"))))),
+          AllOf(withName("Foo::f"), withKind(SymbolKind::Method),
+                withDetail("void ()"), symNameRange(Main.range("def")))));
 }
 
 TEST(DocumentSymbols, Concepts) {
   TestTU TU;
   TU.ExtraArgs = {"-std=c++20"};
   TU.Code = "template <typename T> concept C = requires(T t) { t.foo(); };";
 
   EXPECT_THAT(getSymbols(TU.build()),
-              ElementsAre(AllOf(WithName("C"), WithDetail("concept"))));
+              ElementsAre(AllOf(withName("C"), withDetail("concept"))));
 }
 
 TEST(DocumentSymbols, ExternSymbol) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"cpp(
       extern int var;
       )cpp";
   TU.Code = R"cpp(
TU.Code = R"cpp(
       namespace ns {
         extern "C" {
         void bar();
         class Bar {};
         }
       })cpp";
 
   EXPECT_THAT(getSymbols(TU.build()),
-              ElementsAre(WithName("foo"), WithName("Foo"),
-                          AllOf(WithName("ns"),
-                                Children(WithName("bar"), WithName("Bar")))));
+              ElementsAre(withName("foo"), withName("Foo"),
+                          AllOf(withName("ns"),
+                                children(withName("bar"), withName("Bar")))));
 }
 
 TEST(DocumentSymbols, ExportContext) {
   TestTU TU;
   TU.ExtraArgs = {"-std=c++20"};
   TU.Code = R"cpp(
       export module test;
       export {
       void foo();
       class Foo {};
       })cpp";
 
   EXPECT_THAT(getSymbols(TU.build()),
-              ElementsAre(WithName("foo"), WithName("Foo")));
+              ElementsAre(withName("foo"), withName("Foo")));
 }
 
 TEST(DocumentSymbols, NoLocals) {
   TestTU TU;
   TU.Code = R"cpp(
       void test(int FirstParam, int SecondParam) {
         struct LocalClass {};
         int local_var;
       })cpp";
-  EXPECT_THAT(getSymbols(TU.build()), ElementsAre(WithName("test")));
+  EXPECT_THAT(getSymbols(TU.build()), ElementsAre(withName("test")));
 }
 
 TEST(DocumentSymbols, Unnamed) {
   TestTU TU;
   TU.Code = R"cpp(
       struct {
         int InUnnamed;
       } UnnamedStruct;
       )cpp";
   EXPECT_THAT(
       getSymbols(TU.build()),
-      ElementsAre(AllOf(WithName("(anonymous struct)"),
-                        WithKind(SymbolKind::Struct), WithDetail("struct"),
-                        Children(AllOf(WithName("InUnnamed"),
-                                       WithKind(SymbolKind::Field),
-                                       WithDetail("int"), Children()))),
-                  AllOf(WithName("UnnamedStruct"),
-                        WithKind(SymbolKind::Variable),
-                        WithDetail("struct (unnamed)"), Children())));
+      ElementsAre(AllOf(withName("(anonymous struct)"),
+                        withKind(SymbolKind::Struct), withDetail("struct"),
+                        children(AllOf(withName("InUnnamed"),
+                                       withKind(SymbolKind::Field),
+                                       withDetail("int"), children()))),
+                  AllOf(withName("UnnamedStruct"),
+                        withKind(SymbolKind::Variable),
+                        withDetail("struct (unnamed)"), children())));
 }
 
 TEST(DocumentSymbols, InHeaderFile) {
   TestTU TU;
   TU.AdditionalFiles["bar.h"] = R"cpp(
       int foo() {
       }
       )cpp";
   TU.Code = R"cpp(
       int i; // declaration to finish preamble
       #include "bar.h"
       int test() {
       }
       )cpp";
   EXPECT_THAT(getSymbols(TU.build()),
-              ElementsAre(WithName("i"), WithName("test")));
+              ElementsAre(withName("i"), withName("test")));
 }
 
 TEST(DocumentSymbols, Template) {
   TestTU TU;
   TU.Code = R"(
     template <class T> struct Tmpl {T x = 0;};
     template <> struct Tmpl<int> {
       int y = 0;
TU.Code = R"(
     template <class T, class U = double>
     int varTmpl = T();
     template <>
     double varTmpl<int> = 10.0;
   )";
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
-          AllOf(WithName("Tmpl"), WithKind(SymbolKind::Struct),
-                WithDetail("template struct"),
-                Children(AllOf(WithName("x"), WithKind(SymbolKind::Field),
-                               WithDetail("T")))),
-          AllOf(WithName("Tmpl<int>"), WithKind(SymbolKind::Struct),
-                WithDetail("struct"),
-                Children(AllOf(WithName("y"), WithDetail("int")))),
-          AllOf(WithName("Tmpl<float>"), WithKind(SymbolKind::Struct),
-                WithDetail("struct"), Children()),
-          AllOf(WithName("Tmpl<double>"), WithKind(SymbolKind::Struct),
-                WithDetail("struct"), Children()),
-          AllOf(WithName("funcTmpl"), WithDetail("template int (U)"),
-                Children()),
-          AllOf(WithName("funcTmpl<int>"), WithDetail("int (double)"),
-                Children()),
-          AllOf(WithName("varTmpl"), WithDetail("template int"), Children()),
-          AllOf(WithName("varTmpl<int>"), WithDetail("double"), Children())));
+          AllOf(withName("Tmpl"), withKind(SymbolKind::Struct),
+                withDetail("template struct"),
+                children(AllOf(withName("x"), withKind(SymbolKind::Field),
+                               withDetail("T")))),
+          AllOf(withName("Tmpl<int>"), withKind(SymbolKind::Struct),
+                withDetail("struct"),
+                children(AllOf(withName("y"), withDetail("int")))),
+          AllOf(withName("Tmpl<float>"), withKind(SymbolKind::Struct),
+                withDetail("struct"), children()),
+          AllOf(withName("Tmpl<double>"), withKind(SymbolKind::Struct),
+                withDetail("struct"), children()),
+          AllOf(withName("funcTmpl"), withDetail("template int (U)"),
+                children()),
+          AllOf(withName("funcTmpl<int>"), withDetail("int (double)"),
+                children()),
+          AllOf(withName("varTmpl"), withDetail("template int"), children()),
+          AllOf(withName("varTmpl<int>"), withDetail("double"), children())));
 }
 
 TEST(DocumentSymbols, Namespaces) {
   TestTU TU;
   TU.Code = R"cpp(
       namespace ans1 {
         int ai1;
       namespace ans2 {
TU.Code = R"cpp(
       namespace nb {
       class Bar {};
       }
       }
       )cpp";
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAreArray<::testing::Matcher<DocumentSymbol>>(
-          {AllOf(WithName("ans1"),
-                 Children(AllOf(WithName("ai1"), Children()),
-                          AllOf(WithName("ans2"), Children(WithName("ai2"))))),
-           AllOf(WithName("(anonymous namespace)"), Children(WithName("test"))),
-           AllOf(WithName("na"),
-                 Children(AllOf(WithName("nb"), Children(WithName("Foo"))))),
-           AllOf(WithName("na"),
-                 Children(AllOf(WithName("nb"), Children(WithName("Bar")))))}));
+          {AllOf(withName("ans1"),
+                 children(AllOf(withName("ai1"), children()),
+                          AllOf(withName("ans2"), children(withName("ai2"))))),
+           AllOf(withName("(anonymous namespace)"), children(withName("test"))),
+           AllOf(withName("na"),
+                 children(AllOf(withName("nb"), children(withName("Foo"))))),
+           AllOf(withName("na"),
+                 children(AllOf(withName("nb"), children(withName("Bar")))))}));
 }
 
 TEST(DocumentSymbols, Enums) {
   TestTU TU;
   TU.Code = R"(
       enum {
         Red
       };
       enum Color {
         Green
       };
       enum class Color2 {
         Yellow
       };
       namespace ns {
       enum {
         Black
       };
       }
     )";
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
-          AllOf(WithName("(anonymous enum)"), WithDetail("enum"), 
-                Children(AllOf(WithName("Red"), WithDetail("(unnamed)")))),
-          AllOf(WithName("Color"), WithDetail("enum"),
-                Children(AllOf(WithName("Green"), WithDetail("Color")))),
-          AllOf(WithName("Color2"), WithDetail("enum"),
-                Children(AllOf(WithName("Yellow"), WithDetail("Color2")))),
-          AllOf(WithName("ns"),
-                Children(AllOf(WithName("(anonymous enum)"), WithDetail("enum"),
-                               Children(AllOf(WithName("Black"),
-                                              WithDetail("(unnamed)"))))))));
+          AllOf(withName("(anonymous enum)"), withDetail("enum"),
+                children(AllOf(withName("Red"), withDetail("(unnamed)")))),
+          AllOf(withName("Color"), withDetail("enum"),
+                children(AllOf(withName("Green"), withDetail("Color")))),
+          AllOf(withName("Color2"), withDetail("enum"),
+                children(AllOf(withName("Yellow"), withDetail("Color2")))),
+          AllOf(withName("ns"),
+                children(AllOf(withName("(anonymous enum)"), withDetail("enum"),
+                               children(AllOf(withName("Black"),
+                                              withDetail("(unnamed)"))))))));
 }
 
 TEST(DocumentSymbols, Macro) {
   struct Test {
     const char *Code;
     testing::Matcher<DocumentSymbol> Matcher;
   } Tests[] = {
       {
           R"cpp(
             // Basic macro that generates symbols.
             #define DEFINE_FLAG(X) bool FLAGS_##X; bool FLAGS_no##X
             DEFINE_FLAG(pretty);
           )cpp",
-          AllOf(WithName("DEFINE_FLAG"), WithDetail("(pretty)"),
-                Children(WithName("FLAGS_pretty"), WithName("FLAGS_nopretty"))),
+          AllOf(withName("DEFINE_FLAG"), withDetail("(pretty)"),
+                children(withName("FLAGS_pretty"), withName("FLAGS_nopretty"))),
       },
       {
           R"cpp(
             // Hierarchy is determined by primary (name) location.
             #define ID(X) X
             namespace ID(ns) { int ID(y); }
           )cpp",
-          AllOf(WithName("ID"), WithDetail("(ns)"),
-                Children(AllOf(WithName("ns"),
-                               Children(AllOf(WithName("ID"), WithDetail("(y)"),
-                                              Children(WithName("y"))))))),
+          AllOf(withName("ID"), withDetail("(ns)"),
+                children(AllOf(withName("ns"),
+                               children(AllOf(withName("ID"), withDetail("(y)"),
+                                              children(withName("y"))))))),
       },
       {
           R"cpp(
             // More typical example where macro only generates part of a decl.
             #define TEST(A, B) class A##_##B { void go(); }; void A##_##B::go()
             TEST(DocumentSymbols, Macro) { }
           )cpp",
-          AllOf(WithName("TEST"), WithDetail("(DocumentSymbols, Macro)"),
-                Children(AllOf(WithName("DocumentSymbols_Macro"),
-                               Children(WithName("go"))),
-                         WithName("DocumentSymbols_Macro::go"))),
+          AllOf(withName("TEST"), withDetail("(DocumentSymbols, Macro)"),
+                children(AllOf(withName("DocumentSymbols_Macro"),
+                               children(withName("go"))),
+                         withName("DocumentSymbols_Macro::go"))),
       },
       {
           R"cpp(
             // Nested macros.
             #define NAMESPACE(NS, BODY) namespace NS { BODY }
             NAMESPACE(a, NAMESPACE(b, int x;))
           )cpp",
           AllOf(
-              WithName("NAMESPACE"), WithDetail("(a, NAMESPACE(b, int x;))"),
-              Children(AllOf(
-                  WithName("a"),
-                  Children(AllOf(WithName("NAMESPACE"),
+              withName("NAMESPACE"), withDetail("(a, NAMESPACE(b, int x;))"),
+              children(AllOf(
+                  withName("a"),
+                  children(AllOf(withName("NAMESPACE"),
                                  // FIXME: nested expansions not in TokenBuffer
-                                 WithDetail(""),
-                                 Children(AllOf(WithName("b"),
-                                                Children(WithName("x"))))))))),
+                                 withDetail(""),
+                                 children(AllOf(withName("b"),
+                                                children(withName("x"))))))))),
       },
       {
           R"cpp(
             // Macro invoked from body is not exposed.
             #define INNER(X) int X
             #define OUTER(X) INNER(X)
             OUTER(foo);
           )cpp",
-          AllOf(WithName("OUTER"), WithDetail("(foo)"),
-                Children(WithName("foo"))),
+          AllOf(withName("OUTER"), withDetail("(foo)"),
+                children(withName("foo"))),
       },
   };
   for (const Test &T : Tests) {
     auto TU = TestTU::withCode(T.Code);
     EXPECT_THAT(getSymbols(TU.build()), ElementsAre(T.Matcher)) << T.Code;
   }
 }
 
Annotations Main(R"(
     $fullDef[[FF3() {
       int var = 42;
     }]]
   )");
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
-          AllOf(WithName("FF"), WithDetail("(abc)"),
-                Children(AllOf(WithName("abc_Test"), WithDetail("class"),
-                               SymNameRange(Main.range("expansion1"))))),
-          AllOf(WithName("FF2"), WithDetail("()"),
-                SymNameRange(Main.range("expansion2")),
-                SymRange(Main.range("expansion2parens")),
-                Children(AllOf(WithName("Test"), WithDetail("class"),
-                               SymNameRange(Main.range("expansion2"))))),
-          AllOf(WithName("FF3"), WithDetail("()"),
-                SymRange(Main.range("fullDef")),
-                Children(AllOf(WithName("waldo"), WithDetail("void ()"),
-                               SymRange(Main.range("fullDef")))))));
+          AllOf(withName("FF"), withDetail("(abc)"),
+                children(AllOf(withName("abc_Test"), withDetail("class"),
+                               symNameRange(Main.range("expansion1"))))),
+          AllOf(withName("FF2"), withDetail("()"),
+                symNameRange(Main.range("expansion2")),
+                symRange(Main.range("expansion2parens")),
+                children(AllOf(withName("Test"), withDetail("class"),
+                               symNameRange(Main.range("expansion2"))))),
+          AllOf(withName("FF3"), withDetail("()"),
+                symRange(Main.range("fullDef")),
+                children(AllOf(withName("waldo"), withDetail("void ()"),
+                               symRange(Main.range("fullDef")))))));
 }
 
 TEST(DocumentSymbols, FuncTemplates) {
   TestTU TU;
   Annotations Source(R"cpp(
     template <class T>
     T foo() {}
 
     auto x = foo<int>();
     auto y = foo<double>();
   )cpp");
   TU.Code = Source.code().str();
   // Make sure we only see the template declaration, not instantiations.
   EXPECT_THAT(getSymbols(TU.build()),
-              ElementsAre(AllOf(WithName("foo"), WithDetail("template T ()")),
-                          AllOf(WithName("x"), WithDetail("int")),
-                          AllOf(WithName("y"), WithDetail("double"))));
+              ElementsAre(AllOf(withName("foo"), withDetail("template T ()")),
+                          AllOf(withName("x"), withDetail("int")),
+                          AllOf(withName("y"), withDetail("double"))));
 }
 
 TEST(DocumentSymbols, UsingDirectives) {
   TestTU TU;
   Annotations Source(R"cpp(
     namespace ns {
       int foo;
     }
 
     namespace ns_alias = ns;
 
     using namespace ::ns;     // check we don't loose qualifiers.
     using namespace ns_alias; // and namespace aliases.
   )cpp");
   TU.Code = Source.code().str();
   EXPECT_THAT(getSymbols(TU.build()),
-              ElementsAre(WithName("ns"), WithName("ns_alias"),
-                          WithName("using namespace ::ns"),
-                          WithName("using namespace ns_alias")));
+              ElementsAre(withName("ns"), withName("ns_alias"),
+                          withName("using namespace ::ns"),
+                          withName("using namespace ns_alias")));
 }
 
 TEST(DocumentSymbols, TempSpecs) {
   TestTU TU;
   TU.Code = R"cpp(
       template <typename T, typename U, int X = 5> class Foo {};
       template <typename T> class Foo<int, T> {};
       template <> class Foo<bool, int> {};
       template <> class Foo<bool, int, 3> {};
       )cpp";
   // Foo is higher ranked because of exact name match.
   EXPECT_THAT(getSymbols(TU.build()),
               UnorderedElementsAre(
-                  AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
-                        WithDetail("template class")),
-                  AllOf(WithName("Foo<int, T>"), WithKind(SymbolKind::Class),
-                        WithDetail("template class")),
-                  AllOf(WithName("Foo<bool, int>"), WithKind(SymbolKind::Class),
-                        WithDetail("class")),
-                  AllOf(WithName("Foo<bool, int, 3>"),
-                        WithKind(SymbolKind::Class), WithDetail("class"))));
+                  AllOf(withName("Foo"), withKind(SymbolKind::Class),
+                        withDetail("template class")),
+                  AllOf(withName("Foo<int, T>"), withKind(SymbolKind::Class),
+                        withDetail("template class")),
+                  AllOf(withName("Foo<bool, int>"), withKind(SymbolKind::Class),
+                        withDetail("class")),
+                  AllOf(withName("Foo<bool, int, 3>"),
+                        withKind(SymbolKind::Class), withDetail("class"))));
 }
 
 TEST(DocumentSymbols, Qualifiers) {
   TestTU TU;
   TU.Code = R"cpp(
     namespace foo { namespace bar {
       struct Cls;
 
TU.Code = R"cpp(
 
     namespace alias = foo::bar;
     int ::alias::func4() { return 40; }
   )cpp";
 
   // All the qualifiers should be preserved exactly as written.
   EXPECT_THAT(getSymbols(TU.build()),
               UnorderedElementsAre(
-                  WithName("foo"), WithName("foo::bar::Cls"),
-                  WithName("foo::bar::func1"), WithName("::foo::bar::func2"),
-                  WithName("using namespace foo"), WithName("bar::func3"),
-                  WithName("alias"), WithName("::alias::func4")));
+                  withName("foo"), withName("foo::bar::Cls"),
+                  withName("foo::bar::func1"), withName("::foo::bar::func2"),
+                  withName("using namespace foo"), withName("bar::func3"),
+                  withName("alias"), withName("::alias::func4")));
 }
 
 TEST(DocumentSymbols, QualifiersWithTemplateArgs) {
   TestTU TU;
   TU.Code = R"cpp(
       template <typename T, typename U = double> class Foo;
 
       template <>
TU.Code = R"cpp(
       int Foo<int>::method2() { return 20; }
 
       using Foo_type = Foo<int>;
       // If the whole type is aliased, this should be preserved too!
       int Foo_type::method3() { return 30; }
       )cpp";
   EXPECT_THAT(getSymbols(TU.build()),
               UnorderedElementsAre(
-                  AllOf(WithName("Foo"), WithDetail("template class")),
-                  AllOf(WithName("Foo<int, double>"), WithDetail("class")),
-                  AllOf(WithName("int_type"), WithDetail("type alias")),
-                  AllOf(WithName("Foo<int_type, double>::method1"),
-                        WithDetail("int ()")),
-                  AllOf(WithName("Foo<int>::method2"), WithDetail("int ()")),
-                  AllOf(WithName("Foo_type"), WithDetail("type alias")),
-                  AllOf(WithName("Foo_type::method3"), WithDetail("int ()"))));
+                  AllOf(withName("Foo"), withDetail("template class")),
+                  AllOf(withName("Foo<int, double>"), withDetail("class")),
+                  AllOf(withName("int_type"), withDetail("type alias")),
+                  AllOf(withName("Foo<int_type, double>::method1"),
+                        withDetail("int ()")),
+                  AllOf(withName("Foo<int>::method2"), withDetail("int ()")),
+                  AllOf(withName("Foo_type"), withDetail("type alias")),
+                  AllOf(withName("Foo_type::method3"), withDetail("int ()"))));
 }
 
 TEST(DocumentSymbolsTest, Ranges) {
   TestTU TU;
   Annotations Main(R"(
       $foo[[int foo(bool Argument) {
         return 42;
       }]]
Annotations Main(R"(
       $forwardstruct[[struct StructDeclaration]];
 
       $forwardfunc[[void forwardFunctionDecl(int Something)]];
     )");
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       UnorderedElementsAre(
-          AllOf(WithName("foo"), WithKind(SymbolKind::Function),
-                WithDetail("int (bool)"), SymRange(Main.range("foo"))),
-          AllOf(WithName("GLOBAL_VARIABLE"), WithKind(SymbolKind::Variable),
-                WithDetail("char"), SymRange(Main.range("variable"))),
+          AllOf(withName("foo"), withKind(SymbolKind::Function),
+                withDetail("int (bool)"), symRange(Main.range("foo"))),
+          AllOf(withName("GLOBAL_VARIABLE"), withKind(SymbolKind::Variable),
+                withDetail("char"), symRange(Main.range("variable"))),
           AllOf(
-              WithName("ns"), WithKind(SymbolKind::Namespace),
-              SymRange(Main.range("ns")),
-              Children(AllOf(
-                  WithName("Bar"), WithKind(SymbolKind::Class),
-                  WithDetail("class"), SymRange(Main.range("bar")),
-                  Children(
-                      AllOf(WithName("Bar"), WithKind(SymbolKind::Constructor),
-                            WithDetail("()"), SymRange(Main.range("ctor"))),
-                      AllOf(WithName("~Bar"), WithKind(SymbolKind::Constructor),
-                            WithDetail(""), SymRange(Main.range("dtor"))),
-                      AllOf(WithName("Baz"), WithKind(SymbolKind::Field),
-                            WithDetail("unsigned int"),
-                            SymRange(Main.range("field"))),
-                      AllOf(WithName("getBaz"), WithKind(SymbolKind::Method),
-                            WithDetail("unsigned int ()"),
-                            SymRange(Main.range("getbaz"))))))),
-          AllOf(WithName("ForwardClassDecl"), WithKind(SymbolKind::Class),
-                WithDetail("class"), SymRange(Main.range("forwardclass"))),
-          AllOf(WithName("StructDefinition"), WithKind(SymbolKind::Struct),
-                WithDetail("struct"), SymRange(Main.range("struct")),
-                Children(AllOf(WithName("Pointer"), WithKind(SymbolKind::Field),
-                               WithDetail("int *"),
-                               SymRange(Main.range("structfield"))))),
-          AllOf(WithName("StructDeclaration"), WithKind(SymbolKind::Struct),
-                WithDetail("struct"), SymRange(Main.range("forwardstruct"))),
-          AllOf(WithName("forwardFunctionDecl"), WithKind(SymbolKind::Function),
-                WithDetail("void (int)"),
-                SymRange(Main.range("forwardfunc")))));
+              withName("ns"), withKind(SymbolKind::Namespace),
+              symRange(Main.range("ns")),
+              children(AllOf(
+                  withName("Bar"), withKind(SymbolKind::Class),
+                  withDetail("class"), symRange(Main.range("bar")),
+                  children(
+                      AllOf(withName("Bar"), withKind(SymbolKind::Constructor),
+                            withDetail("()"), symRange(Main.range("ctor"))),
+                      AllOf(withName("~Bar"), withKind(SymbolKind::Constructor),
+                            withDetail(""), symRange(Main.range("dtor"))),
+                      AllOf(withName("Baz"), withKind(SymbolKind::Field),
+                            withDetail("unsigned int"),
+                            symRange(Main.range("field"))),
+                      AllOf(withName("getBaz"), withKind(SymbolKind::Method),
+                            withDetail("unsigned int ()"),
+                            symRange(Main.range("getbaz"))))))),
+          AllOf(withName("ForwardClassDecl"), withKind(SymbolKind::Class),
+                withDetail("class"), symRange(Main.range("forwardclass"))),
+          AllOf(withName("StructDefinition"), withKind(SymbolKind::Struct),
+                withDetail("struct"), symRange(Main.range("struct")),
+                children(AllOf(withName("Pointer"), withKind(SymbolKind::Field),
+                               withDetail("int *"),
+                               symRange(Main.range("structfield"))))),
+          AllOf(withName("StructDeclaration"), withKind(SymbolKind::Struct),
+                withDetail("struct"), symRange(Main.range("forwardstruct"))),
+          AllOf(withName("forwardFunctionDecl"), withKind(SymbolKind::Function),
+                withDetail("void (int)"),
+                symRange(Main.range("forwardfunc")))));
 }
 
 TEST(DocumentSymbolsTest, DependentType) {
   TestTU TU;
   TU.Code = R"(
     template <typename T> auto plus(T x, T y) -> decltype(x + y) { return x + y; }
 
     template <typename Key, typename Value> class Pair {};
 
     template <typename Key, typename Value>
     struct Context : public Pair<Key, Value> {
       using Pair<Key, Value>::Pair;
     };
     )";
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
-          AllOf(WithName("plus"),
-                WithDetail("template auto (T, T) -> decltype(x + y)")),
-          AllOf(WithName("Pair"), WithDetail("template class")),
-          AllOf(WithName("Context"), WithDetail("template struct"),
-                Children(AllOf(
-                    WithName("Pair<type-parameter-0-0, type-parameter-0-1>"),
-                    WithDetail("<dependent type>"))))));
+          AllOf(withName("plus"),
+                withDetail("template auto (T, T) -> decltype(x + y)")),
+          AllOf(withName("Pair"), withDetail("template class")),
+          AllOf(withName("Context"), withDetail("template struct"),
+                children(AllOf(
+                    withName("Pair<type-parameter-0-0, type-parameter-0-1>"),
+                    withDetail("<dependent type>"))))));
 }
 
 TEST(DocumentSymbolsTest, ObjCCategoriesAndClassExtensions) {
   TestTU TU;
   TU.ExtraArgs = {"-xobjective-c++", "-Wno-objc-root-class"};
   Annotations Main(R"cpp(
       $Cat[[@interface Cat
       + (id)sharedCat;
       @end]]
       $SneakyCat[[@interface Cat (Sneaky)
       - (id)sneak:(id)behavior;
       @end]]
 
       $MeowCat[[@interface Cat ()
       - (void)meow;
       @end]]
       $PurCat[[@interface Cat ()
       - (void)pur;
       @end]]
     )cpp");
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
-          AllOf(WithName("Cat"), SymRange(Main.range("Cat")),
-                Children(AllOf(WithName("+sharedCat"),
-                               WithKind(SymbolKind::Method)))),
-          AllOf(WithName("Cat(Sneaky)"), SymRange(Main.range("SneakyCat")),
-                Children(
-                    AllOf(WithName("-sneak:"), WithKind(SymbolKind::Method)))),
+          AllOf(withName("Cat"), symRange(Main.range("Cat")),
+                children(AllOf(withName("+sharedCat"),
+                               withKind(SymbolKind::Method)))),
+          AllOf(withName("Cat(Sneaky)"), symRange(Main.range("SneakyCat")),
+                children(
+                    AllOf(withName("-sneak:"), withKind(SymbolKind::Method)))),
           AllOf(
-              WithName("Cat()"), SymRange(Main.range("MeowCat")),
-              Children(AllOf(WithName("-meow"), WithKind(SymbolKind::Method)))),
-          AllOf(WithName("Cat()"), SymRange(Main.range("PurCat")),
-                Children(
-                    AllOf(WithName("-pur"), WithKind(SymbolKind::Method))))));
+              withName("Cat()"), symRange(Main.range("MeowCat")),
+              children(AllOf(withName("-meow"), withKind(SymbolKind::Method)))),
+          AllOf(withName("Cat()"), symRange(Main.range("PurCat")),
+                children(
+                    AllOf(withName("-pur"), withKind(SymbolKind::Method))))));
 }
 
 TEST(DocumentSymbolsTest, PragmaMarkGroups) {
   TestTU TU;
   TU.ExtraArgs = {"-xobjective-c++", "-Wno-objc-root-class"};
   Annotations Main(R"cpp(
       $DogDef[[@interface Dog
       @end]]
Annotations Main(R"cpp(
 
       #pragma $End[[mark - End
 ]]
     )cpp");
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       UnorderedElementsAre(
-          AllOf(WithName("Dog"), SymRange(Main.range("DogDef"))),
-          AllOf(WithName("Dog"), SymRange(Main.range("DogImpl")),
-                Children(AllOf(WithName("+sharedDoggo"),
-                               WithKind(SymbolKind::Method)),
-                         AllOf(WithName("Overrides"),
-                               SymRange(Main.range("Overrides")),
-                               Children(AllOf(WithName("-init"),
-                                              WithKind(SymbolKind::Method)),
-                                        AllOf(WithName("-bark"),
-                                              WithKind(SymbolKind::Method)))),
-                         AllOf(WithName("Dog Specifics"),
-                               SymRange(Main.range("Specifics")),
-                               Children(AllOf(WithName("-isAGoodBoy"),
-                                              WithKind(SymbolKind::Method)))))),
-          AllOf(WithName("End"), SymRange(Main.range("End")))));
+          AllOf(withName("Dog"), symRange(Main.range("DogDef"))),
+          AllOf(withName("Dog"), symRange(Main.range("DogImpl")),
+                children(AllOf(withName("+sharedDoggo"),
+                               withKind(SymbolKind::Method)),
+                         AllOf(withName("Overrides"),
+                               symRange(Main.range("Overrides")),
+                               children(AllOf(withName("-init"),
+                                              withKind(SymbolKind::Method)),
+                                        AllOf(withName("-bark"),
+                                              withKind(SymbolKind::Method)))),
+                         AllOf(withName("Dog Specifics"),
+                               symRange(Main.range("Specifics")),
+                               children(AllOf(withName("-isAGoodBoy"),
+                                              withKind(SymbolKind::Method)))))),
+          AllOf(withName("End"), symRange(Main.range("End")))));
 }
 
 TEST(DocumentSymbolsTest, PragmaMarkGroupsNesting) {
   TestTU TU;
   TU.ExtraArgs = {"-xobjective-c++", "-Wno-objc-root-class"};
   Annotations Main(R"cpp(
       #pragma mark - Foo
       struct Foo {
         #pragma mark - Bar
         void bar() {
            #pragma mark - NotTopDecl
         }
       };
       void bar() {}
     )cpp");
   TU.Code = Main.code().str();
   EXPECT_THAT(
       getSymbols(TU.build()),
       UnorderedElementsAre(AllOf(
-          WithName("Foo"),
-          Children(AllOf(WithName("Foo"),
-                         Children(AllOf(WithName("Bar"),
-                                        Children(AllOf(WithName("bar"),
-                                                       Children(WithName(
+          withName("Foo"),
+          children(AllOf(withName("Foo"),
+                         children(AllOf(withName("Bar"),
+                                        children(AllOf(withName("bar"),
+                                                       children(withName(
                                                            "NotTopDecl"))))))),
-                   WithName("bar")))));
+                   withName("bar")))));
 }
 
 TEST(DocumentSymbolsTest, PragmaMarkGroupsNoNesting) {
   TestTU TU;
   TU.ExtraArgs = {"-xobjective-c++", "-Wno-objc-root-class"};
   Annotations Main(R"cpp(
       #pragma mark Helpers
       void helpA(id obj) {}
 
       #pragma mark -
       #pragma mark Core
 
       void coreMethod() {}
     )cpp");
   TU.Code = Main.code().str();
   EXPECT_THAT(getSymbols(TU.build()),
-              UnorderedElementsAre(WithName("Helpers"), WithName("helpA"),
-                                   WithName("(unnamed group)"),
-                                   WithName("Core"), WithName("coreMethod")));
+              UnorderedElementsAre(withName("Helpers"), withName("helpA"),
+                                   withName("(unnamed group)"),
+                                   withName("Core"), withName("coreMethod")));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

TEST(HeaderSourceSwitchTest, FileHeuristic) {
   ASSERT_EQ(PathResult.getValue(), Foo3HXX);
 
   // Test if asking for a corresponding file that doesn't exist returns an empty
   // string.
   PathResult = getCorrespondingHeaderOrSource(Invalid, FS.view(llvm::None));
   EXPECT_FALSE(PathResult.hasValue());
 }
 
-MATCHER_P(DeclNamed, Name, "") {
+MATCHER_P(declNamed, Name, "") {
   if (const NamedDecl *ND = dyn_cast<NamedDecl>(arg))
     if (ND->getQualifiedNameAsString() == Name)
       return true;
   return false;
 }
 
 TEST(HeaderSourceSwitchTest, GetLocalDecls) {
   TestTU TU;
TEST(HeaderSourceSwitchTest, GetLocalDecls) {
   void Ignore1() {}
   }
 
   )cpp";
 
   auto AST = TU.build();
   EXPECT_THAT(getIndexableLocalDecls(AST),
               testing::UnorderedElementsAre(
-                  DeclNamed("MainF1"), DeclNamed("Foo"), DeclNamed("ns::Foo"),
-                  DeclNamed("ns::Foo::method"), DeclNamed("ns::Foo::field")));
+                  declNamed("MainF1"), declNamed("Foo"), declNamed("ns::Foo"),
+                  declNamed("ns::Foo::method"), declNamed("ns::Foo::field")));
 }
 
 TEST(HeaderSourceSwitchTest, FromHeaderToSource) {
   // build a proper index, which contains symbols:
   //   A_Sym1, declared in TestTU.h, defined in a.cpp
   //   B_Sym[1-2], declared in TestTU.h, defined in b.cpp
   SymbolSlab::Builder AllSymbols;
   TestTU Testing;

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

protected:
   MockCompilationDatabase CDB;
   std::string MainFile = testPath("main.cpp");
   std::string Subdir = testPath("sub");
   std::string SearchDirArg = (llvm::Twine("-I") + Subdir).str();
   IgnoringDiagConsumer IgnoreDiags;
   std::unique_ptr<CompilerInstance> Clang;
 };
 
-MATCHER_P(Written, Name, "") { return arg.Written == Name; }
-MATCHER_P(Resolved, Name, "") { return arg.Resolved == Name; }
-MATCHER_P(IncludeLine, N, "") { return arg.HashLine == N; }
-MATCHER_P(Directive, D, "") { return arg.Directive == D; }
-MATCHER_P(HasPragmaKeep, H, "") { return arg.BehindPragmaKeep == H; }
+MATCHER_P(written, Name, "") { return arg.Written == Name; }
+MATCHER_P(resolved, Name, "") { return arg.Resolved == Name; }
+MATCHER_P(includeLine, N, "") { return arg.HashLine == N; }
+MATCHER_P(directive, D, "") { return arg.Directive == D; }
+MATCHER_P(hasPragmaKeep, H, "") { return arg.BehindPragmaKeep == H; }
 
 MATCHER_P2(Distance, File, D, "") {
   if (arg.getFirst() != File)
     *result_listener << "file =" << static_cast<unsigned>(arg.getFirst());
   if (arg.getSecond() != D)
     *result_listener << "distance =" << arg.getSecond();
   return arg.getFirst() == File && arg.getSecond() == D;
 }
 
 TEST_F(HeadersTest, CollectRewrittenAndResolved) {
   FS.Files[MainFile] = R"cpp(
 #include "sub/bar.h" // not shortest
 )cpp";
   std::string BarHeader = testPath("sub/bar.h");
   FS.Files[BarHeader] = "";
 
   auto Includes = collectIncludes();
   EXPECT_THAT(Includes.MainFileIncludes,
               UnorderedElementsAre(
-                  AllOf(Written("\"sub/bar.h\""), Resolved(BarHeader))));
+                  AllOf(written("\"sub/bar.h\""), resolved(BarHeader))));
   EXPECT_THAT(Includes.includeDepth(getID(MainFile, Includes)),
               UnorderedElementsAre(Distance(getID(MainFile, Includes), 0u),
                                    Distance(getID(BarHeader, Includes), 1u)));
 }
 
 TEST_F(HeadersTest, OnlyCollectInclusionsInMain) {
   std::string BazHeader = testPath("sub/baz.h");
   FS.Files[BazHeader] = "";
   std::string BarHeader = testPath("sub/bar.h");
   FS.Files[BarHeader] = R"cpp(
 #include "baz.h"
 )cpp";
   FS.Files[MainFile] = R"cpp(
 #include "bar.h"
 )cpp";
   auto Includes = collectIncludes();
   EXPECT_THAT(
       Includes.MainFileIncludes,
-      UnorderedElementsAre(AllOf(Written("\"bar.h\""), Resolved(BarHeader))));
+      UnorderedElementsAre(AllOf(written("\"bar.h\""), resolved(BarHeader))));
   EXPECT_THAT(Includes.includeDepth(getID(MainFile, Includes)),
               UnorderedElementsAre(Distance(getID(MainFile, Includes), 0u),
                                    Distance(getID(BarHeader, Includes), 1u),
                                    Distance(getID(BazHeader, Includes), 2u)));
   // includeDepth() also works for non-main files.
   EXPECT_THAT(Includes.includeDepth(getID(BarHeader, Includes)),
               UnorderedElementsAre(Distance(getID(BarHeader, Includes), 0u),
                                    Distance(getID(BazHeader, Includes), 1u)));
 }
 
 TEST_F(HeadersTest, PreambleIncludesPresentOnce) {
   // We use TestTU here, to ensure we use the preamble replay logic.
   // We're testing that the logic doesn't crash, and doesn't result in duplicate
   // includes. (We'd test more directly, but it's pretty well encapsulated!)
   auto TU = TestTU::withCode(R"cpp(
     #include "a.h"
 
     #include "a.h"
     void foo();
     #include "a.h"
   )cpp");
   TU.HeaderFilename = "a.h"; // suppress "not found".
   EXPECT_THAT(TU.build().getIncludeStructure().MainFileIncludes,
-              ElementsAre(IncludeLine(1), IncludeLine(3), IncludeLine(5)));
+              ElementsAre(includeLine(1), includeLine(3), includeLine(5)));
 }
 
 TEST_F(HeadersTest, UnResolvedInclusion) {
   FS.Files[MainFile] = R"cpp(
 #include "foo.h"
 )cpp";
 
   EXPECT_THAT(collectIncludes().MainFileIncludes,
-              UnorderedElementsAre(AllOf(Written("\"foo.h\""), Resolved(""))));
+              UnorderedElementsAre(AllOf(written("\"foo.h\""), resolved(""))));
   EXPECT_THAT(collectIncludes().IncludeChildren, IsEmpty());
 }
 
 TEST_F(HeadersTest, IncludedFilesGraph) {
   FS.Files[MainFile] = R"cpp(
 #include "bar.h"
 #include "foo.h"
 )cpp";

 #include "foo.h"
 #import "foo.h"
 #include_next "foo.h"
 )cpp";
 
   // ms-compatibility changes meaning of #import, make sure it is turned off.
   CDB.ExtraClangFlags.push_back("-fno-ms-compatibility");
   EXPECT_THAT(collectIncludes().MainFileIncludes,
-              UnorderedElementsAre(Directive(tok::pp_include),
-                                   Directive(tok::pp_import),
-                                   Directive(tok::pp_include_next)));
+              UnorderedElementsAre(directive(tok::pp_include),
+                                   directive(tok::pp_import),
+                                   directive(tok::pp_include_next)));
 }
 
 TEST_F(HeadersTest, IWYUPragmaKeep) {
   FS.Files[MainFile] = R"cpp(
 #include "bar.h" // IWYU pragma: keep
 #include "foo.h"
 )cpp";
 
   EXPECT_THAT(
       collectIncludes().MainFileIncludes,
-      UnorderedElementsAre(AllOf(Written("\"foo.h\""), HasPragmaKeep(false)),
-                           AllOf(Written("\"bar.h\""), HasPragmaKeep(true))));
+      UnorderedElementsAre(AllOf(written("\"foo.h\""), hasPragmaKeep(false)),
+                           AllOf(written("\"bar.h\""), hasPragmaKeep(true))));
 }
 
 TEST_F(HeadersTest, InsertInclude) {
   std::string Path = testPath("sub/bar.h");
   FS.Files[Path] = "";
   EXPECT_EQ(calculate(Path), "\"bar.h\"");
 }
 
TEST_F(HeadersTest, PresumedLocations) {
   HeaderContents += R"cpp(
 #line 3
 #include <a.h>)cpp";
   FS.Files[HeaderFile] = HeaderContents;
 
   // Including through non-builtin file has no effects.
   FS.Files[MainFile] = "#include \"__preamble_patch__.h\"\n\n";
   EXPECT_THAT(collectIncludes().MainFileIncludes,
-              Not(Contains(Written("<a.h>"))));
+              Not(Contains(written("<a.h>"))));
 
   // Now include through built-in file.
   CDB.ExtraClangFlags = {"-include", testPath(HeaderFile)};
   EXPECT_THAT(collectIncludes().MainFileIncludes,
-              Contains(AllOf(IncludeLine(2), Written("<a.h>"))));
+              Contains(AllOf(includeLine(2), written("<a.h>"))));
 }
 
 TEST_F(HeadersTest, SelfContainedHeaders) {
   // Including through non-builtin file has no effects.
   FS.Files[MainFile] = R"cpp(
 #include "includeguarded.h"
 #include "nonguarded.h"
 #include "pp_depend.h"
auto TU = TestTU::withCode(R"cpp(
 
     class vector {};
     std::vector<int> vec;
     std::vector<int>::nested nest;
     std::secret sec;
   )cpp");
 
   auto AST = TU.build();
-  auto &vector_nonstd = findDecl(AST, "vector");
-  auto *vec =
+  auto &VectorNonstd = findDecl(AST, "vector");
+  auto *Vec =
       cast<VarDecl>(findDecl(AST, "vec")).getType()->getAsCXXRecordDecl();
-  auto *nest =
+  auto *Nest =
       cast<VarDecl>(findDecl(AST, "nest")).getType()->getAsCXXRecordDecl();
-  auto *sec =
+  auto *Sec =
       cast<VarDecl>(findDecl(AST, "sec")).getType()->getAsCXXRecordDecl();
 
-  stdlib::Recognizer recognizer;
+  stdlib::Recognizer Recognizer;
 
-  EXPECT_EQ(recognizer(&vector_nonstd), llvm::None);
-  EXPECT_EQ(recognizer(vec), stdlib::Symbol::named("std::", "vector"));
-  EXPECT_EQ(recognizer(nest), stdlib::Symbol::named("std::", "vector"));
-  EXPECT_EQ(recognizer(sec), llvm::None);
+  EXPECT_EQ(Recognizer(&VectorNonstd), llvm::None);
+  EXPECT_EQ(Recognizer(Vec), stdlib::Symbol::named("std::", "vector"));
+  EXPECT_EQ(Recognizer(Nest), stdlib::Symbol::named("std::", "vector"));
+  EXPECT_EQ(Recognizer(Sec), llvm::None);
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

for (const auto &Test : Tests) {
     ReferencedLocations Locs = findReferencedLocations(AST);
     EXPECT_THAT(Locs.Stdlib, ElementsAreArray(WantSyms));
     ReferencedFiles Files = findReferencedFiles(Locs, AST.getIncludeStructure(),
                                                 AST.getSourceManager());
     EXPECT_THAT(Files.Stdlib, ElementsAreArray(WantHeaders));
   }
 }
 
-MATCHER_P(WrittenInclusion, Written, "") {
+MATCHER_P(writtenInclusion, Written, "") {
   if (arg.Written != Written)
     *result_listener << arg.Written;
   return arg.Written == Written;
 }
 
 TEST(IncludeCleaner, StdlibUnused) {
   setIncludeCleanerAnalyzesStdlib(true);
   auto Cleanup =
TU.AdditionalFiles["bits"] = R"cpp(
     }
   )cpp";
   TU.AdditionalFiles["list"] = "#include <bits>";
   TU.AdditionalFiles["queue"] = "#include <bits>";
   TU.ExtraArgs = {"-isystem", testRoot()};
   auto AST = TU.build();
 
   auto Unused = computeUnusedIncludes(AST);
-  EXPECT_THAT(Unused, ElementsAre(Pointee(WrittenInclusion("<queue>"))));
+  EXPECT_THAT(Unused, ElementsAre(Pointee(writtenInclusion("<queue>"))));
 }
 
 TEST(IncludeCleaner, GetUnusedHeaders) {
   llvm::StringLiteral MainFile = R"cpp(
     #include "a.h"
     #include "b.h"
     #include "dir/c.h"
     #include "dir/unused.h"

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

 using ::testing::EndsWith;
 using ::testing::Not;
 using ::testing::Pair;
 using ::testing::UnorderedElementsAre;
 using ::testing::UnorderedPointwise;
 
 std::string toUri(llvm::StringRef Path) { return URI::create(Path).toString(); }
 
-MATCHER(IsTU, "") { return arg.Flags & IncludeGraphNode::SourceFlag::IsTU; }
+MATCHER(isTU, "") { return arg.Flags & IncludeGraphNode::SourceFlag::IsTU; }
 
-MATCHER_P(HasDigest, Digest, "") { return arg.Digest == Digest; }
+MATCHER_P(hasDigest, Digest, "") { return arg.Digest == Digest; }
 
-MATCHER_P(HasName, Name, "") { return arg.Name == Name; }
+MATCHER_P(hasName, Name, "") { return arg.Name == Name; }
 
-MATCHER(HasSameURI, "") {
+MATCHER(hasSameURI, "") {
   llvm::StringRef URI = ::testing::get<0>(arg);
   const std::string &Path = ::testing::get<1>(arg);
   return toUri(Path) == URI;
 }
 
 ::testing::Matcher<const IncludeGraphNode &>
-IncludesAre(const std::vector<std::string> &Includes) {
+includesAre(const std::vector<std::string> &Includes) {
   return ::testing::Field(&IncludeGraphNode::DirectIncludes,
-                          UnorderedPointwise(HasSameURI(), Includes));
+                          UnorderedPointwise(hasSameURI(), Includes));
 }
 
 void checkNodesAreInitialized(const IndexFileIn &IndexFile,
                               const std::vector<std::string> &Paths) {
   ASSERT_TRUE(IndexFile.Sources);
   EXPECT_THAT(Paths.size(), IndexFile.Sources->size());
   for (llvm::StringRef Path : Paths) {
     auto URI = toUri(Path);
TEST_F(IndexActionTest, CollectIncludeGraph) {
   addFile(Level2HeaderPath, Level2HeaderCode);
 
   IndexFileIn IndexFile = runIndexingAction(MainFilePath);
   auto Nodes = toMap(*IndexFile.Sources);
 
   EXPECT_THAT(Nodes,
               UnorderedElementsAre(
                   Pair(toUri(MainFilePath),
-                       AllOf(IsTU(), IncludesAre({Level1HeaderPath}),
-                             HasDigest(digest(MainCode)))),
+                       AllOf(isTU(), includesAre({Level1HeaderPath}),
+                             hasDigest(digest(MainCode)))),
                   Pair(toUri(Level1HeaderPath),
-                       AllOf(Not(IsTU()), IncludesAre({Level2HeaderPath}),
-                             HasDigest(digest(Level1HeaderCode)))),
+                       AllOf(Not(isTU()), includesAre({Level2HeaderPath}),
+                             hasDigest(digest(Level1HeaderCode)))),
                   Pair(toUri(Level2HeaderPath),
-                       AllOf(Not(IsTU()), IncludesAre({}),
-                             HasDigest(digest(Level2HeaderCode))))));
+                       AllOf(Not(isTU()), includesAre({}),
+                             hasDigest(digest(Level2HeaderCode))))));
 }
 
 TEST_F(IndexActionTest, IncludeGraphSelfInclude) {
   std::string MainFilePath = testPath("main.cpp");
   std::string MainCode = "#include \"header.h\"";
   std::string HeaderPath = testPath("header.h");
   std::string HeaderCode = R"cpp(
       #ifndef _GUARD_
       #define _GUARD_
       #include "header.h"
       #endif)cpp";
 
   addFile(MainFilePath, MainCode);
   addFile(HeaderPath, HeaderCode);
 
   IndexFileIn IndexFile = runIndexingAction(MainFilePath);
   auto Nodes = toMap(*IndexFile.Sources);
 
   EXPECT_THAT(
       Nodes,
       UnorderedElementsAre(
-          Pair(toUri(MainFilePath), AllOf(IsTU(), IncludesAre({HeaderPath}),
-                                          HasDigest(digest(MainCode)))),
-          Pair(toUri(HeaderPath), AllOf(Not(IsTU()), IncludesAre({HeaderPath}),
-                                        HasDigest(digest(HeaderCode))))));
+          Pair(toUri(MainFilePath), AllOf(isTU(), includesAre({HeaderPath}),
+                                          hasDigest(digest(MainCode)))),
+          Pair(toUri(HeaderPath), AllOf(Not(isTU()), includesAre({HeaderPath}),
+                                        hasDigest(digest(HeaderCode))))));
 }
 
 TEST_F(IndexActionTest, IncludeGraphSkippedFile) {
   std::string MainFilePath = testPath("main.cpp");
   std::string MainCode = R"cpp(
       #include "common.h"
       #include "header.h"
       )cpp";
TEST_F(IndexActionTest, IncludeGraphSkippedFile) {
   addFile(CommonHeaderPath, CommonHeaderCode);
 
   IndexFileIn IndexFile = runIndexingAction(MainFilePath);
   auto Nodes = toMap(*IndexFile.Sources);
 
   EXPECT_THAT(
       Nodes, UnorderedElementsAre(
                  Pair(toUri(MainFilePath),
-                      AllOf(IsTU(), IncludesAre({HeaderPath, CommonHeaderPath}),
-                            HasDigest(digest(MainCode)))),
+                      AllOf(isTU(), includesAre({HeaderPath, CommonHeaderPath}),
+                            hasDigest(digest(MainCode)))),
                  Pair(toUri(HeaderPath),
-                      AllOf(Not(IsTU()), IncludesAre({CommonHeaderPath}),
-                            HasDigest(digest(HeaderCode)))),
+                      AllOf(Not(isTU()), includesAre({CommonHeaderPath}),
+                            hasDigest(digest(HeaderCode)))),
                  Pair(toUri(CommonHeaderPath),
-                      AllOf(Not(IsTU()), IncludesAre({}),
-                            HasDigest(digest(CommonHeaderCode))))));
+                      AllOf(Not(isTU()), includesAre({}),
+                            hasDigest(digest(CommonHeaderCode))))));
 }
 
 TEST_F(IndexActionTest, IncludeGraphDynamicInclude) {
   std::string MainFilePath = testPath("main.cpp");
   std::string MainCode = R"cpp(
       #ifndef FOO
       #define FOO "main.cpp"
       #else
TEST_F(IndexActionTest, IncludeGraphDynamicInclude) {
 
   IndexFileIn IndexFile = runIndexingAction(MainFilePath);
   auto Nodes = toMap(*IndexFile.Sources);
 
   EXPECT_THAT(
       Nodes,
       UnorderedElementsAre(
           Pair(toUri(MainFilePath),
-               AllOf(IsTU(), IncludesAre({MainFilePath, HeaderPath}),
-                     HasDigest(digest(MainCode)))),
-          Pair(toUri(HeaderPath), AllOf(Not(IsTU()), IncludesAre({}),
-                                        HasDigest(digest(HeaderCode))))));
+               AllOf(isTU(), includesAre({MainFilePath, HeaderPath}),
+                     hasDigest(digest(MainCode)))),
+          Pair(toUri(HeaderPath), AllOf(Not(isTU()), includesAre({}),
+                                        hasDigest(digest(HeaderCode))))));
 }
 
 TEST_F(IndexActionTest, NoWarnings) {
   std::string MainFilePath = testPath("main.cpp");
   std::string MainCode = R"cpp(
       void foo(int x) {
         if (x = 1) // -Wparentheses
           return;
         if (x = 1) // -Wparentheses
           return;
       }
       void bar() {}
   )cpp";
   addFile(MainFilePath, MainCode);
   // We set -ferror-limit so the warning-promoted-to-error would be fatal.
   // This would cause indexing to stop (if warnings weren't disabled).
   IndexFileIn IndexFile = runIndexingAction(
       MainFilePath, {"-ferror-limit=1", "-Wparentheses", "-Werror"});
   ASSERT_TRUE(IndexFile.Sources);
   ASSERT_NE(0u, IndexFile.Sources->size());
-  EXPECT_THAT(*IndexFile.Symbols, ElementsAre(HasName("foo"), HasName("bar")));
+  EXPECT_THAT(*IndexFile.Symbols, ElementsAre(hasName("foo"), hasName("bar")));
 }
 
 TEST_F(IndexActionTest, SkipFiles) {
   std::string MainFilePath = testPath("main.cpp");
   addFile(MainFilePath, R"cpp(
     // clang-format off
     #include "good.h"
     #include "bad.h"
addFile(testPath("bad.h"), R"cpp(
     void f2() { S f; }
     auto unskippable2() { return S(); }
   )cpp");
   Opts.FileFilter = [](const SourceManager &SM, FileID F) {
     return !SM.getFileEntryForID(F)->getName().endswith("bad.h");
   };
   IndexFileIn IndexFile = runIndexingAction(MainFilePath, {"-std=c++14"});
   EXPECT_THAT(*IndexFile.Symbols,
-              UnorderedElementsAre(HasName("S"), HasName("s"), HasName("f1"),
-                                   HasName("unskippable1")));
+              UnorderedElementsAre(hasName("S"), hasName("s"), hasName("f1"),
+                                   hasName("unskippable1")));
   for (const auto &Pair : *IndexFile.Refs)
     for (const auto &Ref : Pair.second)
       EXPECT_THAT(Ref.Location.FileURI, EndsWith("good.h"));
 }
 
 TEST_F(IndexActionTest, SkipNestedSymbols) {
   std::string MainFilePath = testPath("main.cpp");
   addFile(MainFilePath, R"cpp(
TEST_F(IndexActionTest, SkipNestedSymbols) {
   }
   }
   }
   }
   }
   }
   })cpp");
   IndexFileIn IndexFile = runIndexingAction(MainFilePath, {"-std=c++14"});
-  EXPECT_THAT(*IndexFile.Symbols, testing::Contains(HasName("foo")));
-  EXPECT_THAT(*IndexFile.Symbols, testing::Contains(HasName("Bar")));
-  EXPECT_THAT(*IndexFile.Symbols, Not(testing::Contains(HasName("Baz"))));
+  EXPECT_THAT(*IndexFile.Symbols, testing::Contains(hasName("foo")));
+  EXPECT_THAT(*IndexFile.Symbols, testing::Contains(hasName("Bar")));
+  EXPECT_THAT(*IndexFile.Symbols, Not(testing::Contains(hasName("Baz"))));
 }
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 using ::testing::Pair;
 using ::testing::Pointee;
 using ::testing::UnorderedElementsAre;
 
 namespace clang {
 namespace clangd {
 namespace {
 
-MATCHER_P(Named, N, "") { return arg.Name == N; }
-MATCHER_P(RefRange, Range, "") {
+MATCHER_P(named, N, "") { return arg.Name == N; }
+MATCHER_P(refRange, Range, "") {
   return std::make_tuple(arg.Location.Start.line(), arg.Location.Start.column(),
                          arg.Location.End.line(), arg.Location.End.column()) ==
          std::make_tuple(Range.start.line, Range.start.character,
                          Range.end.line, Range.end.character);
 }
-MATCHER_P(FileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
+MATCHER_P(fileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
 
 TEST(SymbolLocation, Position) {
   using Position = SymbolLocation::Position;
   Position Pos;
 
   Pos.setLine(1);
   EXPECT_EQ(1u, Pos.line());
   Pos.setColumn(2);

 
 TEST(SymbolSlab, FindAndIterate) {
   SymbolSlab::Builder B;
   B.insert(symbol("Z"));
   B.insert(symbol("Y"));
   B.insert(symbol("X"));
   EXPECT_EQ(nullptr, B.find(SymbolID("W")));
   for (const char *Sym : {"X", "Y", "Z"})
-    EXPECT_THAT(B.find(SymbolID(Sym)), Pointee(Named(Sym)));
+    EXPECT_THAT(B.find(SymbolID(Sym)), Pointee(named(Sym)));
 
   SymbolSlab S = std::move(B).build();
-  EXPECT_THAT(S, UnorderedElementsAre(Named("X"), Named("Y"), Named("Z")));
+  EXPECT_THAT(S, UnorderedElementsAre(named("X"), named("Y"), named("Z")));
   EXPECT_EQ(S.end(), S.find(SymbolID("W")));
   for (const char *Sym : {"X", "Y", "Z"})
-    EXPECT_THAT(*S.find(SymbolID(Sym)), Named(Sym));
+    EXPECT_THAT(*S.find(SymbolID(Sym)), named(Sym));
 }
 
 TEST(RelationSlab, Lookup) {
   SymbolID A{"A"};
   SymbolID B{"B"};
   SymbolID C{"C"};
   SymbolID D{"D"};
 
TEST(MergeIndexTest, Refs) {
   RefsRequest Request;
   Request.IDs = {Foo.ID};
   RefSlab::Builder Results;
   EXPECT_FALSE(
       Merge.refs(Request, [&](const Ref &O) { Results.insert(Foo.ID, O); }));
   EXPECT_THAT(
       std::move(Results).build(),
       ElementsAre(Pair(
-          _, UnorderedElementsAre(AllOf(RefRange(Test1Code.range("Foo")),
-                                        FileURI("unittest:///test.cc")),
-                                  AllOf(RefRange(Test2Code.range("Foo")),
-                                        FileURI("unittest:///test2.cc"))))));
+          _, UnorderedElementsAre(AllOf(refRange(Test1Code.range("Foo")),
+                                        fileURI("unittest:///test.cc")),
+                                  AllOf(refRange(Test2Code.range("Foo")),
+                                        fileURI("unittest:///test2.cc"))))));
 
   Request.Limit = 1;
   RefSlab::Builder Results2;
   EXPECT_TRUE(
       Merge.refs(Request, [&](const Ref &O) { Results2.insert(Foo.ID, O); }));
 
   // Remove all refs for test.cc from dynamic index,
   // merged index should not return results from static index for test.cc.
   Test.Code = "";
   AST = Test.build();
   Dyn.updateMain(testPath(Test.Filename), AST);
 
   Request.Limit = llvm::None;
   RefSlab::Builder Results3;
   EXPECT_FALSE(
       Merge.refs(Request, [&](const Ref &O) { Results3.insert(Foo.ID, O); }));
   EXPECT_THAT(std::move(Results3).build(),
               ElementsAre(Pair(_, UnorderedElementsAre(AllOf(
-                                      RefRange(Test2Code.range("Foo")),
-                                      FileURI("unittest:///test2.cc"))))));
+                                      refRange(Test2Code.range("Foo")),
+                                      fileURI("unittest:///test2.cc"))))));
 }
 
 TEST(MergeIndexTest, IndexedFiles) {
   SymbolSlab DynSymbols;
   RefSlab DynRefs;
   auto DynSize = DynSymbols.bytes() + DynRefs.bytes();
   auto DynData = std::make_pair(std::move(DynSymbols), std::move(DynRefs));
   llvm::StringSet<> DynFiles = {"unittest:///foo.cc"};

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

std::unique_ptr<Transport> transport(std::string InData, bool Pretty,
                                        JSONStreamStyle Style) {
     InBuf = std::move(InData);
     In = {fmemopen(&InBuf[0], InBuf.size(), "r"), &fclose};
     return newJSONTransport(In.get(), Out, &Mirror, Pretty, Style);
   }
 
   std::string input() const { return InBuf; }
   std::string output() { return Out.str(); }
-  std::string input_mirror() { return Mirror.str(); }
+  std::string inputMirror() { return Mirror.str(); }
 };
 
 // Echo is a simple server running on a transport:
 //   - logs each message it gets.
 //   - when it gets a call, replies to it
 //   - when it gets a notification for method "call", makes a call on Target
 // Hangs up when it gets an exit notification.
 class Echo : public Transport::MessageHandler {
Notification exit: null
   const char *WantOutput =
       "Content-Length: 60\r\n\r\n"
       R"({"id":42,"jsonrpc":"2.0","method":"echo call","params":1234})"
       "Content-Length: 45\r\n\r\n"
       R"({"id":"abcd","jsonrpc":"2.0","result":"efgh"})"
       "Content-Length: 77\r\n\r\n"
       R"({"error":{"code":88,"message":"trouble at mill"},"id":"wxyz","jsonrpc":"2.0"})";
   EXPECT_EQ(output(), WantOutput);
-  EXPECT_EQ(trim(input_mirror()), trim(input()));
+  EXPECT_EQ(trim(inputMirror()), trim(input()));
 }
 
 // Runs an Echo session using the "delimited" input and pretty-printed output
 // that we use in lit tests.
 TEST_F(JSONTransportTest, DelimitedPretty) {
   auto T = transport(R"jsonrpc(
 {"jsonrpc": "2.0", "method": "call", "params": 1234}
 ---
Notification exit: null
   "error": {
     "code": -32801,
     "message": "Request cancelled because the document was modified"
   },
   "id": "wxyz",
   "jsonrpc": "2.0"
 })";
   EXPECT_EQ(output(), WantOutput);
-  EXPECT_EQ(trim(input_mirror()), trim(input()));
+  EXPECT_EQ(trim(inputMirror()), trim(input()));
 }
 
 // IO errors such as EOF ane reported.
 // The only successful return from loop() is if a handler returned false.
 TEST_F(JSONTransportTest, EndOfFile) {
   auto T = transport("Content-Length: 52\r\n\r\n"
                      R"({"jsonrpc": "2.0", "method": "call", "params": 1234})",
                      /*Pretty=*/false, JSONStreamStyle::Standard);
   Echo E(*T);
   auto Err = T->loop(E);
   EXPECT_EQ(trim(E.log()), "Notification call: 1234");
   EXPECT_TRUE(bool(Err)); // Ran into EOF with no handler signalling done.
   consumeError(std::move(Err));
-  EXPECT_EQ(trim(input_mirror()), trim(input()));
+  EXPECT_EQ(trim(inputMirror()), trim(input()));
 }
 
 #endif
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 
 using ::testing::AllOf;
 using ::testing::Contains;
 using ::testing::ElementsAre;
 using ::testing::ElementsAreArray;
 using ::testing::IsEmpty;
 using ::testing::UnorderedElementsAreArray;
 
-MATCHER_P(DeclNamed, Name, "") {
+MATCHER_P(declNamed, Name, "") {
   if (NamedDecl *ND = dyn_cast<NamedDecl>(arg))
     if (ND->getName() == Name)
       return true;
   if (auto *Stream = result_listener->stream()) {
     llvm::raw_os_ostream OS(*Stream);
     arg->dump(OS);
   }
   return false;
 }
 
-MATCHER_P(DeclKind, Kind, "") {
+MATCHER_P(declKind, Kind, "") {
   if (NamedDecl *ND = dyn_cast<NamedDecl>(arg))
     if (ND->getDeclKindName() == llvm::StringRef(Kind))
       return true;
   if (auto *Stream = result_listener->stream()) {
     llvm::raw_os_ostream OS(*Stream);
     arg->dump(OS);
   }
   return false;
 }
 
 // Matches if the Decl has template args equal to ArgName. If the decl is a
 // NamedDecl and ArgName is an empty string it also matches.
-MATCHER_P(WithTemplateArgs, ArgName, "") {
+MATCHER_P(withTemplateArgs, ArgName, "") {
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(arg)) {
     if (const auto *Args = FD->getTemplateSpecializationArgs()) {
       std::string SpecializationArgs;
       // Without the PrintingPolicy "bool" will be printed as "_Bool".
       LangOptions LO;
       PrintingPolicy Policy(LO);
       Policy.adjustForCPlusPlus();
       for (const auto &Arg : Args->asArray()) {
         if (SpecializationArgs.size() > 0)
           SpecializationArgs += ",";
         SpecializationArgs += Arg.getAsType().getAsString(Policy);
       }
       if (Args->size() == 0)
         return ArgName == SpecializationArgs;
       return ArgName == "<" + SpecializationArgs + ">";
     }
   }
   if (const NamedDecl *ND = dyn_cast<NamedDecl>(arg))
     return printTemplateSpecializationArgs(*ND) == ArgName;
   return false;
 }
 
-MATCHER_P(RangeIs, R, "") {
+MATCHER_P(rangeIs, R, "") {
   return arg.beginOffset() == R.Begin && arg.endOffset() == R.End;
 }
 
-MATCHER_P(PragmaTrivia, P, "") { return arg.Trivia == P; }
+MATCHER_P(pragmaTrivia, P, "") { return arg.Trivia == P; }
 
-MATCHER(EqInc, "") {
+MATCHER(eqInc, "") {
   Inclusion Actual = testing::get<0>(arg);
   Inclusion Expected = testing::get<1>(arg);
   return std::tie(Actual.HashLine, Actual.Written) ==
          std::tie(Expected.HashLine, Expected.Written);
 }
 
 TEST(ParsedASTTest, TopLevelDecls) {
   TestTU TU;
   TU.HeaderCode = R"(
     int header1();
     int header2;
   )";
   TU.Code = R"cpp(
     int main();
     template <typename> bool X = true;
   )cpp";
   auto AST = TU.build();
   EXPECT_THAT(AST.getLocalTopLevelDecls(),
               testing::UnorderedElementsAreArray(
-                  {AllOf(DeclNamed("main"), DeclKind("Function")),
-                   AllOf(DeclNamed("X"), DeclKind("VarTemplate"))}));
+                  {AllOf(declNamed("main"), declKind("Function")),
+                   AllOf(declNamed("X"), declKind("VarTemplate"))}));
 }
 
 TEST(ParsedASTTest, DoesNotGetIncludedTopDecls) {
   TestTU TU;
   TU.HeaderCode = R"cpp(
     #define LL void foo(){}
     template<class T>
     struct H {
       H() {}
       LL
     };
   )cpp";
   TU.Code = R"cpp(
     int main() {
       H<int> h;
       h.foo();
     }
   )cpp";
   auto AST = TU.build();
-  EXPECT_THAT(AST.getLocalTopLevelDecls(), ElementsAre(DeclNamed("main")));
+  EXPECT_THAT(AST.getLocalTopLevelDecls(), ElementsAre(declNamed("main")));
 }
 
 TEST(ParsedASTTest, DoesNotGetImplicitTemplateTopDecls) {
   TestTU TU;
   TU.Code = R"cpp(
     template<typename T>
     void f(T) {}
     void s() {
       f(10UL);
     }
   )cpp";
 
   auto AST = TU.build();
   EXPECT_THAT(AST.getLocalTopLevelDecls(),
-              ElementsAre(DeclNamed("f"), DeclNamed("s")));
+              ElementsAre(declNamed("f"), declNamed("s")));
 }
 
 TEST(ParsedASTTest,
      GetsExplicitInstantiationAndSpecializationTemplateTopDecls) {
   TestTU TU;
   TU.Code = R"cpp(
     template <typename T>
     void f(T) {}
TU.Code = R"cpp(
     int foo<T*> = 0;
     template <>
     int foo<bool> = 0;
   )cpp";
 
   auto AST = TU.build();
   EXPECT_THAT(
       AST.getLocalTopLevelDecls(),
-      ElementsAreArray({AllOf(DeclNamed("f"), WithTemplateArgs("")),
-                        AllOf(DeclNamed("f"), WithTemplateArgs("<bool>")),
-                        AllOf(DeclNamed("f"), WithTemplateArgs("<double>")),
-                        AllOf(DeclNamed("V"), WithTemplateArgs("")),
-                        AllOf(DeclNamed("V"), WithTemplateArgs("<T *>")),
-                        AllOf(DeclNamed("V"), WithTemplateArgs("<bool>")),
-                        AllOf(DeclNamed("foo"), WithTemplateArgs("")),
-                        AllOf(DeclNamed("i"), WithTemplateArgs("")),
-                        AllOf(DeclNamed("d"), WithTemplateArgs("")),
-                        AllOf(DeclNamed("foo"), WithTemplateArgs("<T *>")),
-                        AllOf(DeclNamed("foo"), WithTemplateArgs("<bool>"))}));
+      ElementsAreArray({AllOf(declNamed("f"), withTemplateArgs("")),
+                        AllOf(declNamed("f"), withTemplateArgs("<bool>")),
+                        AllOf(declNamed("f"), withTemplateArgs("<double>")),
+                        AllOf(declNamed("V"), withTemplateArgs("")),
+                        AllOf(declNamed("V"), withTemplateArgs("<T *>")),
+                        AllOf(declNamed("V"), withTemplateArgs("<bool>")),
+                        AllOf(declNamed("foo"), withTemplateArgs("")),
+                        AllOf(declNamed("i"), withTemplateArgs("")),
+                        AllOf(declNamed("d"), withTemplateArgs("")),
+                        AllOf(declNamed("foo"), withTemplateArgs("<T *>")),
+                        AllOf(declNamed("foo"), withTemplateArgs("<bool>"))}));
 }
 
 TEST(ParsedASTTest, IgnoresDelayedTemplateParsing) {
   auto TU = TestTU::withCode(R"cpp(
     template <typename T> void xxx() {
       int yyy = 0;
     }
   )cpp");
for (const auto &R : SIDToRefs.second)
       MacroExpansionPositions.push_back(R.Rng.start);
   }
   for (const auto &R : AST.getMacros().UnknownMacros)
     MacroExpansionPositions.push_back(R.Rng.start);
   EXPECT_THAT(MacroExpansionPositions,
               testing::UnorderedElementsAreArray(TestCase.points()));
 }
 
-MATCHER_P(WithFileName, Inc, "") { return arg.FileName == Inc; }
+MATCHER_P(withFileName, Inc, "") { return arg.FileName == Inc; }
 
 TEST(ParsedASTTest, ReplayPreambleForTidyCheckers) {
   struct Inclusion {
     Inclusion(const SourceManager &SM, SourceLocation HashLoc,
               const Token &IncludeTok, llvm::StringRef FileName, bool IsAngled,
               CharSourceRange FilenameRange)
         : HashOffset(SM.getDecomposedLoc(HashLoc).second), IncTok(IncludeTok),
           IncDirective(IncludeTok.getIdentifierInfo()->getName()),
TEST(ParsedASTTest, ReplayPreambleForTidyCheckers) {
 
   ASSERT_EQ(SkippedFiles.size(), Includes.size());
   for (size_t I = 0; I < Includes.size(); ++I) {
     const auto &Inc = Includes[I];
 
     EXPECT_EQ(Inc.HashOffset, HashLocs[I]);
 
     auto IncRange = IncludeRanges[I];
-    EXPECT_THAT(Inc.IncTok.range(SM), RangeIs(IncRange));
+    EXPECT_THAT(Inc.IncTok.range(SM), rangeIs(IncRange));
     EXPECT_EQ(Inc.IncTok.kind(), tok::identifier);
     EXPECT_EQ(Inc.IncDirective,
               Code.substr(IncRange.Begin, IncRange.End - IncRange.Begin));
 
     EXPECT_EQ(Inc.FileNameOffset, FileBeginLocs[I]);
     EXPECT_EQ(Inc.IsAngled, Code[FileBeginLocs[I]] == '<');
 
     auto FileRange = FileRanges[I];
TEST(ParsedASTTest, PatchesAdditionalIncludes) {
   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));
+                  eqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
   // Ensure file proximity signals are correct.
   auto &SM = PatchedAST->getSourceManager();
   auto &FM = SM.getFileManager();
   // Copy so that we can use operator[] to get the children.
   IncludeStructure Includes = PatchedAST->getIncludeStructure();
   auto MainFE = FM.getFile(testPath("foo.cpp"));
   ASSERT_TRUE(MainFE);
   auto MainID = Includes.getID(*MainFE);
TEST(ParsedASTTest, PatchesDeletedIncludes) {
   Inputs = TU.inputs(FS);
   auto PatchedAST = ParsedAST::build(testPath("foo.cpp"), Inputs, std::move(CI),
                                      {}, BaselinePreamble);
   ASSERT_TRUE(PatchedAST);
 
   // Ensure source location information is correct.
   EXPECT_THAT(PatchedAST->getIncludeStructure().MainFileIncludes,
               testing::Pointwise(
-                  EqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
+                  eqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
   // Ensure file proximity signals are correct.
   auto &SM = ExpectedAST.getSourceManager();
   auto &FM = SM.getFileManager();
   // Copy so that we can getOrCreateID().
   IncludeStructure Includes = ExpectedAST.getIncludeStructure();
   auto MainFE = FM.getFile(testPath("foo.cpp"));
   ASSERT_TRUE(MainFE);
   auto MainID = Includes.getOrCreateID(*MainFE);

 bool mainIsGuarded(const ParsedAST &AST) {
   const auto &SM = AST.getSourceManager();
   const FileEntry *MainFE = SM.getFileEntryForID(SM.getMainFileID());
   return AST.getPreprocessor()
       .getHeaderSearchInfo()
       .isFileMultipleIncludeGuarded(MainFE);
 }
 
-MATCHER_P(Diag, Desc, "") {
+MATCHER_P(diag, Desc, "") {
   return llvm::StringRef(arg.Message).contains(Desc);
 }
 
 // Check our understanding of whether the main file is header guarded or not.
 TEST(ParsedASTTest, HeaderGuards) {
   TestTU TU;
   TU.ImplicitHeaderGuard = false;
 
TEST(ParsedASTTest, HeaderGuardsSelfInclude) {
   TU.Filename = "self.h";
 
   TU.Code = R"cpp(
     #include "self.h" // error-ok
     ;
   )cpp";
   auto AST = TU.build();
   EXPECT_THAT(*AST.getDiagnostics(),
-              ElementsAre(Diag("recursively when building a preamble")));
+              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();
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(),
-              ElementsAre(Diag("recursively when building a preamble")));
+              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_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(),
-              ElementsAre(Diag("recursively when building a preamble")));
+              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(),
-              ElementsAre(Diag("recursively when building a preamble")));
+              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_FALSE(mainIsGuarded(AST));
 
   TU.Code = R"cpp(
     #include "self.h" // error-ok
     #pragma once
     ;
   )cpp";
   AST = TU.build();
   EXPECT_THAT(*AST.getDiagnostics(),
-              ElementsAre(Diag("recursively when building a preamble")));
+              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(),
-              ElementsAre(Diag("recursively when building a preamble")));
+              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) {
TEST(ParsedASTTest, HeaderGuardsImplIface) {
   // 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(),
-              ElementsAre(Diag("in included file: main file cannot be included "
+              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(),
-              ElementsAre(Diag("in included file: main file cannot be included "
+              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"(
     #pragma mark - Something API
     int something();
     #pragma mark Something else
   )";
   TU.Code = R"cpp(
     #include "Header.h"
     #pragma mark In Preamble
     #pragma mark - Something Impl
     int something() { return 1; }
     #pragma mark End
   )cpp";
   auto AST = TU.build();
 
-  EXPECT_THAT(AST.getMarks(), ElementsAre(PragmaTrivia(" In Preamble"),
-                                          PragmaTrivia(" - Something Impl"),
-                                          PragmaTrivia(" End")));
+  EXPECT_THAT(AST.getMarks(), ElementsAre(pragmaTrivia(" In Preamble"),
+                                          pragmaTrivia(" - Something Impl"),
+                                          pragmaTrivia(" End")));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

TEST(QualityTests, SymbolRelevanceSignalExtraction) {
   Relevance = {};
   Relevance.merge(CodeCompletionResult(&findDecl(AST, "header"), 42));
   EXPECT_FLOAT_EQ(Relevance.SemaFileProximityScore, 0.6f) << "Decl from header";
   Relevance = {};
   Relevance.merge(CodeCompletionResult(&findDecl(AST, "header_main"), 42));
   EXPECT_FLOAT_EQ(Relevance.SemaFileProximityScore, 1.0f)
       << "Current file and header";
 
-  auto constructShadowDeclCompletionResult = [&](const std::string DeclName) {
+  auto ConstructShadowDeclCompletionResult = [&](const std::string DeclName) {
     auto *Shadow =
         *dyn_cast<UsingDecl>(&findDecl(AST, [&](const NamedDecl &ND) {
            if (const UsingDecl *Using = dyn_cast<UsingDecl>(&ND))
              if (Using->shadow_size() &&
                  Using->getQualifiedNameAsString() == DeclName)
                return true;
            return false;
          }))->shadow_begin();
     CodeCompletionResult Result(Shadow->getTargetDecl(), 42);
     Result.ShadowDecl = Shadow;
     return Result;
   };
 
   Relevance = {};
-  Relevance.merge(constructShadowDeclCompletionResult("Bar"));
+  Relevance.merge(ConstructShadowDeclCompletionResult("Bar"));
   EXPECT_FLOAT_EQ(Relevance.SemaFileProximityScore, 1.0f)
       << "Using declaration in main file";
-  Relevance.merge(constructShadowDeclCompletionResult("FLAGS_FOO"));
+  Relevance.merge(ConstructShadowDeclCompletionResult("FLAGS_FOO"));
   EXPECT_FLOAT_EQ(Relevance.SemaFileProximityScore, 1.0f)
       << "Using declaration in main file";
 
   Relevance = {};
   Relevance.merge(CodeCompletionResult(&findUnqualifiedDecl(AST, "X"), 42));
   EXPECT_EQ(Relevance.Scope, SymbolRelevanceSignals::FileScope);
   Relevance = {};
   Relevance.merge(CodeCompletionResult(&findUnqualifiedDecl(AST, "y"), 42));

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

 Flags:           1
 Digest:          EED8F5EAF25C453C
 DirectIncludes:
   - 'file:///path/inc1.h'
   - 'file:///path/inc2.h'
 ...
 )";
 
-MATCHER_P(ID, I, "") { return arg.ID == cantFail(SymbolID::fromStr(I)); }
-MATCHER_P(QName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
+MATCHER_P(iD, I, "") { return arg.ID == cantFail(SymbolID::fromStr(I)); }
+MATCHER_P(qName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
 MATCHER_P2(IncludeHeaderWithRef, IncludeHeader, References, "") {
   return (arg.IncludeHeader == IncludeHeader) && (arg.References == References);
 }
 
 auto readIndexFile(llvm::StringRef Text) {
   return readIndexFile(Text, SymbolOrigin::Static);
 }
 
 TEST(SerializationTest, NoCrashOnEmptyYAML) {
   EXPECT_TRUE(bool(readIndexFile("")));
 }
 
 TEST(SerializationTest, YAMLConversions) {
   auto ParsedYAML = readIndexFile(YAML);
   ASSERT_TRUE(bool(ParsedYAML)) << ParsedYAML.takeError();
   ASSERT_TRUE(bool(ParsedYAML->Symbols));
   EXPECT_THAT(
       *ParsedYAML->Symbols,
-      UnorderedElementsAre(ID("057557CEBF6E6B2D"), ID("057557CEBF6E6B2E")));
+      UnorderedElementsAre(iD("057557CEBF6E6B2D"), iD("057557CEBF6E6B2E")));
 
   auto Sym1 = *ParsedYAML->Symbols->find(
       cantFail(SymbolID::fromStr("057557CEBF6E6B2D")));
   auto Sym2 = *ParsedYAML->Symbols->find(
       cantFail(SymbolID::fromStr("057557CEBF6E6B2E")));
 
-  EXPECT_THAT(Sym1, QName("clang::Foo1"));
+  EXPECT_THAT(Sym1, qName("clang::Foo1"));
   EXPECT_EQ(Sym1.Signature, "");
   EXPECT_EQ(Sym1.Documentation, "Foo doc");
   EXPECT_EQ(Sym1.ReturnType, "int");
   EXPECT_EQ(StringRef(Sym1.CanonicalDeclaration.FileURI), "file:///path/foo.h");
   EXPECT_EQ(Sym1.Origin, SymbolOrigin::Static);
   EXPECT_EQ(static_cast<uint8_t>(Sym1.Flags), 129);
   EXPECT_TRUE(Sym1.Flags & Symbol::IndexedForCodeCompletion);
   EXPECT_FALSE(Sym1.Flags & Symbol::Deprecated);
   EXPECT_THAT(Sym1.IncludeHeaders,
               UnorderedElementsAre(IncludeHeaderWithRef("include1", 7u),
                                    IncludeHeaderWithRef("include2", 3u)));
 
-  EXPECT_THAT(Sym2, QName("clang::Foo2"));
+  EXPECT_THAT(Sym2, qName("clang::Foo2"));
   EXPECT_EQ(Sym2.Signature, "-sig");
   EXPECT_EQ(Sym2.ReturnType, "");
   EXPECT_EQ(llvm::StringRef(Sym2.CanonicalDeclaration.FileURI),
             "file:///path/bar.h");
   EXPECT_FALSE(Sym2.Flags & Symbol::IndexedForCodeCompletion);
   EXPECT_TRUE(Sym2.Flags & Symbol::Deprecated);
 
   ASSERT_TRUE(bool(ParsedYAML->Refs));
TEST(SerializationTest, YAMLConversions) {
   auto IGNDeserialized = ParsedYAML->Sources->lookup(URI);
   EXPECT_EQ(llvm::toHex(IGNDeserialized.Digest), "EED8F5EAF25C453C");
   EXPECT_THAT(IGNDeserialized.DirectIncludes,
               ElementsAre("file:///path/inc1.h", "file:///path/inc2.h"));
   EXPECT_EQ(IGNDeserialized.URI, URI);
   EXPECT_EQ(IGNDeserialized.Flags, IncludeGraphNode::SourceFlag(1));
 }
 
-std::vector<std::string> YAMLFromSymbols(const SymbolSlab &Slab) {
+std::vector<std::string> yamlFromSymbols(const SymbolSlab &Slab) {
   std::vector<std::string> Result;
   for (const auto &Sym : Slab)
     Result.push_back(toYAML(Sym));
   return Result;
 }
-std::vector<std::string> YAMLFromRefs(const RefSlab &Slab) {
+std::vector<std::string> yamlFromRefs(const RefSlab &Slab) {
   std::vector<std::string> Result;
   for (const auto &Refs : Slab)
     Result.push_back(toYAML(Refs));
   return Result;
 }
 
-std::vector<std::string> YAMLFromRelations(const RelationSlab &Slab) {
+std::vector<std::string> yamlFromRelations(const RelationSlab &Slab) {
   std::vector<std::string> Result;
   for (const auto &Rel : Slab)
     Result.push_back(toYAML(Rel));
   return Result;
 }
 
 TEST(SerializationTest, BinaryConversions) {
   auto In = readIndexFile(YAML);
   EXPECT_TRUE(bool(In)) << In.takeError();
 
   // Write to binary format, and parse again.
   IndexFileOut Out(*In);
   Out.Format = IndexFileFormat::RIFF;
   std::string Serialized = llvm::to_string(Out);
 
   auto In2 = readIndexFile(Serialized);
   ASSERT_TRUE(bool(In2)) << In.takeError();
   ASSERT_TRUE(In2->Symbols);
   ASSERT_TRUE(In2->Refs);
   ASSERT_TRUE(In2->Relations);
 
   // Assert the YAML serializations match, for nice comparisons and diffs.
-  EXPECT_THAT(YAMLFromSymbols(*In2->Symbols),
-              UnorderedElementsAreArray(YAMLFromSymbols(*In->Symbols)));
-  EXPECT_THAT(YAMLFromRefs(*In2->Refs),
-              UnorderedElementsAreArray(YAMLFromRefs(*In->Refs)));
-  EXPECT_THAT(YAMLFromRelations(*In2->Relations),
-              UnorderedElementsAreArray(YAMLFromRelations(*In->Relations)));
+  EXPECT_THAT(yamlFromSymbols(*In2->Symbols),
+              UnorderedElementsAreArray(yamlFromSymbols(*In->Symbols)));
+  EXPECT_THAT(yamlFromRefs(*In2->Refs),
+              UnorderedElementsAreArray(yamlFromRefs(*In->Refs)));
+  EXPECT_THAT(yamlFromRelations(*In2->Relations),
+              UnorderedElementsAreArray(yamlFromRelations(*In->Relations)));
 }
 
 TEST(SerializationTest, SrcsTest) {
   auto In = readIndexFile(YAML);
   EXPECT_TRUE(bool(In)) << In.takeError();
 
   std::string TestContent("TestContent");
   IncludeGraphNode IGN;
Out.Sources = &Sources;
 
     auto In = readIndexFile(Serialized);
     ASSERT_TRUE(bool(In)) << In.takeError();
     ASSERT_TRUE(In->Symbols);
     ASSERT_TRUE(In->Refs);
     ASSERT_TRUE(In->Sources);
     ASSERT_TRUE(In->Sources->count(IGN.URI));
     // Assert the YAML serializations match, for nice comparisons and diffs.
-    EXPECT_THAT(YAMLFromSymbols(*In->Symbols),
-                UnorderedElementsAreArray(YAMLFromSymbols(*In->Symbols)));
-    EXPECT_THAT(YAMLFromRefs(*In->Refs),
-                UnorderedElementsAreArray(YAMLFromRefs(*In->Refs)));
+    EXPECT_THAT(yamlFromSymbols(*In->Symbols),
+                UnorderedElementsAreArray(yamlFromSymbols(*In->Symbols)));
+    EXPECT_THAT(yamlFromRefs(*In->Refs),
+                UnorderedElementsAreArray(yamlFromRefs(*In->Refs)));
     auto IGNDeserialized = In->Sources->lookup(IGN.URI);
     EXPECT_EQ(IGNDeserialized.Digest, IGN.Digest);
     EXPECT_EQ(IGNDeserialized.DirectIncludes, IGN.DirectIncludes);
     EXPECT_EQ(IGNDeserialized.URI, IGN.URI);
     EXPECT_EQ(IGNDeserialized.Flags, IGN.Flags);
   }
 }
 

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

 using llvm::Failed;
 using llvm::FailedWithMessage;
 using llvm::HasValue;
 
 MATCHER_P2(Pos, Line, Col, "") {
   return arg.line == int(Line) && arg.character == int(Col);
 }
 
-MATCHER_P(MacroName, Name, "") { return arg.Name == Name; }
+MATCHER_P(macroName, Name, "") { return arg.Name == Name; }
 
 /// A helper to make tests easier to read.
 Position position(int Line, int Character) {
   Position Pos;
   Pos.line = Line;
   Pos.character = Character;
   return Pos;
 }
TEST(SourceCodeTests, GetMacros) {
   TestTU TU = TestTU::withCode(Code.code());
   auto AST = TU.build();
   auto CurLoc = sourceLocationInMainFile(AST.getSourceManager(), Code.point());
   ASSERT_TRUE(bool(CurLoc));
   const auto *Id = syntax::spelledIdentifierTouching(*CurLoc, AST.getTokens());
   ASSERT_TRUE(Id);
   auto Result = locateMacroAt(*Id, AST.getPreprocessor());
   ASSERT_TRUE(Result);
-  EXPECT_THAT(*Result, MacroName("MACRO"));
+  EXPECT_THAT(*Result, macroName("MACRO"));
 }
 
 TEST(SourceCodeTests, WorksAtBeginOfFile) {
   Annotations Code("^MACRO");
   TestTU TU = TestTU::withCode(Code.code());
   TU.HeaderCode = "#define MACRO int x;";
   auto AST = TU.build();
   auto CurLoc = sourceLocationInMainFile(AST.getSourceManager(), Code.point());
   ASSERT_TRUE(bool(CurLoc));
   const auto *Id = syntax::spelledIdentifierTouching(*CurLoc, AST.getTokens());
   ASSERT_TRUE(Id);
   auto Result = locateMacroAt(*Id, AST.getPreprocessor());
   ASSERT_TRUE(Result);
-  EXPECT_THAT(*Result, MacroName("MACRO"));
+  EXPECT_THAT(*Result, macroName("MACRO"));
 }
 
 TEST(SourceCodeTests, IsInsideMainFile) {
   TestTU TU;
   TU.HeaderCode = R"cpp(
     #define DEFINE_CLASS(X) class X {};
     #define DEFINE_YY DEFINE_CLASS(YY)
 

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

 using ::testing::Field;
 using ::testing::IsEmpty;
 using ::testing::Not;
 using ::testing::Pair;
 using ::testing::UnorderedElementsAre;
 using ::testing::UnorderedElementsAreArray;
 
 // GMock helpers for matching Symbol.
-MATCHER_P(Labeled, Label, "") {
+MATCHER_P(labeled, Label, "") {
   return (arg.Name + arg.Signature).str() == Label;
 }
-MATCHER_P(ReturnType, D, "") { return arg.ReturnType == D; }
-MATCHER_P(Doc, D, "") { return arg.Documentation == D; }
-MATCHER_P(Snippet, S, "") {
+MATCHER_P(returnType, D, "") { return arg.ReturnType == D; }
+MATCHER_P(doc, D, "") { return arg.Documentation == D; }
+MATCHER_P(snippet, S, "") {
   return (arg.Name + arg.CompletionSnippetSuffix).str() == S;
 }
-MATCHER_P(QName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
-MATCHER_P(HasName, Name, "") { return arg.Name == Name; }
-MATCHER_P(TemplateArgs, TemplArgs, "") {
+MATCHER_P(qName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
+MATCHER_P(hasName, Name, "") { return arg.Name == Name; }
+MATCHER_P(templateArgs, TemplArgs, "") {
   return arg.TemplateSpecializationArgs == TemplArgs;
 }
-MATCHER_P(DeclURI, P, "") {
+MATCHER_P(declURI, P, "") {
   return StringRef(arg.CanonicalDeclaration.FileURI) == P;
 }
-MATCHER_P(DefURI, P, "") { return StringRef(arg.Definition.FileURI) == P; }
-MATCHER(IncludeHeader, "") { return !arg.IncludeHeaders.empty(); }
-MATCHER_P(IncludeHeader, P, "") {
+MATCHER_P(defURI, P, "") { return StringRef(arg.Definition.FileURI) == P; }
+MATCHER(includeHeader, "") { return !arg.IncludeHeaders.empty(); }
+MATCHER_P(includeHeader, P, "") {
   return (arg.IncludeHeaders.size() == 1) &&
          (arg.IncludeHeaders.begin()->IncludeHeader == P);
 }
-MATCHER_P2(IncludeHeaderWithRef, IncludeHeader, References, "") {
-  return (arg.IncludeHeader == IncludeHeader) && (arg.References == References);
+MATCHER_P2(IncludeHeaderWithRef, includeHeader, References, "") {
+  return (arg.IncludeHeader == includeHeader) && (arg.References == References);
 }
 bool rangesMatch(const SymbolLocation &Loc, const Range &R) {
   return std::make_tuple(Loc.Start.line(), Loc.Start.column(), Loc.End.line(),
                          Loc.End.column()) ==
          std::make_tuple(R.start.line, R.start.character, R.end.line,
                          R.end.character);
 }
-MATCHER_P(DeclRange, Pos, "") {
+MATCHER_P(declRange, Pos, "") {
   return rangesMatch(arg.CanonicalDeclaration, Pos);
 }
-MATCHER_P(DefRange, Pos, "") { return rangesMatch(arg.Definition, Pos); }
-MATCHER_P(RefCount, R, "") { return int(arg.References) == R; }
-MATCHER_P(ForCodeCompletion, IsIndexedForCodeCompletion, "") {
+MATCHER_P(defRange, Pos, "") { return rangesMatch(arg.Definition, Pos); }
+MATCHER_P(refCount, R, "") { return int(arg.References) == R; }
+MATCHER_P(forCodeCompletion, IsIndexedForCodeCompletion, "") {
   return static_cast<bool>(arg.Flags & Symbol::IndexedForCodeCompletion) ==
          IsIndexedForCodeCompletion;
 }
-MATCHER(Deprecated, "") { return arg.Flags & Symbol::Deprecated; }
-MATCHER(ImplementationDetail, "") {
+MATCHER(deprecated, "") { return arg.Flags & Symbol::Deprecated; }
+MATCHER(implementationDetail, "") {
   return arg.Flags & Symbol::ImplementationDetail;
 }
-MATCHER(VisibleOutsideFile, "") {
+MATCHER(visibleOutsideFile, "") {
   return static_cast<bool>(arg.Flags & Symbol::VisibleOutsideFile);
 }
-MATCHER(RefRange, "") {
+MATCHER(refRange, "") {
   const Ref &Pos = ::testing::get<0>(arg);
   const Range &Range = ::testing::get<1>(arg);
   return rangesMatch(Pos.Location, Range);
 }
 MATCHER_P2(OverriddenBy, Subject, Object, "") {
   return arg == Relation{Subject.ID, RelationKind::OverriddenBy, Object.ID};
 }
 ::testing::Matcher<const std::vector<Ref> &>
-HaveRanges(const std::vector<Range> Ranges) {
-  return ::testing::UnorderedPointwise(RefRange(), Ranges);
+haveRanges(const std::vector<Range> Ranges) {
+  return ::testing::UnorderedPointwise(refRange(), Ranges);
 }
 
 class ShouldCollectSymbolTest : public ::testing::Test {
 public:
   void build(llvm::StringRef HeaderCode, llvm::StringRef Code = "") {
     File.HeaderFilename = HeaderName;
     File.Filename = FileName;
     File.HeaderCode = std::string(HeaderCode);
const std::string Header = R"(
     namespace baz = bar;
 
     using bar::v2;
     } // namespace foo
   )";
   runSymbolCollector(Header, /*Main=*/"");
   EXPECT_THAT(Symbols,
               UnorderedElementsAreArray(
-                  {AllOf(QName("Foo"), ForCodeCompletion(true)),
-                   AllOf(QName("Foo::Foo"), ForCodeCompletion(false)),
-                   AllOf(QName("Foo::Foo"), ForCodeCompletion(false)),
-                   AllOf(QName("Foo::f"), ForCodeCompletion(false)),
-                   AllOf(QName("Foo::~Foo"), ForCodeCompletion(false)),
-                   AllOf(QName("Foo::operator="), ForCodeCompletion(false)),
-                   AllOf(QName("Foo::Nested"), ForCodeCompletion(false)),
-                   AllOf(QName("Foo::Nested::f"), ForCodeCompletion(false)),
-                   AllOf(QName("ClassInLambda"), ForCodeCompletion(false)),
-                   AllOf(QName("Friend"), ForCodeCompletion(true)),
-                   AllOf(QName("f1"), ForCodeCompletion(true)),
-                   AllOf(QName("f2"), ForCodeCompletion(true)),
-                   AllOf(QName("KInt"), ForCodeCompletion(true)),
-                   AllOf(QName("kStr"), ForCodeCompletion(true)),
-                   AllOf(QName("foo"), ForCodeCompletion(true)),
-                   AllOf(QName("foo::bar"), ForCodeCompletion(true)),
-                   AllOf(QName("foo::int32"), ForCodeCompletion(true)),
-                   AllOf(QName("foo::int32_t"), ForCodeCompletion(true)),
-                   AllOf(QName("foo::v1"), ForCodeCompletion(true)),
-                   AllOf(QName("foo::bar::v2"), ForCodeCompletion(true)),
-                   AllOf(QName("foo::v2"), ForCodeCompletion(true)),
-                   AllOf(QName("foo::baz"), ForCodeCompletion(true))}));
+                  {AllOf(qName("Foo"), forCodeCompletion(true)),
+                   AllOf(qName("Foo::Foo"), forCodeCompletion(false)),
+                   AllOf(qName("Foo::Foo"), forCodeCompletion(false)),
+                   AllOf(qName("Foo::f"), forCodeCompletion(false)),
+                   AllOf(qName("Foo::~Foo"), forCodeCompletion(false)),
+                   AllOf(qName("Foo::operator="), forCodeCompletion(false)),
+                   AllOf(qName("Foo::Nested"), forCodeCompletion(false)),
+                   AllOf(qName("Foo::Nested::f"), forCodeCompletion(false)),
+                   AllOf(qName("ClassInLambda"), forCodeCompletion(false)),
+                   AllOf(qName("Friend"), forCodeCompletion(true)),
+                   AllOf(qName("f1"), forCodeCompletion(true)),
+                   AllOf(qName("f2"), forCodeCompletion(true)),
+                   AllOf(qName("KInt"), forCodeCompletion(true)),
+                   AllOf(qName("kStr"), forCodeCompletion(true)),
+                   AllOf(qName("foo"), forCodeCompletion(true)),
+                   AllOf(qName("foo::bar"), forCodeCompletion(true)),
+                   AllOf(qName("foo::int32"), forCodeCompletion(true)),
+                   AllOf(qName("foo::int32_t"), forCodeCompletion(true)),
+                   AllOf(qName("foo::v1"), forCodeCompletion(true)),
+                   AllOf(qName("foo::bar::v2"), forCodeCompletion(true)),
+                   AllOf(qName("foo::v2"), forCodeCompletion(true)),
+                   AllOf(qName("foo::baz"), forCodeCompletion(true))}));
 }
 
 TEST_F(SymbolCollectorTest, FileLocal) {
   const std::string Header = R"(
     class Foo {};
     namespace {
       class Ignored {};
     }
     void bar();
   )";
   const std::string Main = R"(
     class ForwardDecl;
     void bar() {}
     static void a();
     class B {};
     namespace {
       void c();
     }
   )";
   runSymbolCollector(Header, Main);
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("Foo"), VisibleOutsideFile()),
-                  AllOf(QName("bar"), VisibleOutsideFile()),
-                  AllOf(QName("a"), Not(VisibleOutsideFile())),
-                  AllOf(QName("B"), Not(VisibleOutsideFile())),
-                  AllOf(QName("c"), Not(VisibleOutsideFile())),
+                  AllOf(qName("Foo"), visibleOutsideFile()),
+                  AllOf(qName("bar"), visibleOutsideFile()),
+                  AllOf(qName("a"), Not(visibleOutsideFile())),
+                  AllOf(qName("B"), Not(visibleOutsideFile())),
+                  AllOf(qName("c"), Not(visibleOutsideFile())),
                   // FIXME: ForwardDecl likely *is* visible outside.
-                  AllOf(QName("ForwardDecl"), Not(VisibleOutsideFile()))));
+                  AllOf(qName("ForwardDecl"), Not(visibleOutsideFile()))));
 }
 
 TEST_F(SymbolCollectorTest, Template) {
   Annotations Header(R"(
     // Primary template and explicit specialization are indexed, instantiation
     // is not.
     template <class T, class U> struct [[Tmpl]] {T $xdecl[[x]] = 0;};
     template <> struct $specdecl[[Tmpl]]<int, bool> {};
     template <class U> struct $partspecdecl[[Tmpl]]<bool, U> {};
     extern template struct Tmpl<float, bool>;
     template struct Tmpl<double, bool>;
   )");
   runSymbolCollector(Header.code(), /*Main=*/"");
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("Tmpl"), DeclRange(Header.range()),
-                        ForCodeCompletion(true)),
-                  AllOf(QName("Tmpl"), DeclRange(Header.range("specdecl")),
-                        ForCodeCompletion(false)),
-                  AllOf(QName("Tmpl"), DeclRange(Header.range("partspecdecl")),
-                        ForCodeCompletion(false)),
-                  AllOf(QName("Tmpl::x"), DeclRange(Header.range("xdecl")),
-                        ForCodeCompletion(false))));
+                  AllOf(qName("Tmpl"), declRange(Header.range()),
+                        forCodeCompletion(true)),
+                  AllOf(qName("Tmpl"), declRange(Header.range("specdecl")),
+                        forCodeCompletion(false)),
+                  AllOf(qName("Tmpl"), declRange(Header.range("partspecdecl")),
+                        forCodeCompletion(false)),
+                  AllOf(qName("Tmpl::x"), declRange(Header.range("xdecl")),
+                        forCodeCompletion(false))));
 }
 
-TEST_F(SymbolCollectorTest, TemplateArgs) {
+TEST_F(SymbolCollectorTest, templateArgs) {
   Annotations Header(R"(
     template <class X> class $barclasstemp[[Bar]] {};
     template <class T, class U, template<typename> class Z, int Q>
     struct [[Tmpl]] { T $xdecl[[x]] = 0; };
 
     // template-template, non-type and type full spec
     template <> struct $specdecl[[Tmpl]]<int, bool, Bar, 3> {};
 
Annotations Header(R"(
     // template-template parameter-packs partial spec
     template<template <class> class T>
     class $parampacktempltemplpartial[[Foz]]<T, T> {};
   )");
   runSymbolCollector(Header.code(), /*Main=*/"");
   EXPECT_THAT(
       Symbols,
       AllOf(
-          Contains(AllOf(QName("Tmpl"), TemplateArgs("<int, bool, Bar, 3>"),
-                         DeclRange(Header.range("specdecl")),
-                         ForCodeCompletion(false))),
-          Contains(AllOf(QName("Tmpl"), TemplateArgs("<bool, U, Bar, T>"),
-                         DeclRange(Header.range("partspecdecl")),
-                         ForCodeCompletion(false))),
-          Contains(AllOf(QName("Foo"), TemplateArgs("<Bar<int>, int, double>"),
-                         DeclRange(Header.range("parampack")),
-                         ForCodeCompletion(false))),
-          Contains(AllOf(QName("Foo"), TemplateArgs("<T, T>"),
-                         DeclRange(Header.range("parampackpartial")),
-                         ForCodeCompletion(false))),
-          Contains(AllOf(QName("Baz"), TemplateArgs("<3, 5, 8>"),
-                         DeclRange(Header.range("parampacknontype")),
-                         ForCodeCompletion(false))),
-          Contains(AllOf(QName("Baz"), TemplateArgs("<T, T>"),
-                         DeclRange(Header.range("parampacknontypepartial")),
-                         ForCodeCompletion(false))),
-          Contains(AllOf(QName("Foz"), TemplateArgs("<Bar, Bar>"),
-                         DeclRange(Header.range("parampacktempltempl")),
-                         ForCodeCompletion(false))),
-          Contains(AllOf(QName("Foz"), TemplateArgs("<T, T>"),
-                         DeclRange(Header.range("parampacktempltemplpartial")),
-                         ForCodeCompletion(false)))));
+          Contains(AllOf(qName("Tmpl"), templateArgs("<int, bool, Bar, 3>"),
+                         declRange(Header.range("specdecl")),
+                         forCodeCompletion(false))),
+          Contains(AllOf(qName("Tmpl"), templateArgs("<bool, U, Bar, T>"),
+                         declRange(Header.range("partspecdecl")),
+                         forCodeCompletion(false))),
+          Contains(AllOf(qName("Foo"), templateArgs("<Bar<int>, int, double>"),
+                         declRange(Header.range("parampack")),
+                         forCodeCompletion(false))),
+          Contains(AllOf(qName("Foo"), templateArgs("<T, T>"),
+                         declRange(Header.range("parampackpartial")),
+                         forCodeCompletion(false))),
+          Contains(AllOf(qName("Baz"), templateArgs("<3, 5, 8>"),
+                         declRange(Header.range("parampacknontype")),
+                         forCodeCompletion(false))),
+          Contains(AllOf(qName("Baz"), templateArgs("<T, T>"),
+                         declRange(Header.range("parampacknontypepartial")),
+                         forCodeCompletion(false))),
+          Contains(AllOf(qName("Foz"), templateArgs("<Bar, Bar>"),
+                         declRange(Header.range("parampacktempltempl")),
+                         forCodeCompletion(false))),
+          Contains(AllOf(qName("Foz"), templateArgs("<T, T>"),
+                         declRange(Header.range("parampacktempltemplpartial")),
+                         forCodeCompletion(false)))));
 }
 
 TEST_F(SymbolCollectorTest, ObjCSymbols) {
   const std::string Header = R"(
     @interface Person
     - (void)someMethodName:(void*)name1 lastName:(void*)lName;
     @end
 
const std::string Header = R"(
     @protocol MyProtocol
     - (void)someMethodName3:(void*)name3;
     @end
   )";
   TestFileName = testPath("test.m");
   runSymbolCollector(Header, /*Main=*/"", {"-fblocks", "-xobjective-c++"});
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  QName("Person"), QName("Person::someMethodName:lastName:"),
-                  AllOf(QName("MyCategory"), ForCodeCompletion(false)),
-                  QName("Person::someMethodName2:"), QName("MyProtocol"),
-                  QName("MyProtocol::someMethodName3:")));
+                  qName("Person"), qName("Person::someMethodName:lastName:"),
+                  AllOf(qName("MyCategory"), forCodeCompletion(false)),
+                  qName("Person::someMethodName2:"), qName("MyProtocol"),
+                  qName("MyProtocol::someMethodName3:")));
 }
 
 TEST_F(SymbolCollectorTest, ObjCPropertyImpl) {
   const std::string Header = R"(
     @interface Container
     @property(nonatomic) int magic;
     @end
 
     @implementation Container
     @end
   )";
   TestFileName = testPath("test.m");
   runSymbolCollector(Header, /*Main=*/"", {"-xobjective-c++"});
-  EXPECT_THAT(Symbols, Contains(QName("Container")));
-  EXPECT_THAT(Symbols, Contains(QName("Container::magic")));
+  EXPECT_THAT(Symbols, Contains(qName("Container")));
+  EXPECT_THAT(Symbols, Contains(qName("Container::magic")));
   // FIXME: Results also contain Container::_magic on some platforms.
   //        Figure out why it's platform-dependent.
 }
 
 TEST_F(SymbolCollectorTest, ObjCLocations) {
   Annotations Header(R"(
     // Declared in header, defined in main.
     @interface $dogdecl[[Dog]]
Annotations Main(R"(
     // Implicitly defined interface.
     @implementation $catdog[[CatDog]]
     @end
   )");
   runSymbolCollector(Header.code(), Main.code(),
                      {"-xobjective-c++", "-Wno-objc-root-class"});
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("Dog"), DeclRange(Header.range("dogdecl")),
-                        DefRange(Main.range("dogdef"))),
-                  AllOf(QName("Fluffy"), DeclRange(Header.range("fluffydecl")),
-                        DefRange(Main.range("fluffydef"))),
-                  AllOf(QName("CatDog"), DeclRange(Main.range("catdog")),
-                        DefRange(Main.range("catdog"))),
-                  AllOf(QName("Ruff"), DeclRange(Main.range("ruff")),
-                        DefRange(Main.range("ruff")))));
+                  AllOf(qName("Dog"), declRange(Header.range("dogdecl")),
+                        defRange(Main.range("dogdef"))),
+                  AllOf(qName("Fluffy"), declRange(Header.range("fluffydecl")),
+                        defRange(Main.range("fluffydef"))),
+                  AllOf(qName("CatDog"), declRange(Main.range("catdog")),
+                        defRange(Main.range("catdog"))),
+                  AllOf(qName("Ruff"), declRange(Main.range("ruff")),
+                        defRange(Main.range("ruff")))));
 }
 
 TEST_F(SymbolCollectorTest, ObjCForwardDecls) {
   Annotations Header(R"(
     // Forward declared in header, declared and defined in main.
     @protocol Barker;
     @class Dog;
     // Never fully declared so Clang latches onto this decl.
Annotations Main(R"(
     @end
     @implementation $catdogdef[[CatDog]]
     @end
   )");
   runSymbolCollector(Header.code(), Main.code(),
                      {"-xobjective-c++", "-Wno-objc-root-class"});
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("CatDog"), DeclRange(Header.range("catdogdecl")),
-                        DefRange(Main.range("catdogdef"))),
-                  AllOf(QName("Dog"), DeclRange(Main.range("dogdecl")),
-                        DefRange(Main.range("dogdef"))),
-                  AllOf(QName("Barker"), DeclRange(Main.range("barkerdecl"))),
-                  QName("Barker::woof"), QName("Dog::woof")));
+                  AllOf(qName("CatDog"), declRange(Header.range("catdogdecl")),
+                        defRange(Main.range("catdogdef"))),
+                  AllOf(qName("Dog"), declRange(Main.range("dogdecl")),
+                        defRange(Main.range("dogdef"))),
+                  AllOf(qName("Barker"), declRange(Main.range("barkerdecl"))),
+                  qName("Barker::woof"), qName("Dog::woof")));
 }
 
 TEST_F(SymbolCollectorTest, ObjCClassExtensions) {
   Annotations Header(R"(
     @interface $catdecl[[Cat]]
     @end
   )");
   Annotations Main(R"(
     @interface Cat ()
     - (void)meow;
     @end
     @interface Cat ()
     - (void)pur;
     @end
   )");
   runSymbolCollector(Header.code(), Main.code(),
                      {"-xobjective-c++", "-Wno-objc-root-class"});
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("Cat"), DeclRange(Header.range("catdecl"))),
-                  QName("Cat::meow"), QName("Cat::pur")));
+                  AllOf(qName("Cat"), declRange(Header.range("catdecl"))),
+                  qName("Cat::meow"), qName("Cat::pur")));
 }
 
 TEST_F(SymbolCollectorTest, Locations) {
   Annotations Header(R"cpp(
     // Declared in header, defined in main.
     extern int $xdecl[[X]];
     class $clsdecl[[Cls]];
     void $printdecl[[print]]();
Annotations Main(R"cpp(
     void $printdef[[print]]() {}
 
     // Declared/defined in main only.
     int $ydecl[[Y]];
   )cpp");
   runSymbolCollector(Header.code(), Main.code());
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("X"), DeclRange(Header.range("xdecl")),
-                        DefRange(Main.range("xdef"))),
-                  AllOf(QName("Cls"), DeclRange(Header.range("clsdecl")),
-                        DefRange(Main.range("clsdef"))),
-                  AllOf(QName("print"), DeclRange(Header.range("printdecl")),
-                        DefRange(Main.range("printdef"))),
-                  AllOf(QName("Z"), DeclRange(Header.range("zdecl"))),
-                  AllOf(QName("foo"), DeclRange(Header.range("foodecl"))),
-                  AllOf(QName("Y"), DeclRange(Main.range("ydecl")))));
+                  AllOf(qName("X"), declRange(Header.range("xdecl")),
+                        defRange(Main.range("xdef"))),
+                  AllOf(qName("Cls"), declRange(Header.range("clsdecl")),
+                        defRange(Main.range("clsdef"))),
+                  AllOf(qName("print"), declRange(Header.range("printdecl")),
+                        defRange(Main.range("printdef"))),
+                  AllOf(qName("Z"), declRange(Header.range("zdecl"))),
+                  AllOf(qName("foo"), declRange(Header.range("foodecl"))),
+                  AllOf(qName("Y"), declRange(Main.range("ydecl")))));
 }
 
 TEST_F(SymbolCollectorTest, Refs) {
   Annotations Header(R"(
   #define MACRO(X) (X + 1)
   class Foo {
   public:
     Foo() {}
TEST_F(SymbolCollectorTest, Refs) {
   static const int c = FUNC(1);
   class d {};
   )");
   CollectorOpts.RefFilter = RefKind::All;
   CollectorOpts.CollectMacro = true;
   runSymbolCollector(Header.code(),
                      (Main.code() + SymbolsOnlyInMainCode.code()).str());
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Foo").ID,
-                                  HaveRanges(Main.ranges("foo")))));
+                                  haveRanges(Main.ranges("foo")))));
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Bar").ID,
-                                  HaveRanges(Main.ranges("bar")))));
+                                  haveRanges(Main.ranges("bar")))));
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "func").ID,
-                                  HaveRanges(Main.ranges("func")))));
+                                  haveRanges(Main.ranges("func")))));
   EXPECT_THAT(Refs, Not(Contains(Pair(findSymbol(Symbols, "NS").ID, _))));
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "MACRO").ID,
-                                  HaveRanges(Main.ranges("macro")))));
+                                  haveRanges(Main.ranges("macro")))));
   // - (a, b) externally visible and should have refs.
   // - (c, FUNC) externally invisible and had no refs collected.
   auto MainSymbols =
       TestTU::withHeaderCode(SymbolsOnlyInMainCode.code()).headerSymbols();
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(MainSymbols, "a").ID, _)));
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(MainSymbols, "b").ID, _)));
   EXPECT_THAT(Refs, Not(Contains(Pair(findSymbol(MainSymbols, "c").ID, _))));
   EXPECT_THAT(Refs, Not(Contains(Pair(findSymbol(MainSymbols, "FUNC").ID, _))));
TEST_F(SymbolCollectorTest, MacroRefInHeader) {
   CollectorOpts.RefFilter = RefKind::All;
   CollectorOpts.RefsInHeaders = true;
   // Need this to get the SymbolID for macros for tests.
   CollectorOpts.CollectMacro = true;
 
   runSymbolCollector(Header.code(), "");
 
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "FOO").ID,
-                                  HaveRanges(Header.ranges("foo")))));
+                                  haveRanges(Header.ranges("foo")))));
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "BAR").ID,
-                                  HaveRanges(Header.ranges("bar")))));
+                                  haveRanges(Header.ranges("bar")))));
   // No unique ID for multiple symbols named UD. Check for ranges only.
-  EXPECT_THAT(Refs, Contains(Pair(_, HaveRanges(Header.ranges("ud1")))));
-  EXPECT_THAT(Refs, Contains(Pair(_, HaveRanges(Header.ranges("ud2")))));
+  EXPECT_THAT(Refs, Contains(Pair(_, haveRanges(Header.ranges("ud1")))));
+  EXPECT_THAT(Refs, Contains(Pair(_, haveRanges(Header.ranges("ud2")))));
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "CONCAT").ID,
-                                  HaveRanges(Header.ranges("concat")))));
+                                  haveRanges(Header.ranges("concat")))));
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "PREPEND").ID,
-                                  HaveRanges(Header.ranges("prepend")))));
+                                  haveRanges(Header.ranges("prepend")))));
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "MACROA").ID,
-                                  HaveRanges(Header.ranges("macroa")))));
+                                  haveRanges(Header.ranges("macroa")))));
 }
 
 TEST_F(SymbolCollectorTest, MacroRefWithoutCollectingSymbol) {
   Annotations Header(R"(
   #define $foo[[FOO]](X) (X + 1)
   int abc = $foo[[FOO]](1);
   )");
   CollectorOpts.RefFilter = RefKind::All;
   CollectorOpts.RefsInHeaders = true;
   CollectorOpts.CollectMacro = false;
   runSymbolCollector(Header.code(), "");
-  EXPECT_THAT(Refs, Contains(Pair(_, HaveRanges(Header.ranges("foo")))));
+  EXPECT_THAT(Refs, Contains(Pair(_, haveRanges(Header.ranges("foo")))));
 }
 
 TEST_F(SymbolCollectorTest, MacrosWithRefFilter) {
   Annotations Header("#define $macro[[MACRO]](X) (X + 1)");
   Annotations Main("void foo() { int x = $macro[[MACRO]](1); }");
   CollectorOpts.RefFilter = RefKind::Unknown;
   runSymbolCollector(Header.code(), Main.code());
   EXPECT_THAT(Refs, IsEmpty());
for (const auto &SymbolAndRefs : Refs) {
         if ((Ref.Kind & RefKind::Spelled) != RefKind::Unknown)
           SpelledSlabBuilder.insert(ID, Ref);
         else
           ImplicitSlabBuilder.insert(ID, Ref);
     }
     const auto SpelledRefs = std::move(SpelledSlabBuilder).build(),
                ImplicitRefs = std::move(ImplicitSlabBuilder).build();
     EXPECT_THAT(SpelledRefs,
-                Contains(Pair(TargetID, HaveRanges(SpelledRanges))));
+                Contains(Pair(TargetID, haveRanges(SpelledRanges))));
     EXPECT_THAT(ImplicitRefs,
-                Contains(Pair(TargetID, HaveRanges(ImplicitRanges))));
+                Contains(Pair(TargetID, haveRanges(ImplicitRanges))));
   }
 }
 
 TEST_F(SymbolCollectorTest, NameReferences) {
   CollectorOpts.RefFilter = RefKind::All;
   CollectorOpts.RefsInHeaders = true;
   Annotations Header(R"(
     class [[Foo]] {
     public:
       [[Foo]]() {}
       ~[[Foo]]() {}
     };
   )");
   CollectorOpts.RefFilter = RefKind::All;
   runSymbolCollector(Header.code(), "");
   // When we find references for class Foo, we expect to see all
   // constructor/destructor references.
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Foo").ID,
-                                  HaveRanges(Header.ranges()))));
+                                  haveRanges(Header.ranges()))));
 }
 
 TEST_F(SymbolCollectorTest, RefsOnMacros) {
   // Refs collected from SymbolCollector behave in the same way as
   // AST-based xrefs.
   CollectorOpts.RefFilter = RefKind::All;
   CollectorOpts.RefsInHeaders = true;
   Annotations Header(R"(
     #define TYPE(X) X
     #define FOO Foo
     #define CAT(X, Y) X##Y
     class [[Foo]] {};
     void test() {
       TYPE([[Foo]]) foo;
       [[FOO]] foo2;
       TYPE(TYPE([[Foo]])) foo3;
       [[CAT]](Fo, o) foo4;
     }
   )");
   CollectorOpts.RefFilter = RefKind::All;
   runSymbolCollector(Header.code(), "");
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Foo").ID,
-                                  HaveRanges(Header.ranges()))));
+                                  haveRanges(Header.ranges()))));
 }
 
 TEST_F(SymbolCollectorTest, HeaderAsMainFile) {
   CollectorOpts.RefFilter = RefKind::All;
   Annotations Header(R"(
   class $Foo[[Foo]] {};
 
   void $Func[[Func]]() {
     $Foo[[Foo]] fo;
   }
   )");
   // We should collect refs to main-file symbols in all cases:
 
   // 1. The main file is normal .cpp file.
   TestFileName = testPath("foo.cpp");
   runSymbolCollector("", Header.code());
   EXPECT_THAT(Refs,
               UnorderedElementsAre(Pair(findSymbol(Symbols, "Foo").ID,
-                                        HaveRanges(Header.ranges("Foo"))),
+                                        haveRanges(Header.ranges("Foo"))),
                                    Pair(findSymbol(Symbols, "Func").ID,
-                                        HaveRanges(Header.ranges("Func")))));
+                                        haveRanges(Header.ranges("Func")))));
 
   // 2. Run the .h file as main file.
   TestFileName = testPath("foo.h");
   runSymbolCollector("", Header.code(),
                      /*ExtraArgs=*/{"-xobjective-c++-header"});
-  EXPECT_THAT(Symbols, UnorderedElementsAre(QName("Foo"), QName("Func")));
+  EXPECT_THAT(Symbols, UnorderedElementsAre(qName("Foo"), qName("Func")));
   EXPECT_THAT(Refs,
               UnorderedElementsAre(Pair(findSymbol(Symbols, "Foo").ID,
-                                        HaveRanges(Header.ranges("Foo"))),
+                                        haveRanges(Header.ranges("Foo"))),
                                    Pair(findSymbol(Symbols, "Func").ID,
-                                        HaveRanges(Header.ranges("Func")))));
+                                        haveRanges(Header.ranges("Func")))));
 
   // 3. Run the .hh file as main file (without "-x c++-header").
   TestFileName = testPath("foo.hh");
   runSymbolCollector("", Header.code());
-  EXPECT_THAT(Symbols, UnorderedElementsAre(QName("Foo"), QName("Func")));
+  EXPECT_THAT(Symbols, UnorderedElementsAre(qName("Foo"), qName("Func")));
   EXPECT_THAT(Refs,
               UnorderedElementsAre(Pair(findSymbol(Symbols, "Foo").ID,
-                                        HaveRanges(Header.ranges("Foo"))),
+                                        haveRanges(Header.ranges("Foo"))),
                                    Pair(findSymbol(Symbols, "Func").ID,
-                                        HaveRanges(Header.ranges("Func")))));
+                                        haveRanges(Header.ranges("Func")))));
 }
 
 TEST_F(SymbolCollectorTest, RefsInHeaders) {
   CollectorOpts.RefFilter = RefKind::All;
   CollectorOpts.RefsInHeaders = true;
   CollectorOpts.CollectMacro = true;
   Annotations Header(R"(
   #define $macro[[MACRO]](x) (x+1)
   class $foo[[Foo]] {};
   )");
   runSymbolCollector(Header.code(), "");
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "Foo").ID,
-                                  HaveRanges(Header.ranges("foo")))));
+                                  haveRanges(Header.ranges("foo")))));
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "MACRO").ID,
-                                  HaveRanges(Header.ranges("macro")))));
+                                  haveRanges(Header.ranges("macro")))));
 }
 
 TEST_F(SymbolCollectorTest, BaseOfRelations) {
   std::string Header = R"(
   class Base {};
   class Derived : public Base {};
   )";
   runSymbolCollector(Header, /*Main=*/"");
const std::string Main = R"(
     V* v = nullptr;
     GLOBAL_Z(z); // Not a reference to Z, we don't spell the type.
   )";
   CollectorOpts.CountReferences = true;
   runSymbolCollector(Header, Main);
   EXPECT_THAT(
       Symbols,
       UnorderedElementsAreArray(
-          {AllOf(QName("W"), RefCount(1)), AllOf(QName("X"), RefCount(1)),
-           AllOf(QName("Y"), RefCount(0)), AllOf(QName("Z"), RefCount(0)),
-           AllOf(QName("y"), RefCount(0)), AllOf(QName("z"), RefCount(0)),
-           AllOf(QName("x"), RefCount(0)), AllOf(QName("w"), RefCount(0)),
-           AllOf(QName("w2"), RefCount(0)), AllOf(QName("V"), RefCount(1)),
-           AllOf(QName("v"), RefCount(0))}));
+          {AllOf(qName("W"), refCount(1)), AllOf(qName("X"), refCount(1)),
+           AllOf(qName("Y"), refCount(0)), AllOf(qName("Z"), refCount(0)),
+           AllOf(qName("y"), refCount(0)), AllOf(qName("z"), refCount(0)),
+           AllOf(qName("x"), refCount(0)), AllOf(qName("w"), refCount(0)),
+           AllOf(qName("w2"), refCount(0)), AllOf(qName("V"), refCount(1)),
+           AllOf(qName("v"), refCount(0))}));
 }
 
 TEST_F(SymbolCollectorTest, SymbolRelativeNoFallback) {
   runSymbolCollector("class Foo {};", /*Main=*/"");
   EXPECT_THAT(Symbols, UnorderedElementsAre(
-                           AllOf(QName("Foo"), DeclURI(TestHeaderURI))));
+                           AllOf(qName("Foo"), declURI(TestHeaderURI))));
 }
 
 TEST_F(SymbolCollectorTest, SymbolRelativeWithFallback) {
   TestHeaderName = "x.h";
   TestFileName = "x.cpp";
   TestHeaderURI = URI::create(testPath(TestHeaderName)).toString();
   CollectorOpts.FallbackDir = testRoot();
   runSymbolCollector("class Foo {};", /*Main=*/"");
   EXPECT_THAT(Symbols, UnorderedElementsAre(
-                           AllOf(QName("Foo"), DeclURI(TestHeaderURI))));
+                           AllOf(qName("Foo"), declURI(TestHeaderURI))));
 }
 
 TEST_F(SymbolCollectorTest, UnittestURIScheme) {
   // Use test URI scheme from URITests.cpp
   TestHeaderName = testPath("x.h");
   TestFileName = testPath("x.cpp");
   runSymbolCollector("class Foo {};", /*Main=*/"");
   EXPECT_THAT(Symbols, UnorderedElementsAre(
-                           AllOf(QName("Foo"), DeclURI("unittest:///x.h"))));
+                           AllOf(qName("Foo"), declURI("unittest:///x.h"))));
 }
 
 TEST_F(SymbolCollectorTest, IncludeEnums) {
   const std::string Header = R"(
     enum {
       Red
     };
     enum Color {
       Green
     };
     enum class Color2 {
       Yellow
     };
     namespace ns {
     enum {
       Black
     };
     }
   )";
   runSymbolCollector(Header, /*Main=*/"");
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("Red"), ForCodeCompletion(true)),
-                  AllOf(QName("Color"), ForCodeCompletion(true)),
-                  AllOf(QName("Green"), ForCodeCompletion(true)),
-                  AllOf(QName("Color2"), ForCodeCompletion(true)),
-                  AllOf(QName("Color2::Yellow"), ForCodeCompletion(false)),
-                  AllOf(QName("ns"), ForCodeCompletion(true)),
-                  AllOf(QName("ns::Black"), ForCodeCompletion(true))));
+                  AllOf(qName("Red"), forCodeCompletion(true)),
+                  AllOf(qName("Color"), forCodeCompletion(true)),
+                  AllOf(qName("Green"), forCodeCompletion(true)),
+                  AllOf(qName("Color2"), forCodeCompletion(true)),
+                  AllOf(qName("Color2::Yellow"), forCodeCompletion(false)),
+                  AllOf(qName("ns"), forCodeCompletion(true)),
+                  AllOf(qName("ns::Black"), forCodeCompletion(true))));
 }
 
 TEST_F(SymbolCollectorTest, NamelessSymbols) {
   const std::string Header = R"(
     struct {
       int a;
     } Foo;
   )";
   runSymbolCollector(Header, /*Main=*/"");
-  EXPECT_THAT(Symbols, UnorderedElementsAre(QName("Foo"),
-                                            QName("(anonymous struct)::a")));
+  EXPECT_THAT(Symbols, UnorderedElementsAre(qName("Foo"),
+                                            qName("(anonymous struct)::a")));
 }
 
 TEST_F(SymbolCollectorTest, SymbolFormedFromRegisteredSchemeFromMacro) {
 
   Annotations Header(R"(
     #define FF(name) \
       class name##_Test {};
 
     $expansion[[FF]](abc);
 
     #define FF2() \
       class $spelling[[Test]] {};
 
     FF2();
   )");
 
   runSymbolCollector(Header.code(), /*Main=*/"");
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("abc_Test"), DeclRange(Header.range("expansion")),
-                        DeclURI(TestHeaderURI)),
-                  AllOf(QName("Test"), DeclRange(Header.range("spelling")),
-                        DeclURI(TestHeaderURI))));
+                  AllOf(qName("abc_Test"), declRange(Header.range("expansion")),
+                        declURI(TestHeaderURI)),
+                  AllOf(qName("Test"), declRange(Header.range("spelling")),
+                        declURI(TestHeaderURI))));
 }
 
 TEST_F(SymbolCollectorTest, SymbolFormedByCLI) {
   Annotations Header(R"(
     #ifdef NAME
     class $expansion[[NAME]] {};
     #endif
   )");
   runSymbolCollector(Header.code(), /*Main=*/"", /*ExtraArgs=*/{"-DNAME=name"});
   EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(
-                           QName("name"), DeclRange(Header.range("expansion")),
-                           DeclURI(TestHeaderURI))));
+                           qName("name"), declRange(Header.range("expansion")),
+                           declURI(TestHeaderURI))));
 }
 
 TEST_F(SymbolCollectorTest, SymbolsInMainFile) {
   const std::string Main = R"(
     class Foo {};
     void f1();
     inline void f2() {}
 
     namespace {
     void ff() {}
     }
     namespace foo {
     namespace {
     class Bar {};
     }
     }
     void main_f() {}
     void f1() {}
   )";
   runSymbolCollector(/*Header=*/"", Main);
   EXPECT_THAT(Symbols, UnorderedElementsAre(
-                           QName("Foo"), QName("f1"), QName("f2"), QName("ff"),
-                           QName("foo"), QName("foo::Bar"), QName("main_f")));
+                           qName("Foo"), qName("f1"), qName("f2"), qName("ff"),
+                           qName("foo"), qName("foo::Bar"), qName("main_f")));
 }
 
 TEST_F(SymbolCollectorTest, Documentation) {
   const std::string Header = R"(
-    // Doc Foo
+    // doc Foo
     class Foo {
-      // Doc f
+      // doc f
       int f();
     };
   )";
   CollectorOpts.StoreAllDocumentation = false;
   runSymbolCollector(Header, /* Main */ "");
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("Foo"), Doc("Doc Foo"), ForCodeCompletion(true)),
-                  AllOf(QName("Foo::f"), Doc(""), ReturnType(""),
-                        ForCodeCompletion(false))));
+                  AllOf(qName("Foo"), doc("doc Foo"), forCodeCompletion(true)),
+                  AllOf(qName("Foo::f"), doc(""), returnType(""),
+                        forCodeCompletion(false))));
 
   CollectorOpts.StoreAllDocumentation = true;
   runSymbolCollector(Header, /* Main */ "");
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("Foo"), Doc("Doc Foo"), ForCodeCompletion(true)),
-                  AllOf(QName("Foo::f"), Doc("Doc f"), ReturnType(""),
-                        ForCodeCompletion(false))));
+                  AllOf(qName("Foo"), doc("doc Foo"), forCodeCompletion(true)),
+                  AllOf(qName("Foo::f"), doc("doc f"), returnType(""),
+                        forCodeCompletion(false))));
 }
 
 TEST_F(SymbolCollectorTest, ClassMembers) {
   const std::string Header = R"(
     class Foo {
       void f() {}
       void g();
       static void sf() {}
       static void ssf();
       static int x;
     };
   )";
   const std::string Main = R"(
     void Foo::g() {}
     void Foo::ssf() {}
   )";
   runSymbolCollector(Header, Main);
   EXPECT_THAT(
       Symbols,
       UnorderedElementsAre(
-          QName("Foo"),
-          AllOf(QName("Foo::f"), ReturnType(""), ForCodeCompletion(false)),
-          AllOf(QName("Foo::g"), ReturnType(""), ForCodeCompletion(false)),
-          AllOf(QName("Foo::sf"), ReturnType(""), ForCodeCompletion(false)),
-          AllOf(QName("Foo::ssf"), ReturnType(""), ForCodeCompletion(false)),
-          AllOf(QName("Foo::x"), ReturnType(""), ForCodeCompletion(false))));
+          qName("Foo"),
+          AllOf(qName("Foo::f"), returnType(""), forCodeCompletion(false)),
+          AllOf(qName("Foo::g"), returnType(""), forCodeCompletion(false)),
+          AllOf(qName("Foo::sf"), returnType(""), forCodeCompletion(false)),
+          AllOf(qName("Foo::ssf"), returnType(""), forCodeCompletion(false)),
+          AllOf(qName("Foo::x"), returnType(""), forCodeCompletion(false))));
 }
 
 TEST_F(SymbolCollectorTest, Scopes) {
   const std::string Header = R"(
     namespace na {
     class Foo {};
     namespace nb {
     class Bar {};
     }
     }
   )";
   runSymbolCollector(Header, /*Main=*/"");
   EXPECT_THAT(Symbols,
-              UnorderedElementsAre(QName("na"), QName("na::nb"),
-                                   QName("na::Foo"), QName("na::nb::Bar")));
+              UnorderedElementsAre(qName("na"), qName("na::nb"),
+                                   qName("na::Foo"), qName("na::nb::Bar")));
 }
 
 TEST_F(SymbolCollectorTest, ExternC) {
   const std::string Header = R"(
     extern "C" { class Foo {}; }
     namespace na {
     extern "C" { class Bar {}; }
     }
   )";
   runSymbolCollector(Header, /*Main=*/"");
-  EXPECT_THAT(Symbols, UnorderedElementsAre(QName("na"), QName("Foo"),
-                                            QName("na::Bar")));
+  EXPECT_THAT(Symbols, UnorderedElementsAre(qName("na"), qName("Foo"),
+                                            qName("na::Bar")));
 }
 
 TEST_F(SymbolCollectorTest, SkipInlineNamespace) {
   const std::string Header = R"(
     namespace na {
     inline namespace nb {
     class Foo {};
     }
     }
     namespace na {
     // This is still inlined.
     namespace nb {
     class Bar {};
     }
     }
   )";
   runSymbolCollector(Header, /*Main=*/"");
   EXPECT_THAT(Symbols,
-              UnorderedElementsAre(QName("na"), QName("na::nb"),
-                                   QName("na::Foo"), QName("na::Bar")));
+              UnorderedElementsAre(qName("na"), qName("na::nb"),
+                                   qName("na::Foo"), qName("na::Bar")));
 }
 
 TEST_F(SymbolCollectorTest, SymbolWithDocumentation) {
   const std::string Header = R"(
     namespace nx {
     /// Foo comment.
     int ff(int x, double y) { return 0; }
     }
   )";
   runSymbolCollector(Header, /*Main=*/"");
   EXPECT_THAT(
       Symbols,
       UnorderedElementsAre(
-          QName("nx"), AllOf(QName("nx::ff"), Labeled("ff(int x, double y)"),
-                             ReturnType("int"), Doc("Foo comment."))));
+          qName("nx"), AllOf(qName("nx::ff"), labeled("ff(int x, double y)"),
+                             returnType("int"), doc("Foo comment."))));
 }
 
-TEST_F(SymbolCollectorTest, Snippet) {
+TEST_F(SymbolCollectorTest, snippet) {
   const std::string Header = R"(
     namespace nx {
     void f() {}
     int ff(int x, double y) { return 0; }
     }
   )";
   runSymbolCollector(Header, /*Main=*/"");
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  QName("nx"),
-                  AllOf(QName("nx::f"), Labeled("f()"), Snippet("f()")),
-                  AllOf(QName("nx::ff"), Labeled("ff(int x, double y)"),
-                        Snippet("ff(${1:int x}, ${2:double y})"))));
+                  qName("nx"),
+                  AllOf(qName("nx::f"), labeled("f()"), snippet("f()")),
+                  AllOf(qName("nx::ff"), labeled("ff(int x, double y)"),
+                        snippet("ff(${1:int x}, ${2:double y})"))));
 }
 
 TEST_F(SymbolCollectorTest, IncludeHeaderSameAsFileURI) {
   CollectorOpts.CollectIncludePath = true;
   runSymbolCollector("#pragma once\nclass Foo {};", /*Main=*/"");
   EXPECT_THAT(Symbols, UnorderedElementsAre(
-                           AllOf(QName("Foo"), DeclURI(TestHeaderURI))));
+                           AllOf(qName("Foo"), declURI(TestHeaderURI))));
   EXPECT_THAT(Symbols.begin()->IncludeHeaders,
               UnorderedElementsAre(IncludeHeaderWithRef(TestHeaderURI, 1u)));
 }
 
 TEST_F(SymbolCollectorTest, CanonicalSTLHeader) {
   CollectorOpts.CollectIncludePath = true;
   CanonicalIncludes Includes;
   auto Language = LangOptions();
   Language.CPlusPlus = true;
   Includes.addSystemHeadersMapping(Language);
   CollectorOpts.Includes = &Includes;
   runSymbolCollector(
       R"cpp(
       namespace std {
         class string {};
         // Move overloads have special handling.
         template <typename _T> T&& move(_T&& __value);
         template <typename _I, typename _O> _O move(_I, _I, _O);
       }
       )cpp",
       /*Main=*/"");
   EXPECT_THAT(
       Symbols,
       UnorderedElementsAre(
-          QName("std"),
-          AllOf(QName("std::string"), DeclURI(TestHeaderURI),
-                IncludeHeader("<string>")),
+          qName("std"),
+          AllOf(qName("std::string"), declURI(TestHeaderURI),
+                includeHeader("<string>")),
           // Parameter names are demangled.
-          AllOf(Labeled("move(T &&value)"), IncludeHeader("<utility>")),
-          AllOf(Labeled("move(I, I, O)"), IncludeHeader("<algorithm>"))));
+          AllOf(labeled("move(T &&value)"), includeHeader("<utility>")),
+          AllOf(labeled("move(I, I, O)"), includeHeader("<algorithm>"))));
 }
 
 TEST_F(SymbolCollectorTest, IWYUPragma) {
   CollectorOpts.CollectIncludePath = true;
   CanonicalIncludes Includes;
   PragmaHandler = collectIWYUHeaderMaps(&Includes);
   CollectorOpts.Includes = &Includes;
   const std::string Header = R"(
     // IWYU pragma: private, include the/good/header.h
     class Foo {};
   )";
   runSymbolCollector(Header, /*Main=*/"");
   EXPECT_THAT(Symbols, UnorderedElementsAre(
-                           AllOf(QName("Foo"), DeclURI(TestHeaderURI),
-                                 IncludeHeader("\"the/good/header.h\""))));
+                           AllOf(qName("Foo"), declURI(TestHeaderURI),
+                                 includeHeader("\"the/good/header.h\""))));
 }
 
 TEST_F(SymbolCollectorTest, IWYUPragmaWithDoubleQuotes) {
   CollectorOpts.CollectIncludePath = true;
   CanonicalIncludes Includes;
   PragmaHandler = collectIWYUHeaderMaps(&Includes);
   CollectorOpts.Includes = &Includes;
   const std::string Header = R"(
     // IWYU pragma: private, include "the/good/header.h"
     class Foo {};
   )";
   runSymbolCollector(Header, /*Main=*/"");
   EXPECT_THAT(Symbols, UnorderedElementsAre(
-                           AllOf(QName("Foo"), DeclURI(TestHeaderURI),
-                                 IncludeHeader("\"the/good/header.h\""))));
+                           AllOf(qName("Foo"), declURI(TestHeaderURI),
+                                 includeHeader("\"the/good/header.h\""))));
 }
 
 TEST_F(SymbolCollectorTest, SkipIncFileWhenCanonicalizeHeaders) {
   CollectorOpts.CollectIncludePath = true;
   CanonicalIncludes Includes;
   Includes.addMapping(TestHeaderName, "<canonical>");
   CollectorOpts.Includes = &Includes;
   auto IncFile = testPath("test.inc");
   auto IncURI = URI::create(IncFile).toString();
   InMemoryFileSystem->addFile(IncFile, 0,
                               llvm::MemoryBuffer::getMemBuffer("class X {};"));
   runSymbolCollector("#include \"test.inc\"\nclass Y {};", /*Main=*/"",
                      /*ExtraArgs=*/{"-I", testRoot()});
   EXPECT_THAT(Symbols,
-              UnorderedElementsAre(AllOf(QName("X"), DeclURI(IncURI),
-                                         IncludeHeader("<canonical>")),
-                                   AllOf(QName("Y"), DeclURI(TestHeaderURI),
-                                         IncludeHeader("<canonical>"))));
+              UnorderedElementsAre(AllOf(qName("X"), declURI(IncURI),
+                                         includeHeader("<canonical>")),
+                                   AllOf(qName("Y"), declURI(TestHeaderURI),
+                                         includeHeader("<canonical>"))));
 }
 
 TEST_F(SymbolCollectorTest, MainFileIsHeaderWhenSkipIncFile) {
   CollectorOpts.CollectIncludePath = true;
   // To make this case as hard as possible, we won't tell clang main is a
   // header. No extension, no -x c++-header.
   TestFileName = testPath("no_ext_main");
   TestFileURI = URI::create(TestFileName).toString();
   auto IncFile = testPath("test.inc");
   auto IncURI = URI::create(IncFile).toString();
   InMemoryFileSystem->addFile(IncFile, 0,
                               llvm::MemoryBuffer::getMemBuffer("class X {};"));
   runSymbolCollector("", R"cpp(
     // Can't use #pragma once in a main file clang doesn't think is a header.
     #ifndef MAIN_H_
     #define MAIN_H_
     #include "test.inc"
     #endif
   )cpp",
                      /*ExtraArgs=*/{"-I", testRoot()});
-  EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(QName("X"), DeclURI(IncURI),
-                                                  IncludeHeader(TestFileURI))));
+  EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(qName("X"), declURI(IncURI),
+                                                  includeHeader(TestFileURI))));
 }
 
 TEST_F(SymbolCollectorTest, IncFileInNonHeader) {
   CollectorOpts.CollectIncludePath = true;
   TestFileName = testPath("main.cc");
   TestFileURI = URI::create(TestFileName).toString();
   auto IncFile = testPath("test.inc");
   auto IncURI = URI::create(IncFile).toString();
   InMemoryFileSystem->addFile(IncFile, 0,
                               llvm::MemoryBuffer::getMemBuffer("class X {};"));
   runSymbolCollector("", R"cpp(
     #include "test.inc"
   )cpp",
                      /*ExtraArgs=*/{"-I", testRoot()});
-  EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(QName("X"), DeclURI(IncURI),
-                                                  Not(IncludeHeader()))));
+  EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(qName("X"), declURI(IncURI),
+                                                  Not(includeHeader()))));
 }
 
 // Features that depend on header-guards are fragile. Header guards are only
 // recognized when the file ends, so we have to defer checking for them.
 TEST_F(SymbolCollectorTest, HeaderGuardDetected) {
   CollectorOpts.CollectIncludePath = true;
   CollectorOpts.CollectMacro = true;
   runSymbolCollector(R"cpp(
     #ifndef HEADER_GUARD_
     #define HEADER_GUARD_
 
     // Symbols are seen before the header guard is complete.
     #define MACRO
     int decl();
 
     #endif // Header guard is recognized here.
   )cpp",
                      "");
-  EXPECT_THAT(Symbols, Not(Contains(QName("HEADER_GUARD_"))));
-  EXPECT_THAT(Symbols, Each(IncludeHeader()));
+  EXPECT_THAT(Symbols, Not(Contains(qName("HEADER_GUARD_"))));
+  EXPECT_THAT(Symbols, Each(includeHeader()));
 }
 
 TEST_F(SymbolCollectorTest, NonModularHeader) {
   auto TU = TestTU::withHeaderCode("int x();");
-  EXPECT_THAT(TU.headerSymbols(), ElementsAre(IncludeHeader()));
+  EXPECT_THAT(TU.headerSymbols(), ElementsAre(includeHeader()));
 
   // Files missing include guards aren't eligible for insertion.
   TU.ImplicitHeaderGuard = false;
-  EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(IncludeHeader())));
+  EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(includeHeader())));
 
   // We recognize some patterns of trying to prevent insertion.
   TU = TestTU::withHeaderCode(R"cpp(
 #ifndef SECRET
 #error "This file isn't safe to include directly"
 #endif
     int x();
     )cpp");
   TU.ExtraArgs.push_back("-DSECRET"); // *we're* able to include it.
-  EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(IncludeHeader())));
+  EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(includeHeader())));
 }
 
 TEST_F(SymbolCollectorTest, AvoidUsingFwdDeclsAsCanonicalDecls) {
   CollectorOpts.CollectIncludePath = true;
   Annotations Header(R"(
     #pragma once
     // Forward declarations of TagDecls.
     class C;
     struct S;
     union U;
 
     // Canonical declarations.
     class $cdecl[[C]] {};
     struct $sdecl[[S]] {};
     union $udecl[[U]] {int $xdecl[[x]]; bool $ydecl[[y]];};
   )");
   runSymbolCollector(Header.code(), /*Main=*/"");
   EXPECT_THAT(
       Symbols,
       UnorderedElementsAre(
-          AllOf(QName("C"), DeclURI(TestHeaderURI),
-                DeclRange(Header.range("cdecl")), IncludeHeader(TestHeaderURI),
-                DefURI(TestHeaderURI), DefRange(Header.range("cdecl"))),
-          AllOf(QName("S"), DeclURI(TestHeaderURI),
-                DeclRange(Header.range("sdecl")), IncludeHeader(TestHeaderURI),
-                DefURI(TestHeaderURI), DefRange(Header.range("sdecl"))),
-          AllOf(QName("U"), DeclURI(TestHeaderURI),
-                DeclRange(Header.range("udecl")), IncludeHeader(TestHeaderURI),
-                DefURI(TestHeaderURI), DefRange(Header.range("udecl"))),
-          AllOf(QName("U::x"), DeclURI(TestHeaderURI),
-                DeclRange(Header.range("xdecl")), DefURI(TestHeaderURI),
-                DefRange(Header.range("xdecl"))),
-          AllOf(QName("U::y"), DeclURI(TestHeaderURI),
-                DeclRange(Header.range("ydecl")), DefURI(TestHeaderURI),
-                DefRange(Header.range("ydecl")))));
+          AllOf(qName("C"), declURI(TestHeaderURI),
+                declRange(Header.range("cdecl")), includeHeader(TestHeaderURI),
+                defURI(TestHeaderURI), defRange(Header.range("cdecl"))),
+          AllOf(qName("S"), declURI(TestHeaderURI),
+                declRange(Header.range("sdecl")), includeHeader(TestHeaderURI),
+                defURI(TestHeaderURI), defRange(Header.range("sdecl"))),
+          AllOf(qName("U"), declURI(TestHeaderURI),
+                declRange(Header.range("udecl")), includeHeader(TestHeaderURI),
+                defURI(TestHeaderURI), defRange(Header.range("udecl"))),
+          AllOf(qName("U::x"), declURI(TestHeaderURI),
+                declRange(Header.range("xdecl")), defURI(TestHeaderURI),
+                defRange(Header.range("xdecl"))),
+          AllOf(qName("U::y"), declURI(TestHeaderURI),
+                declRange(Header.range("ydecl")), defURI(TestHeaderURI),
+                defRange(Header.range("ydecl")))));
 }
 
 TEST_F(SymbolCollectorTest, ClassForwardDeclarationIsCanonical) {
   CollectorOpts.CollectIncludePath = true;
   runSymbolCollector(/*Header=*/"#pragma once\nclass X;",
                      /*Main=*/"class X {};");
   EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(
-                           QName("X"), DeclURI(TestHeaderURI),
-                           IncludeHeader(TestHeaderURI), DefURI(TestFileURI))));
+                           qName("X"), declURI(TestHeaderURI),
+                           includeHeader(TestHeaderURI), defURI(TestFileURI))));
 }
 
 TEST_F(SymbolCollectorTest, UTF16Character) {
   // ö is 2-bytes.
   Annotations Header(/*Header=*/"class [[pörk]] {};");
   runSymbolCollector(Header.code(), /*Main=*/"");
   EXPECT_THAT(Symbols, UnorderedElementsAre(
-                           AllOf(QName("pörk"), DeclRange(Header.range()))));
+                           AllOf(qName("pörk"), declRange(Header.range()))));
 }
 
 TEST_F(SymbolCollectorTest, DoNotIndexSymbolsInFriendDecl) {
   Annotations Header(R"(
     namespace nx {
       class $z[[Z]] {};
       class X {
         friend class Y;
         friend class Z;
         friend void foo();
         friend void $bar[[bar]]() {}
       };
       class $y[[Y]] {};
       void $foo[[foo]]();
     }
   )");
   runSymbolCollector(Header.code(), /*Main=*/"");
 
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  QName("nx"), QName("nx::X"),
-                  AllOf(QName("nx::Y"), DeclRange(Header.range("y"))),
-                  AllOf(QName("nx::Z"), DeclRange(Header.range("z"))),
-                  AllOf(QName("nx::foo"), DeclRange(Header.range("foo"))),
-                  AllOf(QName("nx::bar"), DeclRange(Header.range("bar")))));
+                  qName("nx"), qName("nx::X"),
+                  AllOf(qName("nx::Y"), declRange(Header.range("y"))),
+                  AllOf(qName("nx::Z"), declRange(Header.range("z"))),
+                  AllOf(qName("nx::foo"), declRange(Header.range("foo"))),
+                  AllOf(qName("nx::bar"), declRange(Header.range("bar")))));
 }
 
 TEST_F(SymbolCollectorTest, ReferencesInFriendDecl) {
   const std::string Header = R"(
     class X;
     class Y;
   )";
   const std::string Main = R"(
     class C {
       friend ::X;
       friend class Y;
     };
   )";
   CollectorOpts.CountReferences = true;
   runSymbolCollector(Header, Main);
-  EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(QName("X"), RefCount(1)),
-                                            AllOf(QName("Y"), RefCount(1)),
-                                            AllOf(QName("C"), RefCount(0))));
+  EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(qName("X"), refCount(1)),
+                                            AllOf(qName("Y"), refCount(1)),
+                                            AllOf(qName("C"), refCount(0))));
 }
 
 TEST_F(SymbolCollectorTest, Origin) {
   CollectorOpts.Origin = SymbolOrigin::Static;
   runSymbolCollector("class Foo {};", /*Main=*/"");
   EXPECT_THAT(Symbols, UnorderedElementsAre(
                            Field(&Symbol::Origin, SymbolOrigin::Static)));
   runSymbolCollector("#define FOO", /*Main=*/"");
Annotations Main(R"(
      USED(t);
   )");
   CollectorOpts.CountReferences = true;
   CollectorOpts.CollectMacro = true;
   runSymbolCollector(Header.code(), Main.code());
   EXPECT_THAT(
       Symbols,
       UnorderedElementsAre(
-          QName("p"), QName("t"),
-          AllOf(QName("X"), DeclURI(TestHeaderURI),
-                IncludeHeader(TestHeaderURI)),
-          AllOf(Labeled("MAC(x)"), RefCount(0),
-
-                DeclRange(Header.range("mac")), VisibleOutsideFile()),
-          AllOf(Labeled("USED(y)"), RefCount(1),
-                DeclRange(Header.range("used")), VisibleOutsideFile()),
-          AllOf(Labeled("MAIN"), RefCount(0), DeclRange(Main.range("main")),
-                Not(VisibleOutsideFile()))));
+          qName("p"), qName("t"),
+          AllOf(qName("X"), declURI(TestHeaderURI),
+                includeHeader(TestHeaderURI)),
+          AllOf(labeled("MAC(x)"), refCount(0),
+
+                declRange(Header.range("mac")), visibleOutsideFile()),
+          AllOf(labeled("USED(y)"), refCount(1),
+                declRange(Header.range("used")), visibleOutsideFile()),
+          AllOf(labeled("MAIN"), refCount(0), declRange(Main.range("main")),
+                Not(visibleOutsideFile()))));
 }
 
 TEST_F(SymbolCollectorTest, DeprecatedSymbols) {
   const std::string Header = R"(
     void TestClangc() __attribute__((deprecated("", "")));
     void TestClangd();
   )";
   runSymbolCollector(Header, /**/ "");
   EXPECT_THAT(Symbols, UnorderedElementsAre(
-                           AllOf(QName("TestClangc"), Deprecated()),
-                           AllOf(QName("TestClangd"), Not(Deprecated()))));
+                           AllOf(qName("TestClangc"), deprecated()),
+                           AllOf(qName("TestClangd"), Not(deprecated()))));
 }
 
-TEST_F(SymbolCollectorTest, ImplementationDetail) {
+TEST_F(SymbolCollectorTest, implementationDetail) {
   const std::string Header = R"(
     #define DECL_NAME(x, y) x##_##y##_Decl
     #define DECL(x, y) class DECL_NAME(x, y) {};
     DECL(X, Y); // X_Y_Decl
 
     class Public {};
   )";
   runSymbolCollector(Header, /**/ "");
   EXPECT_THAT(Symbols,
               UnorderedElementsAre(
-                  AllOf(QName("X_Y_Decl"), ImplementationDetail()),
-                  AllOf(QName("Public"), Not(ImplementationDetail()))));
+                  AllOf(qName("X_Y_Decl"), implementationDetail()),
+                  AllOf(qName("Public"), Not(implementationDetail()))));
 }
 
 TEST_F(SymbolCollectorTest, UsingDecl) {
   const char *Header = R"(
   void foo();
   namespace std {
     using ::foo;
   })";
   runSymbolCollector(Header, /**/ "");
-  EXPECT_THAT(Symbols, Contains(QName("std::foo")));
+  EXPECT_THAT(Symbols, Contains(qName("std::foo")));
 }
 
 TEST_F(SymbolCollectorTest, CBuiltins) {
   // In C, printf in stdio.h is a redecl of an implicit builtin.
   const char *Header = R"(
     extern int printf(const char*, ...);
   )";
   runSymbolCollector(Header, /**/ "", {"-xc"});
-  EXPECT_THAT(Symbols, Contains(QName("printf")));
+  EXPECT_THAT(Symbols, Contains(qName("printf")));
 }
 
 TEST_F(SymbolCollectorTest, InvalidSourceLoc) {
   const char *Header = R"(
       void operator delete(void*)
         __attribute__((__externally_visible__));)";
   runSymbolCollector(Header, /**/ "");
-  EXPECT_THAT(Symbols, Contains(QName("operator delete")));
+  EXPECT_THAT(Symbols, Contains(qName("operator delete")));
 }
 
 TEST_F(SymbolCollectorTest, BadUTF8) {
   // Extracted from boost/spirit/home/support/char_encoding/iso8859_1.hpp
   // This looks like UTF-8 and fools clang, but has high-ISO-8859-1 comments.
   const char *Header = "int PUNCT = 0;\n"
                        "/* \xa1 */ int types[] = { /* \xa1 */PUNCT };";
   CollectorOpts.RefFilter = RefKind::All;
   CollectorOpts.RefsInHeaders = true;
   runSymbolCollector(Header, "");
-  EXPECT_THAT(Symbols, Contains(AllOf(QName("types"), Doc("\xef\xbf\xbd "))));
-  EXPECT_THAT(Symbols, Contains(QName("PUNCT")));
+  EXPECT_THAT(Symbols, Contains(AllOf(qName("types"), doc("\xef\xbf\xbd "))));
+  EXPECT_THAT(Symbols, Contains(qName("PUNCT")));
   // Reference is stored, although offset within line is not reliable.
   EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "PUNCT").ID, _)));
 }
 
 TEST_F(SymbolCollectorTest, MacrosInHeaders) {
   CollectorOpts.CollectMacro = true;
   TestFileName = testPath("test.h");
   runSymbolCollector("", "#define X");
   EXPECT_THAT(Symbols,
-              UnorderedElementsAre(AllOf(QName("X"), ForCodeCompletion(true))));
+              UnorderedElementsAre(AllOf(qName("X"), forCodeCompletion(true))));
 }
 
 // Regression test for a crash-bug we used to have.
 TEST_F(SymbolCollectorTest, UndefOfModuleMacro) {
   auto TU = TestTU::withCode(R"cpp(#include "bar.h")cpp");
   TU.AdditionalFiles["bar.h"] = R"cpp(
     #include "foo.h"
     #undef X
     )cpp";
   TU.AdditionalFiles["foo.h"] = "#define X 1";
   TU.AdditionalFiles["module.map"] = R"cpp(
     module foo {
      header "foo.h"
      export *
    }
    )cpp";
   TU.ExtraArgs.push_back("-fmodules");
   TU.ExtraArgs.push_back("-fmodule-map-file=" + testPath("module.map"));
   TU.OverlayRealFileSystemForModules = true;
 
   TU.build();
   // We mostly care about not crashing, but verify that we didn't insert garbage
   // about X too.
-  EXPECT_THAT(TU.headerSymbols(), Not(Contains(QName("X"))));
+  EXPECT_THAT(TU.headerSymbols(), Not(Contains(qName("X"))));
 }
 
 TEST_F(SymbolCollectorTest, NoCrashOnObjCMethodCStyleParam) {
   auto TU = TestTU::withCode(R"objc(
     @interface Foo
     - (void)fun:(bool)foo, bool bar;
     @end
   )objc");
   TU.ExtraArgs.push_back("-xobjective-c++");
 
   TU.build();
   // We mostly care about not crashing.
   EXPECT_THAT(TU.headerSymbols(),
-              UnorderedElementsAre(QName("Foo"), QName("Foo::fun:")));
+              UnorderedElementsAre(qName("Foo"), qName("Foo::fun:")));
 }
 
 TEST_F(SymbolCollectorTest, Reserved) {
   const char *Header = R"cpp(
     void __foo();
     namespace _X { int secret; }
   )cpp";
 
   CollectorOpts.CollectReserved = true;
   runSymbolCollector("", Header);
-  EXPECT_THAT(Symbols, UnorderedElementsAre(QName("__foo"), QName("_X"),
-                                            QName("_X::secret")));
+  EXPECT_THAT(Symbols, UnorderedElementsAre(qName("__foo"), qName("_X"),
+                                            qName("_X::secret")));
 
   CollectorOpts.CollectReserved = false;
   runSymbolCollector("", Header); //
   EXPECT_THAT(Symbols, IsEmpty());
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 #include "gtest/gtest.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
 using ::testing::UnorderedElementsAreArray;
 
-auto CreateExpectedSymbolDetails = [](const std::string &name,
-                                      const std::string &container,
+auto CreateExpectedSymbolDetails = [](const std::string &Name,
+                                      const std::string &Container,
                                       const std::string &USR) {
-  return SymbolDetails{name, container, USR, SymbolID(USR)};
+  return SymbolDetails{Name, Container, USR, SymbolID(USR)};
 };
 
 TEST(SymbolInfoTests, All) {
   std::pair<const char *, std::vector<SymbolDetails>>
       TestInputExpectedOutput[] = {
           {
               R"cpp( // Simple function reference - declaration
           void foo();

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

SymbolSlab generateSymbols(std::vector<std::string> QualifiedNames) {
   SymbolSlab::Builder Slab;
   for (llvm::StringRef QName : QualifiedNames)
     Slab.insert(symbol(QName));
   return std::move(Slab).build();
 }
 
 SymbolSlab generateNumSymbols(int Begin, int End) {
   std::vector<std::string> Names;
-  for (int i = Begin; i <= End; i++)
-    Names.push_back(std::to_string(i));
+  for (int I = Begin; I <= End; I++)
+    Names.push_back(std::to_string(I));
   return generateSymbols(Names);
 }
 
 std::string getQualifiedName(const Symbol &Sym) {
   return (Sym.Scope + Sym.Name + Sym.TemplateSpecializationArgs).str();
 }
 
 std::vector<std::string> match(const SymbolIndex &I,

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

 using ::testing::AllOf;
 using ::testing::ElementsAre;
 using ::testing::Field;
 using ::testing::IsEmpty;
 using ::testing::Matcher;
 using ::testing::UnorderedElementsAre;
 
 // GMock helpers for matching TypeHierarchyItem.
-MATCHER_P(WithName, N, "") { return arg.name == N; }
-MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
-MATCHER_P(SelectionRangeIs, R, "") { return arg.selectionRange == R; }
+MATCHER_P(withName, N, "") { return arg.name == N; }
+MATCHER_P(withKind, Kind, "") { return arg.kind == Kind; }
+MATCHER_P(selectionRangeIs, R, "") { return arg.selectionRange == R; }
 template <class... ParentMatchers>
-::testing::Matcher<TypeHierarchyItem> Parents(ParentMatchers... ParentsM) {
+::testing::Matcher<TypeHierarchyItem> parents(ParentMatchers... ParentsM) {
   return Field(&TypeHierarchyItem::parents,
                HasValue(UnorderedElementsAre(ParentsM...)));
 }
 template <class... ChildMatchers>
-::testing::Matcher<TypeHierarchyItem> Children(ChildMatchers... ChildrenM) {
+::testing::Matcher<TypeHierarchyItem> children(ChildMatchers... ChildrenM) {
   return Field(&TypeHierarchyItem::children,
                HasValue(UnorderedElementsAre(ChildrenM...)));
 }
 // Note: "not resolved" is different from "resolved but empty"!
-MATCHER(ParentsNotResolved, "") { return !arg.parents; }
-MATCHER(ChildrenNotResolved, "") { return !arg.children; }
+MATCHER(parentsNotResolved, "") { return !arg.parents; }
+MATCHER(childrenNotResolved, "") { return !arg.children; }
 
 TEST(FindRecordTypeAt, TypeOrVariable) {
   Annotations Source(R"cpp(
 struct Ch^ild2 {
   int c;
 };
 
 using A^lias = Child2;
)cpp");
   const CXXRecordDecl *Parent =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Parent"));
   const CXXRecordDecl *Child =
       dyn_cast<ClassTemplateDecl>(&findDecl(AST, "Child"))->getTemplatedDecl();
 
   EXPECT_THAT(typeParents(Child), ElementsAre(Parent));
 }
 
-MATCHER_P(ImplicitSpecOf, ClassTemplate, "") {
+MATCHER_P(implicitSpecOf, ClassTemplate, "") {
   const ClassTemplateSpecializationDecl *CTS =
       dyn_cast<ClassTemplateSpecializationDecl>(arg);
   return CTS &&
          CTS->getSpecializedTemplate()->getTemplatedDecl() == ClassTemplate &&
          CTS->getSpecializationKind() == TSK_ImplicitInstantiation;
 }
 
 // This is similar to findDecl(AST, QName), but supports using
const CXXRecordDecl *Parent =
       dyn_cast<ClassTemplateDecl>(&findDecl(AST, "Parent"))->getTemplatedDecl();
   const CXXRecordDecl *ParentSpec =
       dyn_cast<CXXRecordDecl>(&findDeclWithTemplateArgs(AST, "Parent<int>"));
   const CXXRecordDecl *Child1 =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Child1"));
   const CXXRecordDecl *Child2 =
       dyn_cast<CXXRecordDecl>(&findDecl(AST, "Child2"));
 
-  EXPECT_THAT(typeParents(Child1), ElementsAre(ImplicitSpecOf(Parent)));
+  EXPECT_THAT(typeParents(Child1), ElementsAre(implicitSpecOf(Parent)));
   EXPECT_THAT(typeParents(Child2), ElementsAre(ParentSpec));
 }
 
 TEST(TypeParents, TemplateSpec2) {
   Annotations Source(R"cpp(
 struct Parent {};
 
 template <typename T>
for (Position Pt : Source.points()) {
     // Set ResolveLevels to 0 because it's only used for Children;
     // for Parents, getTypeHierarchy() always returns all levels.
     llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
         AST, Pt, /*ResolveLevels=*/0, TypeHierarchyDirection::Parents);
     ASSERT_TRUE(bool(Result));
     EXPECT_THAT(
         *Result,
         AllOf(
-            WithName("Child"), WithKind(SymbolKind::Struct),
-            Parents(AllOf(WithName("Parent1"), WithKind(SymbolKind::Struct),
-                          SelectionRangeIs(Source.range("Parent1Def")),
-                          Parents()),
-                    AllOf(WithName("Parent3"), WithKind(SymbolKind::Struct),
-                          SelectionRangeIs(Source.range("Parent3Def")),
-                          Parents(AllOf(
-                              WithName("Parent2"), WithKind(SymbolKind::Struct),
-                              SelectionRangeIs(Source.range("Parent2Def")),
-                              Parents()))))));
+            withName("Child"), withKind(SymbolKind::Struct),
+            parents(AllOf(withName("Parent1"), withKind(SymbolKind::Struct),
+                          selectionRangeIs(Source.range("Parent1Def")),
+                          parents()),
+                    AllOf(withName("Parent3"), withKind(SymbolKind::Struct),
+                          selectionRangeIs(Source.range("Parent3Def")),
+                          parents(AllOf(
+                              withName("Parent2"), withKind(SymbolKind::Struct),
+                              selectionRangeIs(Source.range("Parent2Def")),
+                              parents()))))));
   }
 }
 
 TEST(TypeHierarchy, RecursiveHierarchyUnbounded) {
   Annotations Source(R"cpp(
   template <int N>
   struct $SDef[[S]] : S<N + 1> {};
 
TEST(TypeHierarchy, RecursiveHierarchyUnbounded) {
   // 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.
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.points()[0], 0, TypeHierarchyDirection::Parents);
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(
       *Result,
-      AllOf(WithName("S<0>"), WithKind(SymbolKind::Struct),
-            Parents(
-                AllOf(WithName("S"), WithKind(SymbolKind::Struct),
-                      SelectionRangeIs(Source.range("SDef")),
-                      Parents(AllOf(WithName("S"), WithKind(SymbolKind::Struct),
-                                    SelectionRangeIs(Source.range("SDef")),
-                                    Parents()))))));
+      AllOf(withName("S<0>"), withKind(SymbolKind::Struct),
+            parents(
+                AllOf(withName("S"), withKind(SymbolKind::Struct),
+                      selectionRangeIs(Source.range("SDef")),
+                      parents(AllOf(withName("S"), withKind(SymbolKind::Struct),
+                                    selectionRangeIs(Source.range("SDef")),
+                                    parents()))))));
 }
 
 TEST(TypeHierarchy, RecursiveHierarchyBounded) {
   Annotations Source(R"cpp(
   template <int N>
   struct $SDef[[S]] : S<N - 1> {};
 
   template <>
TEST(TypeHierarchy, RecursiveHierarchyBounded) {
 
   // Make sure getTypeHierarchy() doesn't get into an infinite recursion
   // for either a concrete starting point or a dependent starting point.
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.point("SRefConcrete"), 0, TypeHierarchyDirection::Parents);
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(
       *Result,
-      AllOf(WithName("S<2>"), WithKind(SymbolKind::Struct),
-            Parents(AllOf(
-                WithName("S<1>"), WithKind(SymbolKind::Struct),
-                SelectionRangeIs(Source.range("SDef")),
-                Parents(AllOf(WithName("S<0>"), WithKind(SymbolKind::Struct),
-                              Parents()))))));
+      AllOf(withName("S<2>"), withKind(SymbolKind::Struct),
+            parents(AllOf(
+                withName("S<1>"), withKind(SymbolKind::Struct),
+                selectionRangeIs(Source.range("SDef")),
+                parents(AllOf(withName("S<0>"), withKind(SymbolKind::Struct),
+                              parents()))))));
   Result = getTypeHierarchy(AST, Source.point("SRefDependent"), 0,
                             TypeHierarchyDirection::Parents);
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(
       *Result,
-      AllOf(WithName("S"), WithKind(SymbolKind::Struct),
-            Parents(AllOf(WithName("S"), WithKind(SymbolKind::Struct),
-                          SelectionRangeIs(Source.range("SDef")), Parents()))));
+      AllOf(withName("S"), withKind(SymbolKind::Struct),
+            parents(AllOf(withName("S"), withKind(SymbolKind::Struct),
+                          selectionRangeIs(Source.range("SDef")), parents()))));
 }
 
 TEST(TypeHierarchy, DeriveFromImplicitSpec) {
   Annotations Source(R"cpp(
   template <typename T>
   struct Parent {};
 
   struct Child1 : Parent<int> {};
 
   struct Child2 : Parent<char> {};
 
   Parent<int> Fo^o;
   )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
   auto Index = TU.index();
 
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.points()[0], 2, TypeHierarchyDirection::Children, Index.get(),
       testPath(TU.Filename));
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(*Result,
-              AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
-                    Children(AllOf(WithName("Child1"),
-                                   WithKind(SymbolKind::Struct), Children()),
-                             AllOf(WithName("Child2"),
-                                   WithKind(SymbolKind::Struct), Children()))));
+              AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+                    children(AllOf(withName("Child1"),
+                                   withKind(SymbolKind::Struct), children()),
+                             AllOf(withName("Child2"),
+                                   withKind(SymbolKind::Struct), children()))));
 }
 
 TEST(TypeHierarchy, DeriveFromPartialSpec) {
   Annotations Source(R"cpp(
   template <typename T> struct Parent {};
   template <typename T> struct Parent<T*> {};
 
   struct Child : Parent<int*> {};
 
   Parent<int> Fo^o;
   )cpp");
 
   TestTU TU = TestTU::withCode(Source.code());
   auto AST = TU.build();
   auto Index = TU.index();
 
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.points()[0], 2, TypeHierarchyDirection::Children, Index.get(),
       testPath(TU.Filename));
   ASSERT_TRUE(bool(Result));
-  EXPECT_THAT(*Result, AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
-                             Children()));
+  EXPECT_THAT(*Result, AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+                             children()));
 }
 
 TEST(TypeHierarchy, DeriveFromTemplate) {
   Annotations Source(R"cpp(
   template <typename T>
   struct Parent {};
 
   template <typename T>
TEST(TypeHierarchy, DeriveFromTemplate) {
   // FIXME: We'd like this to show the implicit specializations Parent<int>
   //        and Child<int>, but currently libIndex does not expose relationships
   //        between implicit specializations.
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.points()[0], 2, TypeHierarchyDirection::Children, Index.get(),
       testPath(TU.Filename));
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(*Result,
-              AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
-                    Children(AllOf(WithName("Child"),
-                                   WithKind(SymbolKind::Struct), Children()))));
+              AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+                    children(AllOf(withName("Child"),
+                                   withKind(SymbolKind::Struct), children()))));
 }
 
 TEST(TypeHierarchy, Preamble) {
   Annotations SourceAnnotations(R"cpp(
 struct Ch^ild : Parent {
   int b;
 };)cpp");
 
   Annotations HeaderInPreambleAnnotations(R"cpp(
 struct [[Parent]] {
   int a;
 };)cpp");
 
   TestTU TU = TestTU::withCode(SourceAnnotations.code());
   TU.HeaderCode = HeaderInPreambleAnnotations.code().str();
   auto AST = TU.build();
 
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, SourceAnnotations.point(), 1, TypeHierarchyDirection::Parents);
 
   ASSERT_TRUE(Result);
   EXPECT_THAT(
       *Result,
-      AllOf(WithName("Child"),
-            Parents(AllOf(WithName("Parent"),
-                          SelectionRangeIs(HeaderInPreambleAnnotations.range()),
-                          Parents()))));
+      AllOf(withName("Child"),
+            parents(AllOf(withName("Parent"),
+                          selectionRangeIs(HeaderInPreambleAnnotations.range()),
+                          parents()))));
 }
 
 SymbolID findSymbolIDByName(SymbolIndex *Index, llvm::StringRef Name,
                             llvm::StringRef TemplateArgs = "") {
   SymbolID Result;
   FuzzyFindRequest Request;
   Request.Query = std::string(Name);
   Request.AnyScope = true;
)cpp");
   auto Index = TU.index();
 
   llvm::Optional<TypeHierarchyItem> Result = getTypeHierarchy(
       AST, Source.point(), /*ResolveLevels=*/1,
       TypeHierarchyDirection::Children, Index.get(), testPath(TU.Filename));
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(
       *Result,
-      AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
-            ParentsNotResolved(),
-            Children(AllOf(WithName("Child1"), WithKind(SymbolKind::Struct),
-                           ParentsNotResolved(), ChildrenNotResolved()))));
+      AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+            parentsNotResolved(),
+            children(AllOf(withName("Child1"), withKind(SymbolKind::Struct),
+                           parentsNotResolved(), childrenNotResolved()))));
 
   resolveTypeHierarchy((*Result->children)[0], /*ResolveLevels=*/1,
                        TypeHierarchyDirection::Children, Index.get());
 
   EXPECT_THAT(
       (*Result->children)[0],
-      AllOf(WithName("Child1"), WithKind(SymbolKind::Struct),
-            ParentsNotResolved(),
-            Children(AllOf(WithName("Child2a"), WithKind(SymbolKind::Struct),
-                           ParentsNotResolved(), ChildrenNotResolved()),
-                     AllOf(WithName("Child2b"), WithKind(SymbolKind::Struct),
-                           ParentsNotResolved(), ChildrenNotResolved()))));
+      AllOf(withName("Child1"), withKind(SymbolKind::Struct),
+            parentsNotResolved(),
+            children(AllOf(withName("Child2a"), withKind(SymbolKind::Struct),
+                           parentsNotResolved(), childrenNotResolved()),
+                     AllOf(withName("Child2b"), withKind(SymbolKind::Struct),
+                           parentsNotResolved(), childrenNotResolved()))));
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

 // Force the unittest URI scheme to be linked,
 static int LLVM_ATTRIBUTE_UNUSED UnittestSchemeAnchorDest =
     UnittestSchemeAnchorSource;
 
 namespace {
 
 using ::testing::AllOf;
 
-MATCHER_P(Scheme, S, "") { return arg.scheme() == S; }
-MATCHER_P(Authority, A, "") { return arg.authority() == A; }
-MATCHER_P(Body, B, "") { return arg.body() == B; }
+MATCHER_P(scheme, S, "") { return arg.scheme() == S; }
+MATCHER_P(authority, A, "") { return arg.authority() == A; }
+MATCHER_P(body, B, "") { return arg.body() == B; }
 
 std::string createOrDie(llvm::StringRef AbsolutePath,
                         llvm::StringRef Scheme = "file") {
   auto Uri = URI::create(AbsolutePath, Scheme);
   if (!Uri)
     llvm_unreachable(toString(Uri.takeError()).c_str());
   return Uri->toString();
 }
 
 URI parseOrDie(llvm::StringRef Uri) {
   auto U = URI::parse(Uri);
   if (!U)
     llvm_unreachable(toString(U.takeError()).c_str());
   return *U;
 }
 
 TEST(PercentEncodingTest, Encode) {
-  EXPECT_EQ(URI("x", /*Authority=*/"", "a/b/c").toString(), "x:a/b/c");
-  EXPECT_EQ(URI("x", /*Authority=*/"", "a!b;c~").toString(), "x:a%21b%3Bc~");
-  EXPECT_EQ(URI("x", /*Authority=*/"", "a123b").toString(), "x:a123b");
-  EXPECT_EQ(URI("x", /*Authority=*/"", "a:b;c").toString(), "x:a:b%3Bc");
+  EXPECT_EQ(URI("x", /*authority=*/"", "a/b/c").toString(), "x:a/b/c");
+  EXPECT_EQ(URI("x", /*authority=*/"", "a!b;c~").toString(), "x:a%21b%3Bc~");
+  EXPECT_EQ(URI("x", /*authority=*/"", "a123b").toString(), "x:a123b");
+  EXPECT_EQ(URI("x", /*authority=*/"", "a:b;c").toString(), "x:a:b%3Bc");
 }
 
 TEST(PercentEncodingTest, Decode) {
   EXPECT_EQ(parseOrDie("x:a/b/c").body(), "a/b/c");
 
   EXPECT_EQ(parseOrDie("s%2b://%3a/%3").scheme(), "s+");
   EXPECT_EQ(parseOrDie("s%2b://%3a/%3").authority(), ":");
   EXPECT_EQ(parseOrDie("s%2b://%3a/%3").body(), "/%3");

 TEST(URITest, FailedCreate) {
   EXPECT_ERROR(URI::create("/x/y/z", "no"));
   // Path has to be absolute.
   EXPECT_ERROR(URI::create("x/y/z", "file"));
 }
 
 TEST(URITest, Parse) {
   EXPECT_THAT(parseOrDie("file://auth/x/y/z"),
-              AllOf(Scheme("file"), Authority("auth"), Body("/x/y/z")));
+              AllOf(scheme("file"), authority("auth"), body("/x/y/z")));
 
   EXPECT_THAT(parseOrDie("file://au%3dth/%28x%29/y/%5c%20z"),
-              AllOf(Scheme("file"), Authority("au=th"), Body("/(x)/y/\\ z")));
+              AllOf(scheme("file"), authority("au=th"), body("/(x)/y/\\ z")));
 
   EXPECT_THAT(parseOrDie("file:///%28x%29/y/%5c%20z"),
-              AllOf(Scheme("file"), Authority(""), Body("/(x)/y/\\ z")));
+              AllOf(scheme("file"), authority(""), body("/(x)/y/\\ z")));
   EXPECT_THAT(parseOrDie("file:///x/y/z"),
-              AllOf(Scheme("file"), Authority(""), Body("/x/y/z")));
+              AllOf(scheme("file"), authority(""), body("/x/y/z")));
   EXPECT_THAT(parseOrDie("file:"),
-              AllOf(Scheme("file"), Authority(""), Body("")));
+              AllOf(scheme("file"), authority(""), body("")));
   EXPECT_THAT(parseOrDie("file:///x/y/z%2"),
-              AllOf(Scheme("file"), Authority(""), Body("/x/y/z%2")));
+              AllOf(scheme("file"), authority(""), body("/x/y/z%2")));
   EXPECT_THAT(parseOrDie("http://llvm.org"),
-              AllOf(Scheme("http"), Authority("llvm.org"), Body("")));
+              AllOf(scheme("http"), authority("llvm.org"), body("")));
   EXPECT_THAT(parseOrDie("http://llvm.org/"),
-              AllOf(Scheme("http"), Authority("llvm.org"), Body("/")));
+              AllOf(scheme("http"), authority("llvm.org"), body("/")));
   EXPECT_THAT(parseOrDie("http://llvm.org/D"),
-              AllOf(Scheme("http"), Authority("llvm.org"), Body("/D")));
+              AllOf(scheme("http"), authority("llvm.org"), body("/D")));
   EXPECT_THAT(parseOrDie("http:/"),
-              AllOf(Scheme("http"), Authority(""), Body("/")));
+              AllOf(scheme("http"), authority(""), body("/")));
   EXPECT_THAT(parseOrDie("urn:isbn:0451450523"),
-              AllOf(Scheme("urn"), Authority(""), Body("isbn:0451450523")));
+              AllOf(scheme("urn"), authority(""), body("isbn:0451450523")));
   EXPECT_THAT(
       parseOrDie("file:///c:/windows/system32/"),
-      AllOf(Scheme("file"), Authority(""), Body("/c:/windows/system32/")));
+      AllOf(scheme("file"), authority(""), body("/c:/windows/system32/")));
 }
 
 TEST(URITest, ParseFailed) {
   // Expect ':' in URI.
   EXPECT_ERROR(URI::parse("file//x/y/z"));
   // Empty.
   EXPECT_ERROR(URI::parse(""));
   EXPECT_ERROR(URI::parse(":/a/b/c"));

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

 using ::testing::Not;
 using ::testing::UnorderedElementsAre;
 using ::testing::UnorderedElementsAreArray;
 using ::testing::UnorderedPointwise;
 
 MATCHER_P2(FileRange, File, Range, "") {
   return Location{URIForFile::canonicalize(File, testRoot()), Range} == arg;
 }
-MATCHER(DeclRange, "") {
+MATCHER(declRange, "") {
   const LocatedSymbol &Sym = ::testing::get<0>(arg);
   const Range &Range = ::testing::get<1>(arg);
   return Sym.PreferredDeclaration.range == Range;
 }
 
 // Extracts ranges from an annotated example, and constructs a matcher for a
 // highlight set. Ranges should be named $read/$write as appropriate.
 Matcher<const std::vector<DocumentHighlight> &>
-HighlightsFrom(const Annotations &Test) {
+highlightsFrom(const Annotations &Test) {
   std::vector<DocumentHighlight> Expected;
   auto Add = [&](const Range &R, DocumentHighlightKind K) {
     Expected.emplace_back();
     Expected.back().range = R;
     Expected.back().kind = K;
   };
   for (const auto &Range : Test.ranges())
     Add(Range, DocumentHighlightKind::Text);
const char *Tests[] = {
         }
       )cpp",
   };
   for (const char *Test : Tests) {
     Annotations T(Test);
     auto TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-xobjective-c++");
     auto AST = TU.build();
-    EXPECT_THAT(findDocumentHighlights(AST, T.point()), HighlightsFrom(T))
+    EXPECT_THAT(findDocumentHighlights(AST, T.point()), highlightsFrom(T))
         << Test;
   }
 }
 
 TEST(HighlightsTest, ControlFlow) {
   const char *Tests[] = {
       R"cpp(
         // Highlight same-function returns.
const char *Tests[] = {
         }
       )cpp",
   };
   for (const char *Test : Tests) {
     Annotations T(Test);
     auto TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-fexceptions"); // FIXME: stop testing on PS4.
     auto AST = TU.build();
-    EXPECT_THAT(findDocumentHighlights(AST, T.point()), HighlightsFrom(T))
+    EXPECT_THAT(findDocumentHighlights(AST, T.point()), highlightsFrom(T))
         << Test;
   }
 }
 
-MATCHER_P3(Sym, Name, Decl, DefOrNone, "") {
+MATCHER_P3(sym, Name, Decl, DefOrNone, "") {
   llvm::Optional<Range> Def = DefOrNone;
   if (Name != arg.Name) {
     *result_listener << "Name is " << arg.Name;
     return false;
   }
   if (Decl != arg.PreferredDeclaration.range) {
     *result_listener << "Declaration is "
                      << llvm::to_string(arg.PreferredDeclaration);
MATCHER_P3(sym, Name, Decl, DefOrNone, "") {
   }
   if (arg.Definition->range != *Def) {
     *result_listener << "Definition is " << llvm::to_string(arg.Definition);
     return false;
   }
   return true;
 }
 
-MATCHER_P(Sym, Name, "") { return arg.Name == Name; }
+MATCHER_P(sym, Name, "") { return arg.Name == Name; }
 
-MATCHER_P(RangeIs, R, "") { return arg.Loc.range == R; }
-MATCHER_P(AttrsAre, A, "") { return arg.Attributes == A; }
-MATCHER_P(HasID, ID, "") { return arg.ID == ID; }
+MATCHER_P(rangeIs, R, "") { return arg.Loc.range == R; }
+MATCHER_P(attrsAre, A, "") { return arg.Attributes == A; }
+MATCHER_P(hasID, ID, "") { return arg.ID == ID; }
 
 TEST(LocateSymbol, WithIndex) {
   Annotations SymbolHeader(R"cpp(
         class $forward[[Forward]];
         class $foo[[Foo]] {};
 
         void $f1[[f1]]();
 
TEST(LocateSymbol, WithIndex) {
 
   Annotations Test(R"cpp(// only declaration in AST.
         void [[f1]]();
         int main() {
           ^f1();
         }
       )cpp");
   EXPECT_THAT(LocateWithIndex(Test),
-              ElementsAre(Sym("f1", Test.range(), SymbolCpp.range("f1"))));
+              ElementsAre(sym("f1", Test.range(), SymbolCpp.range("f1"))));
 
   Test = Annotations(R"cpp(// definition in AST.
         void [[f1]]() {}
         int main() {
           ^f1();
         }
       )cpp");
   EXPECT_THAT(LocateWithIndex(Test),
-              ElementsAre(Sym("f1", SymbolHeader.range("f1"), Test.range())));
+              ElementsAre(sym("f1", SymbolHeader.range("f1"), Test.range())));
 
   Test = Annotations(R"cpp(// forward declaration in AST.
         class [[Foo]];
         F^oo* create();
       )cpp");
   EXPECT_THAT(LocateWithIndex(Test),
-              ElementsAre(Sym("Foo", Test.range(), SymbolHeader.range("foo"))));
+              ElementsAre(sym("Foo", Test.range(), SymbolHeader.range("foo"))));
 
   Test = Annotations(R"cpp(// definition in AST.
         class [[Forward]] {};
         F^orward create();
       )cpp");
   EXPECT_THAT(
       LocateWithIndex(Test),
-      ElementsAre(Sym("Forward", SymbolHeader.range("forward"), Test.range())));
+      ElementsAre(sym("Forward", SymbolHeader.range("forward"), Test.range())));
 }
 
 TEST(LocateSymbol, AnonymousStructFields) {
   auto Code = Annotations(R"cpp(
     struct $2[[Foo]] {
       struct { int $1[[x]]; };
       void foo() {
         // Make sure the implicit base is skipped.
         $1^x = 42;
       }
     };
     // Check that we don't skip explicit bases.
     int a = $2^Foo{}.x;
   )cpp");
   TestTU TU = TestTU::withCode(Code.code());
   auto AST = TU.build();
   EXPECT_THAT(locateSymbolAt(AST, Code.point("1"), TU.index().get()),
-              UnorderedElementsAre(Sym("x", Code.range("1"), Code.range("1"))));
+              UnorderedElementsAre(sym("x", Code.range("1"), Code.range("1"))));
   EXPECT_THAT(
       locateSymbolAt(AST, Code.point("2"), TU.index().get()),
-      UnorderedElementsAre(Sym("Foo", Code.range("2"), Code.range("2"))));
+      UnorderedElementsAre(sym("Foo", Code.range("2"), Code.range("2"))));
 }
 
 TEST(LocateSymbol, FindOverrides) {
   auto Code = Annotations(R"cpp(
     class Foo {
       virtual void $1[[fo^o]]() = 0;
     };
     class Bar : public Foo {
       void $2[[foo]]() override;
     };
   )cpp");
   TestTU TU = TestTU::withCode(Code.code());
   auto AST = TU.build();
   EXPECT_THAT(locateSymbolAt(AST, Code.point(), TU.index().get()),
-              UnorderedElementsAre(Sym("foo", Code.range("1"), llvm::None),
-                                   Sym("foo", Code.range("2"), llvm::None)));
+              UnorderedElementsAre(sym("foo", Code.range("1"), llvm::None),
+                                   sym("foo", Code.range("2"), llvm::None)));
 }
 
 TEST(LocateSymbol, WithIndexPreferredLocation) {
   Annotations SymbolHeader(R"cpp(
         class $p[[Proto]] {};
         void $f[[func]]() {};
       )cpp");
   TestTU TU;
Annotations Test(R"cpp(// only declaration in AST.
           return nullptr;
         }
       )cpp");
 
   auto AST = TestTU::withCode(Test.code()).build();
   {
     auto Locs = clangd::locateSymbolAt(AST, Test.point("p"), Index.get());
     auto CodeGenLoc = SymbolHeader.range("p");
-    EXPECT_THAT(Locs, ElementsAre(Sym("Proto", CodeGenLoc, CodeGenLoc)));
+    EXPECT_THAT(Locs, ElementsAre(sym("Proto", CodeGenLoc, CodeGenLoc)));
   }
   {
     auto Locs = clangd::locateSymbolAt(AST, Test.point("f"), Index.get());
     auto CodeGenLoc = SymbolHeader.range("f");
-    EXPECT_THAT(Locs, ElementsAre(Sym("func", CodeGenLoc, CodeGenLoc)));
+    EXPECT_THAT(Locs, ElementsAre(sym("func", CodeGenLoc, CodeGenLoc)));
   }
 }
 
 TEST(LocateSymbol, All) {
   // Ranges in tests:
   //   $decl is the declaration location (if absent, no symbol is located)
   //   $def is the definition location (if absent, symbol has no definition)
   //   unnamed range becomes both $decl and $def.
auto T = Annotations(R"cpp(
     int add(int x, int y) { return $MACRO^MACRO(x, y); }
     int sum = $add^add(1, 2);
   )cpp");
 
   TestTU TU = TestTU::withCode(T.code());
   auto AST = TU.build();
   auto Index = TU.index();
   EXPECT_THAT(locateSymbolAt(AST, T.point("add"), Index.get()),
-              ElementsAre(AllOf(Sym("add"),
-                                HasID(getSymbolID(&findDecl(AST, "add"))))));
+              ElementsAre(AllOf(sym("add"),
+                                hasID(getSymbolID(&findDecl(AST, "add"))))));
   EXPECT_THAT(
       locateSymbolAt(AST, T.point("MACRO"), Index.get()),
-      ElementsAre(AllOf(Sym("MACRO"),
-                        HasID(findSymbol(TU.headerSymbols(), "MACRO").ID))));
+      ElementsAre(AllOf(sym("MACRO"),
+                        hasID(findSymbol(TU.headerSymbols(), "MACRO").ID))));
 }
 
 TEST(LocateSymbol, AllMulti) {
   // Ranges in tests:
   //   $declN is the declaration location
   //   $defN is the definition location (if absent, symbol has no definition)
   //
   // NOTE:
auto T = Annotations(
         // Comment mentioning M^yClass
       )cpp");
 
   auto TU = TestTU::withCode(T.code());
   auto AST = TU.build();
   auto Index = TU.index();
   EXPECT_THAT(
       locateSymbolAt(AST, T.point(), Index.get()),
-      ElementsAre(AllOf(Sym("MyClass", T.range(), T.range()),
-                        HasID(getSymbolID(&findDecl(AST, "MyClass"))))));
+      ElementsAre(AllOf(sym("MyClass", T.range(), T.range()),
+                        hasID(getSymbolID(&findDecl(AST, "MyClass"))))));
 }
 
 TEST(LocateSymbol, Textual) {
   const char *Tests[] = {
       R"cpp(// Comment
         struct [[MyClass]] {};
         // Comment mentioning M^yClass
       )cpp",
auto T = Annotations(R"cpp(
     }
   )cpp");
   auto TU = TestTU::withCode(T.code());
   // FIXME: Go-to-definition in a template requires disabling delayed template
   // parsing.
   TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
   auto AST = TU.build();
   // Ordered assertions are deliberate: we expect a predictable order.
-  EXPECT_THAT(locateSymbolAt(AST, T.point("1")), ElementsAre(Sym("str")));
-  EXPECT_THAT(locateSymbolAt(AST, T.point("2")), ElementsAre(Sym("str")));
-  EXPECT_THAT(locateSymbolAt(AST, T.point("3")), ElementsAre(Sym("f")));
-  EXPECT_THAT(locateSymbolAt(AST, T.point("4")), ElementsAre(Sym("g")));
-  EXPECT_THAT(locateSymbolAt(AST, T.point("5")), ElementsAre(Sym("f")));
-  EXPECT_THAT(locateSymbolAt(AST, T.point("6")), ElementsAre(Sym("str")));
+  EXPECT_THAT(locateSymbolAt(AST, T.point("1")), ElementsAre(sym("str")));
+  EXPECT_THAT(locateSymbolAt(AST, T.point("2")), ElementsAre(sym("str")));
+  EXPECT_THAT(locateSymbolAt(AST, T.point("3")), ElementsAre(sym("f")));
+  EXPECT_THAT(locateSymbolAt(AST, T.point("4")), ElementsAre(sym("g")));
+  EXPECT_THAT(locateSymbolAt(AST, T.point("5")), ElementsAre(sym("f")));
+  EXPECT_THAT(locateSymbolAt(AST, T.point("6")), ElementsAre(sym("str")));
   // FIXME: Target the constructor as well.
-  EXPECT_THAT(locateSymbolAt(AST, T.point("7")), ElementsAre(Sym("abc")));
+  EXPECT_THAT(locateSymbolAt(AST, T.point("7")), ElementsAre(sym("abc")));
   // FIXME: Target the constructor as well.
-  EXPECT_THAT(locateSymbolAt(AST, T.point("8")), ElementsAre(Sym("abcd")));
+  EXPECT_THAT(locateSymbolAt(AST, T.point("8")), ElementsAre(sym("abcd")));
   // FIXME: Target the constructor as well.
-  EXPECT_THAT(locateSymbolAt(AST, T.point("9")), ElementsAre(Sym("Foo")));
+  EXPECT_THAT(locateSymbolAt(AST, T.point("9")), ElementsAre(sym("Foo")));
   EXPECT_THAT(locateSymbolAt(AST, T.point("10")),
-              ElementsAre(Sym("Foo", T.range("ConstructorLoc"), llvm::None)));
+              ElementsAre(sym("Foo", T.range("ConstructorLoc"), llvm::None)));
   EXPECT_THAT(locateSymbolAt(AST, T.point("11")),
-              ElementsAre(Sym("Foo", T.range("ConstructorLoc"), llvm::None)));
+              ElementsAre(sym("Foo", T.range("ConstructorLoc"), llvm::None)));
   // These assertions are unordered because the order comes from
   // CXXRecordDecl::lookupDependentName() which doesn't appear to provide
   // an order guarantee.
   EXPECT_THAT(locateSymbolAt(AST, T.point("12")),
               UnorderedElementsAre(
-                  Sym("bar", T.range("NonstaticOverload1"), llvm::None),
-                  Sym("bar", T.range("NonstaticOverload2"), llvm::None)));
+                  sym("bar", T.range("NonstaticOverload1"), llvm::None),
+                  sym("bar", T.range("NonstaticOverload2"), llvm::None)));
   EXPECT_THAT(
       locateSymbolAt(AST, T.point("13")),
-      UnorderedElementsAre(Sym("baz", T.range("StaticOverload1"), llvm::None),
-                           Sym("baz", T.range("StaticOverload2"), llvm::None)));
+      UnorderedElementsAre(sym("baz", T.range("StaticOverload1"), llvm::None),
+                           sym("baz", T.range("StaticOverload2"), llvm::None)));
 }
 
 TEST(LocateSymbol, TextualDependent) {
   // Put the declarations in the header to make sure we are
   // finding them via the index heuristic and not the
   // nearby-ident heuristic.
   Annotations Header(R"cpp(
         struct Foo {
TEST(LocateSymbol, TextualDependent) {
   auto AST = TU.build();
   auto Index = TU.index();
   // Need to use locateSymbolAt() since we are testing an
   // interaction between locateASTReferent() and
   // locateSymbolNamedTextuallyAt().
   auto Results = locateSymbolAt(AST, Source.point(), Index.get());
   EXPECT_THAT(Results,
               UnorderedElementsAre(
-                  Sym("uniqueMethodName", Header.range("FooLoc"), llvm::None),
-                  Sym("uniqueMethodName", Header.range("BarLoc"), llvm::None)));
+                  sym("uniqueMethodName", Header.range("FooLoc"), llvm::None),
+                  sym("uniqueMethodName", Header.range("BarLoc"), llvm::None)));
 }
 
 TEST(LocateSymbol, Alias) {
   const char *Tests[] = {
       R"cpp(
       template <class T> struct function {};
       template <class T> using [[callback]] = function<T()>;
 
const char *Tests[] = {
     )cpp",
   };
 
   for (const auto *Case : Tests) {
     SCOPED_TRACE(Case);
     auto T = Annotations(Case);
     auto AST = TestTU::withCode(T.code()).build();
     EXPECT_THAT(locateSymbolAt(AST, T.point()),
-                UnorderedPointwise(DeclRange(), T.ranges()));
+                UnorderedPointwise(declRange(), T.ranges()));
   }
 }
 
 TEST(LocateSymbol, RelPathsInCompileCommand) {
   // The source is in "/clangd-test/src".
   // We build in "/clangd-test/build".
 
   Annotations SourceAnnotations(R"cpp(
FS.Files[HeaderNotInPreambleH] =
       std::string(HeaderNotInPreambleAnnotations.code());
 
   runAddDocument(Server, FooCpp, SourceAnnotations.code());
 
   // Go to a definition in main source file.
   auto Locations =
       runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("p1"));
   EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
-  EXPECT_THAT(*Locations, ElementsAre(Sym("foo", SourceAnnotations.range(),
+  EXPECT_THAT(*Locations, ElementsAre(sym("foo", SourceAnnotations.range(),
                                           SourceAnnotations.range())));
 
   // Go to a definition in header_in_preamble.h.
   Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("p2"));
   EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
   EXPECT_THAT(
       *Locations,
-      ElementsAre(Sym("bar_preamble", HeaderInPreambleAnnotations.range(),
+      ElementsAre(sym("bar_preamble", HeaderInPreambleAnnotations.range(),
                       HeaderInPreambleAnnotations.range())));
 
   // Go to a definition in header_not_in_preamble.h.
   Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("p3"));
   EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
   EXPECT_THAT(*Locations,
-              ElementsAre(Sym("bar_not_preamble",
+              ElementsAre(sym("bar_not_preamble",
                               HeaderNotInPreambleAnnotations.range(),
                               HeaderNotInPreambleAnnotations.range())));
 }
 
 TEST(GoToInclude, All) {
   MockFS FS;
   MockCompilationDatabase CDB;
   ClangdServer Server(CDB, FS, ClangdServer::optsForTest());
TEST(GoToInclude, All) {
   FS.Files[FooH] = std::string(HeaderAnnotations.code());
 
   runAddDocument(Server, FooH, HeaderAnnotations.code());
   runAddDocument(Server, FooCpp, SourceAnnotations.code());
 
   // Test include in preamble.
   auto Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point());
   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
-  EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+  EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
                                           HeaderAnnotations.range())));
 
   // Test include in preamble, last char.
   Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("2"));
   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
-  EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+  EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
                                           HeaderAnnotations.range())));
 
   Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("3"));
   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
-  EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+  EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
                                           HeaderAnnotations.range())));
 
   // Test include outside of preamble.
   Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("6"));
   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
-  EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+  EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
                                           HeaderAnnotations.range())));
 
   // Test a few positions that do not result in Locations.
   Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("4"));
   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
   EXPECT_THAT(*Locations, IsEmpty());
 
   Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("5"));
   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
-  EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+  EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
                                           HeaderAnnotations.range())));
 
   Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("7"));
   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
-  EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+  EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
                                           HeaderAnnotations.range())));
 
   // Objective C #import directive.
   Annotations ObjC(R"objc(
   #import "^foo.h"
   )objc");
   auto FooM = testPath("foo.m");
   FS.Files[FooM] = std::string(ObjC.code());
 
   runAddDocument(Server, FooM, ObjC.code());
   Locations = runLocateSymbolAt(Server, FooM, ObjC.point());
   ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
-  EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+  EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
                                           HeaderAnnotations.range())));
 }
 
 TEST(LocateSymbol, WithPreamble) {
   // Test stragety: AST should always use the latest preamble instead of last
   // good preamble.
   MockFS FS;
   MockCompilationDatabase CDB;
TEST(LocateSymbol, WithPreamble) {
   auto FooH = testPath("foo.h");
   Annotations FooHeader(R"cpp([[]])cpp");
   FS.Files[FooH] = std::string(FooHeader.code());
 
   runAddDocument(Server, FooCpp, FooWithHeader.code());
   // LocateSymbol goes to a #include file: the result comes from the preamble.
   EXPECT_THAT(
       cantFail(runLocateSymbolAt(Server, FooCpp, FooWithHeader.point())),
-      ElementsAre(Sym("foo.h", FooHeader.range(), FooHeader.range())));
+      ElementsAre(sym("foo.h", FooHeader.range(), FooHeader.range())));
 
   // Only preamble is built, and no AST is built in this request.
   Server.addDocument(FooCpp, FooWithoutHeader.code(), "null",
                      WantDiagnostics::No);
   // We build AST here, and it should use the latest preamble rather than the
   // stale one.
   EXPECT_THAT(
       cantFail(runLocateSymbolAt(Server, FooCpp, FooWithoutHeader.point())),
-      ElementsAre(Sym("foo", FooWithoutHeader.range(), llvm::None)));
+      ElementsAre(sym("foo", FooWithoutHeader.range(), llvm::None)));
 
   // Reset test environment.
   runAddDocument(Server, FooCpp, FooWithHeader.code());
   // Both preamble and AST are built in this request.
   Server.addDocument(FooCpp, FooWithoutHeader.code(), "null",
                      WantDiagnostics::Yes);
   // Use the AST being built in above request.
   EXPECT_THAT(
       cantFail(runLocateSymbolAt(Server, FooCpp, FooWithoutHeader.point())),
-      ElementsAre(Sym("foo", FooWithoutHeader.range(), llvm::None)));
+      ElementsAre(sym("foo", FooWithoutHeader.range(), llvm::None)));
 }
 
 TEST(LocateSymbol, NearbyTokenSmoke) {
   auto T = Annotations(R"cpp(
     // prints e^rr and crashes
     void die(const char* [[err]]);
   )cpp");
   auto AST = TestTU::withCode(T.code()).build();
   // We don't pass an index, so can't hit index-based fallback.
   EXPECT_THAT(locateSymbolAt(AST, T.point()),
-              ElementsAre(Sym("err", T.range(), T.range())));
+              ElementsAre(sym("err", T.range(), T.range())));
 }
 
 TEST(LocateSymbol, NearbyIdentifier) {
   const char *Tests[] = {
       R"cpp(
       // regular identifiers (won't trigger)
       int hello;
       int y = he^llo;
TEST(FindImplementations, Inheritance) {
 
   Annotations Code(Test);
   auto TU = TestTU::withCode(Code.code());
   auto AST = TU.build();
   auto Index = TU.index();
   for (StringRef Label : {"0", "1", "2", "3", "4", "5", "6", "7"}) {
     for (const auto &Point : Code.points(Label)) {
       EXPECT_THAT(findImplementations(AST, Point, Index.get()),
-                  UnorderedPointwise(DeclRange(), Code.ranges(Label)))
+                  UnorderedPointwise(declRange(), Code.ranges(Label)))
           << Code.code() << " at " << Point << " for Label " << Label;
     }
   }
 }
 
 TEST(FindImplementations, CaptureDefintion) {
   llvm::StringRef Test = R"cpp(
     struct Base {
       virtual void F^oo();
     };
     struct Child1 : Base {
       void $Decl[[Foo]]() override;
     };
     struct Child2 : Base {
       void $Child2[[Foo]]() override;
     };
     void Child1::$Def[[Foo]]() { /* Definition */ }
   )cpp";
   Annotations Code(Test);
   auto TU = TestTU::withCode(Code.code());
   auto AST = TU.build();
   EXPECT_THAT(
       findImplementations(AST, Code.point(), TU.index().get()),
-      UnorderedElementsAre(Sym("Foo", Code.range("Decl"), Code.range("Def")),
-                           Sym("Foo", Code.range("Child2"), llvm::None)))
+      UnorderedElementsAre(sym("Foo", Code.range("Decl"), Code.range("Def")),
+                           sym("Foo", Code.range("Child2"), llvm::None)))
       << Test;
 }
 
 TEST(FindType, All) {
   Annotations HeaderA(R"cpp(
     struct [[Target]] { operator int() const; };
     struct Aggregate { Target a, b; };
     Target t;
for (const llvm::StringRef Case : {
        }) {
     Annotations A(Case);
     TU.Code = A.code().str();
     ParsedAST AST = TU.build();
 
     ASSERT_GT(A.points().size(), 0u) << Case;
     for (auto Pos : A.points())
       EXPECT_THAT(findType(AST, Pos),
-                  ElementsAre(Sym("Target", HeaderA.range(), HeaderA.range())))
+                  ElementsAre(sym("Target", HeaderA.range(), HeaderA.range())))
           << Case;
   }
 
   // FIXME: We'd like these cases to work. Fix them and move above.
   for (const llvm::StringRef Case : {
            "smart_ptr<Target> ^tsmart;",
        }) {
     Annotations A(Case);
     TU.Code = A.code().str();
     ParsedAST AST = TU.build();
 
     EXPECT_THAT(findType(AST, A.point()),
-                Not(Contains(Sym("Target", HeaderA.range(), HeaderA.range()))))
+                Not(Contains(sym("Target", HeaderA.range(), HeaderA.range()))))
         << Case;
   }
 }
 
 void checkFindRefs(llvm::StringRef Test, bool UseIndex = false) {
   Annotations T(Test);
   auto TU = TestTU::withCode(T.code());
   auto AST = TU.build();
   std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
   for (const auto &R : T.ranges())
-    ExpectedLocations.push_back(AllOf(RangeIs(R), AttrsAre(0u)));
+    ExpectedLocations.push_back(AllOf(rangeIs(R), attrsAre(0u)));
   // $def is actually shorthand for both definition and declaration.
   // If we have cases that are definition-only, we should change this.
   for (const auto &R : T.ranges("def"))
     ExpectedLocations.push_back(
-        AllOf(RangeIs(R), AttrsAre(ReferencesResult::Definition |
+        AllOf(rangeIs(R), attrsAre(ReferencesResult::Definition |
                                    ReferencesResult::Declaration)));
   for (const auto &R : T.ranges("decl"))
     ExpectedLocations.push_back(
-        AllOf(RangeIs(R), AttrsAre(ReferencesResult::Declaration)));
+        AllOf(rangeIs(R), attrsAre(ReferencesResult::Declaration)));
   for (const auto &R : T.ranges("overridedecl"))
     ExpectedLocations.push_back(AllOf(
-        RangeIs(R),
-        AttrsAre(ReferencesResult::Declaration | ReferencesResult::Override)));
+        rangeIs(R),
+        attrsAre(ReferencesResult::Declaration | ReferencesResult::Override)));
   for (const auto &R : T.ranges("overridedef"))
     ExpectedLocations.push_back(
-        AllOf(RangeIs(R), AttrsAre(ReferencesResult::Declaration |
+        AllOf(rangeIs(R), attrsAre(ReferencesResult::Declaration |
                                    ReferencesResult::Definition |
                                    ReferencesResult::Override)));
   for (const auto &P : T.points()) {
     EXPECT_THAT(findReferences(AST, P, 0, UseIndex ? TU.index().get() : nullptr)
                     .References,
                 UnorderedElementsAreArray(ExpectedLocations))
         << "Failed for Refs at " << P << "\n"
         << Test;
TEST(FindReferences, MainFileReferencesOnly) {
   auto TU = TestTU::withCode(Code.code());
   TU.AdditionalFiles["foo.inc"] = R"cpp(
       foo = 3;
     )cpp";
   auto AST = TU.build();
 
   std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
   for (const auto &R : Code.ranges())
-    ExpectedLocations.push_back(RangeIs(R));
+    ExpectedLocations.push_back(rangeIs(R));
   EXPECT_THAT(findReferences(AST, Code.point(), 0).References,
               ElementsAreArray(ExpectedLocations))
       << Test;
 }
 
 TEST(FindReferences, ExplicitSymbols) {
   const char *Tests[] = {
       R"cpp(
TEST(FindReferences, NeedsIndexForSymbols) {
   TestTU TU;
   TU.Code = std::string(Main.code());
   TU.HeaderCode = Header;
   auto AST = TU.build();
 
   // References in main file are returned without index.
   EXPECT_THAT(
       findReferences(AST, Main.point(), 0, /*Index=*/nullptr).References,
-      ElementsAre(RangeIs(Main.range())));
+      ElementsAre(rangeIs(Main.range())));
   Annotations IndexedMain(R"cpp(
     int [[foo]]() { return 42; }
   )cpp");
 
   // References from indexed files are included.
   TestTU IndexedTU;
   IndexedTU.Code = std::string(IndexedMain.code());
   IndexedTU.Filename = "Indexed.cpp";
   IndexedTU.HeaderCode = Header;
   EXPECT_THAT(
       findReferences(AST, Main.point(), 0, IndexedTU.index().get()).References,
-      ElementsAre(RangeIs(Main.range()),
-                  AllOf(RangeIs(IndexedMain.range()),
-                        AttrsAre(ReferencesResult::Declaration |
+      ElementsAre(rangeIs(Main.range()),
+                  AllOf(rangeIs(IndexedMain.range()),
+                        attrsAre(ReferencesResult::Declaration |
                                  ReferencesResult::Definition))));
   auto LimitRefs =
       findReferences(AST, Main.point(), /*Limit*/ 1, IndexedTU.index().get());
   EXPECT_EQ(1u, LimitRefs.References.size());
   EXPECT_TRUE(LimitRefs.HasMore);
 
   // Avoid indexed results for the main file. Use AST for the mainfile.
   TU.Code = ("\n\n" + Main.code()).str();
   EXPECT_THAT(findReferences(AST, Main.point(), 0, TU.index().get()).References,
-              ElementsAre(RangeIs(Main.range())));
+              ElementsAre(rangeIs(Main.range())));
 }
 
 TEST(FindReferences, NeedsIndexForMacro) {
   const char *Header = "#define MACRO(X) (X+1)";
   Annotations Main(R"cpp(
     int main() {
       int a = [[MA^CRO]](1);
     }
   )cpp");
   TestTU TU;
   TU.Code = std::string(Main.code());
   TU.HeaderCode = Header;
   auto AST = TU.build();
 
   // References in main file are returned without index.
   EXPECT_THAT(
       findReferences(AST, Main.point(), 0, /*Index=*/nullptr).References,
-      ElementsAre(RangeIs(Main.range())));
+      ElementsAre(rangeIs(Main.range())));
 
   Annotations IndexedMain(R"cpp(
     int indexed_main() {
       int a = [[MACRO]](1);
     }
   )cpp");
 
   // References from indexed files are included.
   TestTU IndexedTU;
   IndexedTU.Code = std::string(IndexedMain.code());
   IndexedTU.Filename = "Indexed.cpp";
   IndexedTU.HeaderCode = Header;
   EXPECT_THAT(
       findReferences(AST, Main.point(), 0, IndexedTU.index().get()).References,
-      ElementsAre(RangeIs(Main.range()), RangeIs(IndexedMain.range())));
+      ElementsAre(rangeIs(Main.range()), rangeIs(IndexedMain.range())));
   auto LimitRefs =
       findReferences(AST, Main.point(), /*Limit*/ 1, IndexedTU.index().get());
   EXPECT_EQ(1u, LimitRefs.References.size());
   EXPECT_TRUE(LimitRefs.HasMore);
 }
 
 TEST(FindReferences, NoQueryForLocalSymbols) {
   struct RecordingIndex : public MemIndex {

clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp

TEST_F(ThreadingTest, TaskRunner) {
   // const var is not required.
   // Making it non-const makes both compilers happy.
   int IncrementsPerTask = 1000;
 
   std::mutex Mutex;
   int Counter(0); /* GUARDED_BY(Mutex) */
   {
     AsyncTaskRunner Tasks;
-    auto scheduleIncrements = [&]() {
+    auto ScheduleIncrements = [&]() {
       for (int TaskI = 0; TaskI < TasksCnt; ++TaskI) {
         Tasks.runAsync("task", [&Counter, &Mutex, IncrementsPerTask]() {
           for (int Increment = 0; Increment < IncrementsPerTask; ++Increment) {
             std::lock_guard<std::mutex> Lock(Mutex);
             ++Counter;
           }
         });
       }
     };
 
     {
       // Make sure runAsync is not running tasks synchronously on the same
       // thread by locking the Mutex used for increments.
       std::lock_guard<std::mutex> Lock(Mutex);
-      scheduleIncrements();
+      ScheduleIncrements();
     }
 
     Tasks.wait();
     {
       std::lock_guard<std::mutex> Lock(Mutex);
       ASSERT_EQ(Counter, TasksCnt * IncrementsPerTask);
     }
 
     {
       std::lock_guard<std::mutex> Lock(Mutex);
       Counter = 0;
-      scheduleIncrements();
+      ScheduleIncrements();
     }
   }
   // Check that destructor has waited for tasks to finish.
   std::lock_guard<std::mutex> Lock(Mutex);
   ASSERT_EQ(Counter, TasksCnt * IncrementsPerTask);
 }
 
 TEST_F(ThreadingTest, Memoize) {

clang-tools-extra/clangd/unittests/support/TraceTests.cpp

 namespace clangd {
 namespace {
 
 using testing::_;
 using testing::ElementsAre;
 using testing::SizeIs;
 using testing::StartsWith;
 
-MATCHER_P(StringNode, Val, "") {
+MATCHER_P(stringNode, Val, "") {
   if (arg->getType() != llvm::yaml::Node::NK_Scalar) {
     *result_listener << "is a " << arg->getVerbatimTag();
     return false;
   }
   llvm::SmallString<32> S;
   return Val == static_cast<llvm::yaml::ScalarNode *>(arg)->getValue(S);
 }
 
 // Checks that N is a Mapping (JS object) with the expected scalar properties.
 // The object must have all the Expected properties, but may have others.
-bool VerifyObject(llvm::yaml::Node &N,
+bool verifyObject(llvm::yaml::Node &N,
                   std::map<std::string, std::string> Expected) {
   auto *M = llvm::dyn_cast<llvm::yaml::MappingNode>(&N);
   if (!M) {
     ADD_FAILURE() << "Not an object";
     return false;
   }
   bool Match = true;
   llvm::SmallString<32> Tmp;
TEST(TraceTest, SmokeTest) {
   bool ThreadsHaveNames = !ThreadName.empty();
 
   // We expect in order:
   //   displayTimeUnit: "ns"
   //   traceEvents: [process name, thread name, start span, log, end span]
   // (The order doesn't matter, but the YAML parser is awkward to use otherwise)
   auto Prop = Root->begin();
   ASSERT_NE(Prop, Root->end()) << "Expected displayTimeUnit property";
-  ASSERT_THAT(Prop->getKey(), StringNode("displayTimeUnit"));
-  EXPECT_THAT(Prop->getValue(), StringNode("ns"));
+  ASSERT_THAT(Prop->getKey(), stringNode("displayTimeUnit"));
+  EXPECT_THAT(Prop->getValue(), stringNode("ns"));
   ASSERT_NE(++Prop, Root->end()) << "Expected traceEvents property";
-  EXPECT_THAT(Prop->getKey(), StringNode("traceEvents"));
+  EXPECT_THAT(Prop->getKey(), stringNode("traceEvents"));
   auto *Events =
       llvm::dyn_cast_or_null<llvm::yaml::SequenceNode>(Prop->getValue());
   ASSERT_NE(Events, nullptr) << "traceEvents should be an array";
   auto Event = Events->begin();
   ASSERT_NE(Event, Events->end()) << "Expected process name";
-  EXPECT_TRUE(VerifyObject(*Event, {{"ph", "M"}, {"name", "process_name"}}));
+  EXPECT_TRUE(verifyObject(*Event, {{"ph", "M"}, {"name", "process_name"}}));
   if (ThreadsHaveNames) {
     ASSERT_NE(++Event, Events->end()) << "Expected thread name";
-    EXPECT_TRUE(VerifyObject(*Event, {{"ph", "M"}, {"name", "thread_name"}}));
+    EXPECT_TRUE(verifyObject(*Event, {{"ph", "M"}, {"name", "thread_name"}}));
   }
   ASSERT_NE(++Event, Events->end()) << "Expected log message";
-  EXPECT_TRUE(VerifyObject(*Event, {{"ph", "i"}, {"name", "Log"}}));
+  EXPECT_TRUE(verifyObject(*Event, {{"ph", "i"}, {"name", "Log"}}));
   ASSERT_NE(++Event, Events->end()) << "Expected span end";
-  EXPECT_TRUE(VerifyObject(*Event, {{"ph", "X"}, {"name", "A"}}));
+  EXPECT_TRUE(verifyObject(*Event, {{"ph", "X"}, {"name", "A"}}));
   ASSERT_EQ(++Event, Events->end());
   ASSERT_EQ(++Prop, Root->end());
 }
 
 TEST(MetricsTracer, LatencyTest) {
   trace::TestTracer Tracer;
   constexpr llvm::StringLiteral MetricName = "span_latency";
   constexpr llvm::StringLiteral OpName = "op_name";