diff --git a/clang-tools-extra/clangd/ClangdLSPServer.cpp b/clang-tools-extra/clangd/ClangdLSPServer.cpp
--- a/clang-tools-extra/clangd/ClangdLSPServer.cpp
+++ b/clang-tools-extra/clangd/ClangdLSPServer.cpp
@@ -71,8 +71,8 @@
   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.
@@ -88,7 +88,7 @@
   //        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;
@@ -949,7 +949,7 @@
   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;
@@ -1484,8 +1484,8 @@
   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");
diff --git a/clang-tools-extra/clangd/SourceCode.cpp b/clang-tools-extra/clangd/SourceCode.cpp
--- a/clang-tools-extra/clangd/SourceCode.cpp
+++ b/clang-tools-extra/clangd/SourceCode.cpp
@@ -1176,10 +1176,10 @@
     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 {
diff --git a/clang-tools-extra/clangd/TUScheduler.cpp b/clang-tools-extra/clangd/TUScheduler.cpp
--- a/clang-tools-extra/clangd/TUScheduler.cpp
+++ b/clang-tools-extra/clangd/TUScheduler.cpp
@@ -100,10 +100,10 @@
 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;
 }
@@ -1231,7 +1231,7 @@
     }
 
     // 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));
@@ -1659,7 +1659,7 @@
   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]() {
diff --git a/clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp b/clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp
--- a/clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp
+++ b/clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp
@@ -71,29 +71,29 @@
   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
diff --git a/clang-tools-extra/clangd/fuzzer/FuzzerClangdMain.cpp b/clang-tools-extra/clangd/fuzzer/FuzzerClangdMain.cpp
--- a/clang-tools-extra/clangd/fuzzer/FuzzerClangdMain.cpp
+++ b/clang-tools-extra/clangd/fuzzer/FuzzerClangdMain.cpp
@@ -12,6 +12,7 @@
 
 #include "llvm/FuzzMutate/FuzzerCLI.h"
 
+// NOLINTNEXTLINE(readability-identifier-naming)
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size);
 int main(int argc, char *argv[]) {
   return llvm::runFuzzerOnInputs(argc, argv, LLVMFuzzerTestOneInput);
diff --git a/clang-tools-extra/clangd/fuzzer/clangd-fuzzer.cpp b/clang-tools-extra/clangd/fuzzer/clangd-fuzzer.cpp
--- a/clang-tools-extra/clangd/fuzzer/clangd-fuzzer.cpp
+++ b/clang-tools-extra/clangd/fuzzer/clangd-fuzzer.cpp
@@ -19,12 +19,13 @@
 
 using namespace clang::clangd;
 
-extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size) {
-  if (size == 0)
+// NOLINTNEXTLINE(readability-identifier-naming)
+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);
diff --git a/clang-tools-extra/clangd/index/YAMLSerialization.cpp b/clang-tools-extra/clangd/index/YAMLSerialization.cpp
--- a/clang-tools-extra/clangd/index/YAMLSerialization.cpp
+++ b/clang-tools-extra/clangd/index/YAMLSerialization.cpp
@@ -173,19 +173,19 @@
 };
 
 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);
   }
 };
 
diff --git a/clang-tools-extra/clangd/unittests/BackgroundIndexTests.cpp b/clang-tools-extra/clangd/unittests/BackgroundIndexTests.cpp
--- a/clang-tools-extra/clangd/unittests/BackgroundIndexTests.cpp
+++ b/clang-tools-extra/clangd/unittests/BackgroundIndexTests.cpp
@@ -36,7 +36,7 @@
 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.
@@ -225,7 +225,7 @@
   EXPECT_THAT(Syms, UnorderedElementsAre(Named("common")));
   auto Common = *Syms.begin();
   EXPECT_THAT(getRefs(Idx, Common.ID),
-              RefsAre({FileURI("unittest:///root/A.h"),
+              refsAre({FileURI("unittest:///root/A.h"),
                        FileURI("unittest:///root/A.cc"),
                        FileURI("unittest:///root/B.cc"),
                        FileURI("unittest:///root/B.cc"),
@@ -269,7 +269,7 @@
       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; }
@@ -343,8 +343,8 @@
       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;
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -56,11 +56,11 @@
 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...));
 }
@@ -89,20 +89,20 @@
   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());
@@ -134,20 +134,20 @@
   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());
@@ -177,13 +177,13 @@
   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) {
@@ -210,10 +210,10 @@
   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) {
@@ -276,21 +276,21 @@
     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());
@@ -385,21 +385,21 @@
     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());
@@ -450,9 +450,9 @@
   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
diff --git a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
--- a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
@@ -83,10 +83,10 @@
 MATCHER_P(Signature, S, "") { return arg.Signature == S; }
 
 // Shorthand for Contains(Named(Name)).
-Matcher<const std::vector<CodeCompletion> &> Has(std::string 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)));
 }
@@ -255,16 +255,16 @@
 
   // 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) {
@@ -303,16 +303,16 @@
   // 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,
@@ -351,17 +351,17 @@
   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"),
+              AllOf(has("local_var"), has("LocalClass"),
                     Contains(Kind(CompletionItemKind::Snippet))));
   // Check documentation.
   EXPECT_THAT(Results.Completions, Contains(IsDocumented()));
@@ -396,7 +396,7 @@
       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 {
@@ -410,7 +410,7 @@
       }
   )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) {
@@ -437,23 +437,23 @@
 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) {
@@ -535,18 +535,18 @@
       )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(
@@ -678,8 +678,8 @@
       )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) {
@@ -690,8 +690,8 @@
       )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) {
@@ -895,9 +895,9 @@
   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"))));
@@ -1220,7 +1220,7 @@
 
 /// \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;
@@ -1245,10 +1245,10 @@
     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);
@@ -1264,7 +1264,7 @@
       f(^);
     }
   )cpp");
-  EXPECT_THAT(Results.signatures, UnorderedElementsAre(Sig("f() -> void")));
+  EXPECT_THAT(Results.signatures, UnorderedElementsAre(sig("f() -> void")));
 }
 
 TEST(SignatureHelpTest, DefaultArgs) {
@@ -1275,8 +1275,8 @@
   )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);
 }
@@ -1287,7 +1287,7 @@
     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);
 }
@@ -1390,7 +1390,7 @@
   TU.Code = Test.code().str();
   auto Results = signatureHelp(testPath(TU.Filename), Test.point(),
                                *EmptyPreamble, TU.inputs(FS));
-  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);
 }
@@ -2129,11 +2129,11 @@
     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);
@@ -2150,7 +2150,7 @@
   )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>
@@ -2161,7 +2161,7 @@
     })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>
@@ -2173,7 +2173,7 @@
   )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
@@ -2193,7 +2193,7 @@
   )cpp";
 
   EXPECT_THAT(signatures(Sig3).signatures,
-              ElementsAre(Sig("foo([[T]], [[U]]) -> void")));
+              ElementsAre(sig("foo([[T]], [[U]]) -> void")));
 }
 
 TEST(SignatureHelpTest, IndexDocumentation) {
@@ -2214,8 +2214,8 @@
 
   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();
@@ -2232,9 +2232,9 @@
   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) {
@@ -2264,7 +2264,7 @@
   EXPECT_THAT(
       llvm::cantFail(runSignatureHelp(Server, File, FileContent.point()))
           .signatures,
-      ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Member doc"))));
+      ElementsAre(AllOf(sig("foo() -> int"), SigDoc("Member doc"))));
 }
 
 TEST(CompletionTest, CompletionFunctionArgsDisabled) {
@@ -2536,7 +2536,7 @@
       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);
 }
 
@@ -2548,8 +2548,8 @@
       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);
   }
   {
@@ -2559,8 +2559,8 @@
       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);
   }
   {
@@ -2570,8 +2570,8 @@
       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);
   }
   {
@@ -2582,7 +2582,7 @@
       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);
   }
 }
@@ -2599,8 +2599,8 @@
       };
     )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(
@@ -2617,8 +2617,8 @@
       };
     )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 &]])")));
   }
 }
 
@@ -2631,17 +2631,17 @@
   {
     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)));
   }
 }
 
@@ -2655,17 +2655,17 @@
   {
     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)));
   }
 }
 
@@ -2681,17 +2681,17 @@
   {
     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)));
   }
 }
 
@@ -2706,17 +2706,17 @@
   {
     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)));
   }
 }
 
@@ -2728,8 +2728,8 @@
 
   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) {
@@ -3116,7 +3116,7 @@
   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) {
diff --git a/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp b/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp
--- a/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp
@@ -22,7 +22,7 @@
 namespace clang {
 namespace clangd {
 namespace config {
-template <typename T> void PrintTo(const Located<T> &V, std::ostream *OS) {
+template <typename T> void printTo(const Located<T> &V, std::ostream *OS) {
   *OS << ::testing::PrintToString(*V);
 }
 
diff --git a/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp b/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
--- a/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
@@ -45,28 +45,28 @@
 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));
 }
 
@@ -113,10 +113,10 @@
 }
 
 // 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;
 }
 
@@ -163,20 +163,20 @@
           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(
+                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"),
@@ -187,7 +187,7 @@
                "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'")))));
 }
 
@@ -216,7 +216,7 @@
   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";
@@ -224,7 +224,7 @@
       *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) {
@@ -313,7 +313,7 @@
                      "using 'cassert' instead"),
                 DiagSource(Diag::ClangTidy),
                 DiagName("modernize-deprecated-headers"),
-                WithFix(Fix(Test.range("deprecated"), "<cassert>",
+                withFix(Fix(Test.range("deprecated"), "<cassert>",
                             "change '\"assert.h\"' to '<cassert>'"))),
           Diag(Test.range("doubled"),
                "suspicious usage of 'sizeof(sizeof(...))'"),
@@ -323,14 +323,14 @@
                      "macro expansion"),
                 DiagSource(Diag::ClangTidy),
                 DiagName("bugprone-macro-repeated-side-effects"),
-                WithNote(Diag(Test.range("macrodef"),
+                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"),
                 // 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"),
@@ -370,7 +370,7 @@
       *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")))));
 }
@@ -527,7 +527,7 @@
   TestTU TU = TestTU::withCode(Source.code());
   EXPECT_THAT(
       *TU.build().getDiagnostics(),
-      ElementsAre(WithFix(Fix(
+      ElementsAre(withFix(Fix(
           Source.range(),
           "somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier",
           "change 'omereallyreallyreallyreallyreallyreallyreallyreall…' to "
@@ -543,7 +543,7 @@
   )cpp");
   TU.Code = std::string(Source.code());
   EXPECT_THAT(*TU.build().getDiagnostics(),
-              ElementsAre(WithFix(
+              ElementsAre(withFix(
                   Fix(Source.range(), "ident", "change 'ide\\…' to 'ident'"))));
 }
 
@@ -692,7 +692,7 @@
   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(ClangdTest, MSAsm) {
@@ -866,58 +866,58 @@
           {AllOf(Diag(Test.range("nested"),
                       "incomplete type 'ns::X' named in nested name specifier"),
                  DiagName("incomplete_nested_name_spec"),
-                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("base"), "base class has incomplete type"),
                  DiagName("incomplete_base_class"),
-                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("access"),
                       "member access into incomplete type 'ns::X'"),
                  DiagName("incomplete_member_access"),
-                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(
                Diag(
                    Test.range("type"),
                    "incomplete type 'ns::X' where a complete type is required"),
                DiagName("incomplete_type"),
-               WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+               withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                            "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("incomplete"),
                       "variable has incomplete type 'ns::X'"),
                  DiagName("typecheck_decl_incomplete_type"),
-                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(
                Diag(Test.range("tag"), "incomplete definition of type 'ns::X'"),
                DiagName("typecheck_incomplete_tag"),
-               WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+               withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                            "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("use"),
                       "invalid use of incomplete type 'ns::X'"),
                  DiagName("invalid_incomplete_type_use"),
-                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("sizeof"),
                       "invalid application of 'sizeof' to "
                       "an incomplete type 'ns::X'"),
                  DiagName("sizeof_alignof_incomplete_or_sizeless_type"),
-                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("for"),
                       "cannot use incomplete type 'ns::X' as a range"),
                  DiagName("for_range_incomplete_type"),
-                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("return"),
                       "incomplete result type 'ns::X' in function definition"),
                  DiagName("func_def_incomplete_result"),
-                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X"))),
            AllOf(Diag(Test.range("field"), "field has incomplete type 'ns::X'"),
                  DiagName("field_incomplete_or_sizeless"),
-                 WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                 withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                              "Add include \"x.h\" for symbol ns::X")))}))
       << Test.code();
 }
@@ -983,28 +983,28 @@
       UnorderedElementsAre(
           AllOf(Diag(Test.range("unqualified1"), "unknown type name 'X'"),
                 DiagName("unknown_typename"),
-                WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+                withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Add 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",
+                withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Add 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",
+                withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                             "Add 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",
+                withFix(Fix(Test.range("insert"), "#include \"global.h\"\n",
                             "Add 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",
+                withFix(Fix(Test.range("insert"), "#include \"foo.h\"\n",
                             "Add include \"foo.h\" for symbol ns::Foo")))));
 }
 
@@ -1028,7 +1028,7 @@
               UnorderedElementsAre(AllOf(
                   Diag(Test.range("unqualified"), "unknown type name 'X'"),
                   DiagName("unknown_typename"),
-                  WithFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
+                  withFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
                               "Add include \"a.h\" for symbol na::X"),
                           Fix(Test.range("insert"), "#include \"b.h\"\n",
                               "Add include \"b.h\" for symbol na::nb::X")))));
@@ -1109,7 +1109,7 @@
       UnorderedElementsAre(AllOf(
           Diag(Test.range(), "no member named 'scope' in namespace 'ns'"),
           DiagName("no_member"),
-          WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+          withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                       "Add include \"x.h\" for symbol ns::scope::X_Y")))));
 }
 
@@ -1139,26 +1139,26 @@
               Diag(Test.range("q1"), "use of undeclared identifier 'clangd'; "
                                      "did you mean 'clang'?"),
               DiagName("undeclared_var_use_suggest"),
-              WithFix(_, // change clangd to clang
+              withFix(_, // change clangd to clang
                       Fix(Test.range("insert"), "#include \"x.h\"\n",
                           "Add 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",
+              withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                           "Add 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(
+              withFix(
                   _, // change clangd to clang
                   Fix(Test.range("insert"), "#include \"y.h\"\n",
                       "Add 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(Fix(
+                withFix(Fix(
                     Test.range("insert"), "#include \"y.h\"\n",
                     "Add include \"y.h\" for symbol clang::clangd::ns::Y")))));
 }
@@ -1180,7 +1180,7 @@
               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",
+                  withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
                               "Add include \"x.h\" for symbol a::X")))));
 }
 
@@ -1217,7 +1217,7 @@
               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) {
@@ -1324,7 +1324,7 @@
               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) {
@@ -1355,7 +1355,7 @@
               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) {
@@ -1482,9 +1482,9 @@
   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) {
@@ -1520,8 +1520,8 @@
       *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());
diff --git a/clang-tools-extra/clangd/unittests/ExpectedTypeTest.cpp b/clang-tools-extra/clangd/unittests/ExpectedTypeTest.cpp
--- a/clang-tools-extra/clangd/unittests/ExpectedTypeTest.cpp
+++ b/clang-tools-extra/clangd/unittests/ExpectedTypeTest.cpp
@@ -41,7 +41,7 @@
   /// 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
@@ -49,7 +49,7 @@
   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;
@@ -65,13 +65,13 @@
   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().
@@ -101,7 +101,7 @@
 
   EXPECT_THAT(buildEquivClasses({"b", "i", "ui", "ll", "f", "d", "iptr", "bptr",
                                  "user_type"}),
-              ClassesAre({{"b"},
+              classesAre({{"b"},
                           {"i", "ui", "ll"},
                           {"f", "d"},
                           {"iptr"},
@@ -140,10 +140,10 @@
      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);
 }
 
@@ -162,7 +162,7 @@
 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);
 
diff --git a/clang-tools-extra/clangd/unittests/FileIndexTests.cpp b/clang-tools-extra/clangd/unittests/FileIndexTests.cpp
--- a/clang-tools-extra/clangd/unittests/FileIndexTests.cpp
+++ b/clang-tools-extra/clangd/unittests/FileIndexTests.cpp
@@ -67,7 +67,7 @@
 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)));
 }
 
@@ -80,8 +80,8 @@
 
 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());
 }
 
@@ -110,7 +110,7 @@
   EXPECT_THAT(runFuzzyFind(*FS.buildIndex(IndexType::Light), ""),
               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) {
@@ -153,7 +153,7 @@
   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")}));
+  EXPECT_THAT(getRefs(*Symbols, ID), refsAre({FileURI("f1.cc")}));
 
   FS.update("f1", nullptr, nullptr, nullptr, false);
   auto Empty = FS.buildIndex(IndexType::Light);
@@ -162,7 +162,7 @@
 
   EXPECT_THAT(runFuzzyFind(*Symbols, ""),
               UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
-  EXPECT_THAT(getRefs(*Symbols, ID), RefsAre({FileURI("f1.cc")}));
+  EXPECT_THAT(getRefs(*Symbols, ID), refsAre({FileURI("f1.cc")}));
 }
 
 // Adds Basename.cpp, which includes Basename.h, which contains Code.
@@ -362,7 +362,7 @@
   Index.updateMain(testPath(Test2.Filename), AST);
 
   EXPECT_THAT(getRefs(Index, Foo.ID),
-              RefsAre({AllOf(RefRange(MainCode.range("foo")),
+              refsAre({AllOf(RefRange(MainCode.range("foo")),
                              FileURI("unittest:///test.cc")),
                        AllOf(RefRange(MainCode.range("foo")),
                              FileURI("unittest:///test2.cc"))}));
@@ -391,12 +391,12 @@
 
   auto HeaderMacro = findSymbol(Test.headerSymbols(), "HEADER_MACRO");
   EXPECT_THAT(getRefs(Index, HeaderMacro.ID),
-              RefsAre({AllOf(RefRange(MainCode.range("ref1")),
+              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")),
+              refsAre({AllOf(RefRange(MainCode.range("def2")),
                              FileURI("unittest:///test.cc")),
                        AllOf(RefRange(MainCode.range("ref2")),
                              FileURI("unittest:///test.cc"))}));
@@ -470,7 +470,7 @@
   // 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) {
diff --git a/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp b/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
--- a/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
@@ -41,7 +41,7 @@
 // GMock helpers for matching DocumentSymbol.
 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...));
 }
 
@@ -378,52 +378,52 @@
       getSymbols(TU.build()),
       ElementsAreArray(
           {AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
-                 WithDetail("class"), Children()),
+                 WithDetail("class"), children()),
            AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
                  WithDetail("class"),
-                 Children(
+                 children(
                      AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
-                           WithDetail("()"), Children()),
+                           WithDetail("()"), children()),
                      AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
-                           WithDetail("(int)"), Children()),
+                           WithDetail("(int)"), children()),
                      AllOf(WithName("f"), WithKind(SymbolKind::Method),
-                           WithDetail("void ()"), Children()),
+                           WithDetail("void ()"), children()),
                      AllOf(WithName("operator="), WithKind(SymbolKind::Method),
-                           WithDetail("Foo &(const Foo &)"), Children()),
+                           WithDetail("Foo &(const Foo &)"), children()),
                      AllOf(WithName("~Foo"), WithKind(SymbolKind::Constructor),
-                           WithDetail(""), Children()),
+                           WithDetail(""), children()),
                      AllOf(WithName("Nested"), WithKind(SymbolKind::Class),
                            WithDetail("class"),
-                           Children(AllOf(
+                           children(AllOf(
                                WithName("f"), WithKind(SymbolKind::Method),
-                               WithDetail("void ()"), Children()))))),
+                               WithDetail("void ()"), children()))))),
            AllOf(WithName("Friend"), WithKind(SymbolKind::Class),
-                 WithDetail("class"), Children()),
+                 WithDetail("class"), children()),
            AllOf(WithName("f1"), WithKind(SymbolKind::Function),
-                 WithDetail("void ()"), Children()),
+                 WithDetail("void ()"), children()),
            AllOf(WithName("f2"), WithKind(SymbolKind::Function),
-                 WithDetail("void ()"), Children()),
+                 WithDetail("void ()"), children()),
            AllOf(WithName("KInt"), WithKind(SymbolKind::Variable),
-                 WithDetail("const int"), Children()),
+                 WithDetail("const int"), children()),
            AllOf(WithName("kStr"), WithKind(SymbolKind::Variable),
-                 WithDetail("const char *"), Children()),
+                 WithDetail("const char *"), children()),
            AllOf(WithName("f1"), WithKind(SymbolKind::Function),
-                 WithDetail("void ()"), Children()),
+                 WithDetail("void ()"), children()),
            AllOf(
                WithName("foo"), WithKind(SymbolKind::Namespace), WithDetail(""),
-               Children(AllOf(WithName("int32"), WithKind(SymbolKind::Class),
-                              WithDetail("type alias"), Children()),
+               children(AllOf(WithName("int32"), WithKind(SymbolKind::Class),
+                              WithDetail("type alias"), children()),
                         AllOf(WithName("int32_t"), WithKind(SymbolKind::Class),
-                              WithDetail("type alias"), Children()),
+                              WithDetail("type alias"), children()),
                         AllOf(WithName("v1"), WithKind(SymbolKind::Variable),
-                              WithDetail("int"), Children()),
+                              WithDetail("int"), children()),
                         AllOf(WithName("bar"), WithKind(SymbolKind::Namespace),
                               WithDetail(""),
-                              Children(AllOf(WithName("v2"),
+                              children(AllOf(WithName("v2"),
                                              WithKind(SymbolKind::Variable),
-                                             WithDetail("int"), Children()))),
+                                             WithDetail("int"), children()))),
                         AllOf(WithName("baz"), WithKind(SymbolKind::Namespace),
-                              WithDetail(""), Children()),
+                              WithDetail(""), children()),
                         AllOf(WithName("v2"), WithKind(SymbolKind::Namespace),
                               WithDetail(""))))}));
 }
@@ -444,7 +444,7 @@
       ElementsAre(
           AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
                 WithDetail("class"),
-                Children(AllOf(WithName("f"), WithKind(SymbolKind::Method),
+                children(AllOf(WithName("f"), WithKind(SymbolKind::Method),
                                WithDetail("void ()"),
                                SymNameRange(Main.range("decl"))))),
           AllOf(WithName("Foo::f"), WithKind(SymbolKind::Method),
@@ -489,7 +489,7 @@
   EXPECT_THAT(getSymbols(TU.build()),
               ElementsAre(WithName("foo"), WithName("Foo"),
                           AllOf(WithName("ns"),
-                                Children(WithName("bar"), WithName("Bar")))));
+                                children(WithName("bar"), WithName("Bar")))));
 }
 
 TEST(DocumentSymbols, ExportContext) {
@@ -527,12 +527,12 @@
       getSymbols(TU.build()),
       ElementsAre(AllOf(WithName("(anonymous struct)"),
                         WithKind(SymbolKind::Struct), WithDetail("struct"),
-                        Children(AllOf(WithName("InUnnamed"),
+                        children(AllOf(WithName("InUnnamed"),
                                        WithKind(SymbolKind::Field),
-                                       WithDetail("int"), Children()))),
+                                       WithDetail("int"), children()))),
                   AllOf(WithName("UnnamedStruct"),
                         WithKind(SymbolKind::Variable),
-                        WithDetail("struct (unnamed)"), Children())));
+                        WithDetail("struct (unnamed)"), children())));
 }
 
 TEST(DocumentSymbols, InHeaderFile) {
@@ -576,21 +576,21 @@
       ElementsAre(
           AllOf(WithName("Tmpl"), WithKind(SymbolKind::Struct),
                 WithDetail("template struct"),
-                Children(AllOf(WithName("x"), WithKind(SymbolKind::Field),
+                children(AllOf(WithName("x"), WithKind(SymbolKind::Field),
                                WithDetail("T")))),
           AllOf(WithName("Tmpl<int>"), WithKind(SymbolKind::Struct),
                 WithDetail("struct"),
-                Children(AllOf(WithName("y"), WithDetail("int")))),
+                children(AllOf(WithName("y"), WithDetail("int")))),
           AllOf(WithName("Tmpl<float>"), WithKind(SymbolKind::Struct),
-                WithDetail("struct"), Children()),
+                WithDetail("struct"), children()),
           AllOf(WithName("Tmpl<double>"), WithKind(SymbolKind::Struct),
-                WithDetail("struct"), Children()),
+                WithDetail("struct"), children()),
           AllOf(WithName("funcTmpl"), WithDetail("template int (U)"),
-                Children()),
+                children()),
           AllOf(WithName("funcTmpl<int>"), WithDetail("int (double)"),
-                Children()),
-          AllOf(WithName("varTmpl"), WithDetail("template int"), Children()),
-          AllOf(WithName("varTmpl<int>"), WithDetail("double"), Children())));
+                children()),
+          AllOf(WithName("varTmpl"), WithDetail("template int"), children()),
+          AllOf(WithName("varTmpl<int>"), WithDetail("double"), children())));
 }
 
 TEST(DocumentSymbols, Namespaces) {
@@ -622,13 +622,13 @@
       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"))),
+                 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"))))),
+                 children(AllOf(WithName("nb"), children(WithName("Foo"))))),
            AllOf(WithName("na"),
-                 Children(AllOf(WithName("nb"), Children(WithName("Bar")))))}));
+                 children(AllOf(WithName("nb"), children(WithName("Bar")))))}));
 }
 
 TEST(DocumentSymbols, Enums) {
@@ -652,15 +652,15 @@
   EXPECT_THAT(
       getSymbols(TU.build()),
       ElementsAre(
-          AllOf(WithName("(anonymous enum)"), WithDetail("enum"), 
-                Children(AllOf(WithName("Red"), 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")))),
+                children(AllOf(WithName("Green"), WithDetail("Color")))),
           AllOf(WithName("Color2"), WithDetail("enum"),
-                Children(AllOf(WithName("Yellow"), WithDetail("Color2")))),
+                children(AllOf(WithName("Yellow"), WithDetail("Color2")))),
           AllOf(WithName("ns"),
-                Children(AllOf(WithName("(anonymous enum)"), WithDetail("enum"),
-                               Children(AllOf(WithName("Black"),
+                children(AllOf(WithName("(anonymous enum)"), WithDetail("enum"),
+                               children(AllOf(WithName("Black"),
                                               WithDetail("(unnamed)"))))))));
 }
 
@@ -676,7 +676,7 @@
             DEFINE_FLAG(pretty);
           )cpp",
           AllOf(WithName("DEFINE_FLAG"), WithDetail("(pretty)"),
-                Children(WithName("FLAGS_pretty"), WithName("FLAGS_nopretty"))),
+                children(WithName("FLAGS_pretty"), WithName("FLAGS_nopretty"))),
       },
       {
           R"cpp(
@@ -685,9 +685,9 @@
             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"))))))),
+                children(AllOf(WithName("ns"),
+                               children(AllOf(WithName("ID"), WithDetail("(y)"),
+                                              children(WithName("y"))))))),
       },
       {
           R"cpp(
@@ -696,8 +696,8 @@
             TEST(DocumentSymbols, Macro) { }
           )cpp",
           AllOf(WithName("TEST"), WithDetail("(DocumentSymbols, Macro)"),
-                Children(AllOf(WithName("DocumentSymbols_Macro"),
-                               Children(WithName("go"))),
+                children(AllOf(WithName("DocumentSymbols_Macro"),
+                               children(WithName("go"))),
                          WithName("DocumentSymbols_Macro::go"))),
       },
       {
@@ -708,13 +708,13 @@
           )cpp",
           AllOf(
               WithName("NAMESPACE"), WithDetail("(a, NAMESPACE(b, int x;))"),
-              Children(AllOf(
+              children(AllOf(
                   WithName("a"),
-                  Children(AllOf(WithName("NAMESPACE"),
+                  children(AllOf(WithName("NAMESPACE"),
                                  // FIXME: nested expansions not in TokenBuffer
                                  WithDetail(""),
-                                 Children(AllOf(WithName("b"),
-                                                Children(WithName("x"))))))))),
+                                 children(AllOf(WithName("b"),
+                                                children(WithName("x"))))))))),
       },
       {
           R"cpp(
@@ -724,7 +724,7 @@
             OUTER(foo);
           )cpp",
           AllOf(WithName("OUTER"), WithDetail("(foo)"),
-                Children(WithName("foo"))),
+                children(WithName("foo"))),
       },
   };
   for (const Test &T : Tests) {
@@ -758,16 +758,16 @@
       getSymbols(TU.build()),
       ElementsAre(
           AllOf(WithName("FF"), WithDetail("(abc)"),
-                Children(AllOf(WithName("abc_Test"), WithDetail("class"),
+                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"),
+                children(AllOf(WithName("Test"), WithDetail("class"),
                                SymNameRange(Main.range("expansion2"))))),
           AllOf(WithName("FF3"), WithDetail("()"),
                 SymRange(Main.range("fullDef")),
-                Children(AllOf(WithName("waldo"), WithDetail("void ()"),
+                children(AllOf(WithName("waldo"), WithDetail("void ()"),
                                SymRange(Main.range("fullDef")))))));
 }
 
@@ -939,10 +939,10 @@
           AllOf(
               WithName("ns"), WithKind(SymbolKind::Namespace),
               SymRange(Main.range("ns")),
-              Children(AllOf(
+              children(AllOf(
                   WithName("Bar"), WithKind(SymbolKind::Class),
                   WithDetail("class"), SymRange(Main.range("bar")),
-                  Children(
+                  children(
                       AllOf(WithName("Bar"), WithKind(SymbolKind::Constructor),
                             WithDetail("()"), SymRange(Main.range("ctor"))),
                       AllOf(WithName("~Bar"), WithKind(SymbolKind::Constructor),
@@ -957,7 +957,7 @@
                 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),
+                children(AllOf(WithName("Pointer"), WithKind(SymbolKind::Field),
                                WithDetail("int *"),
                                SymRange(Main.range("structfield"))))),
           AllOf(WithName("StructDeclaration"), WithKind(SymbolKind::Struct),
@@ -986,7 +986,7 @@
                 WithDetail("template auto (T, T) -> decltype(x + y)")),
           AllOf(WithName("Pair"), WithDetail("template class")),
           AllOf(WithName("Context"), WithDetail("template struct"),
-                Children(AllOf(
+                children(AllOf(
                     WithName("Pair<type-parameter-0-0, type-parameter-0-1>"),
                     WithDetail("<dependent type>"))))));
 }
@@ -1014,16 +1014,16 @@
       getSymbols(TU.build()),
       ElementsAre(
           AllOf(WithName("Cat"), SymRange(Main.range("Cat")),
-                Children(AllOf(WithName("+sharedCat"),
+                children(AllOf(WithName("+sharedCat"),
                                WithKind(SymbolKind::Method)))),
           AllOf(WithName("Cat(Sneaky)"), SymRange(Main.range("SneakyCat")),
-                Children(
+                children(
                     AllOf(WithName("-sneak:"), WithKind(SymbolKind::Method)))),
           AllOf(
               WithName("Cat()"), SymRange(Main.range("MeowCat")),
-              Children(AllOf(WithName("-meow"), WithKind(SymbolKind::Method)))),
+              children(AllOf(WithName("-meow"), WithKind(SymbolKind::Method)))),
           AllOf(WithName("Cat()"), SymRange(Main.range("PurCat")),
-                Children(
+                children(
                     AllOf(WithName("-pur"), WithKind(SymbolKind::Method))))));
 }
 
@@ -1061,17 +1061,17 @@
       UnorderedElementsAre(
           AllOf(WithName("Dog"), SymRange(Main.range("DogDef"))),
           AllOf(WithName("Dog"), SymRange(Main.range("DogImpl")),
-                Children(AllOf(WithName("+sharedDoggo"),
+                children(AllOf(WithName("+sharedDoggo"),
                                WithKind(SymbolKind::Method)),
                          AllOf(WithName("Overrides"),
                                SymRange(Main.range("Overrides")),
-                               Children(AllOf(WithName("-init"),
+                               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"),
+                               children(AllOf(WithName("-isAGoodBoy"),
                                               WithKind(SymbolKind::Method)))))),
           AllOf(WithName("End"), SymRange(Main.range("End")))));
 }
@@ -1094,10 +1094,10 @@
       getSymbols(TU.build()),
       UnorderedElementsAre(AllOf(
           WithName("Foo"),
-          Children(AllOf(WithName("Foo"),
-                         Children(AllOf(WithName("Bar"),
-                                        Children(AllOf(WithName("bar"),
-                                                       Children(WithName(
+          children(AllOf(WithName("Foo"),
+                         children(AllOf(WithName("Bar"),
+                                        children(AllOf(WithName("bar"),
+                                                       children(WithName(
                                                            "NotTopDecl"))))))),
                    WithName("bar")))));
 }
diff --git a/clang-tools-extra/clangd/unittests/IndexActionTests.cpp b/clang-tools-extra/clangd/unittests/IndexActionTests.cpp
--- a/clang-tools-extra/clangd/unittests/IndexActionTests.cpp
+++ b/clang-tools-extra/clangd/unittests/IndexActionTests.cpp
@@ -40,7 +40,7 @@
 }
 
 ::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));
 }
@@ -127,13 +127,13 @@
   EXPECT_THAT(Nodes,
               UnorderedElementsAre(
                   Pair(toUri(MainFilePath),
-                       AllOf(IsTU(), IncludesAre({Level1HeaderPath}),
+                       AllOf(IsTU(), includesAre({Level1HeaderPath}),
                              HasDigest(digest(MainCode)))),
                   Pair(toUri(Level1HeaderPath),
-                       AllOf(Not(IsTU()), IncludesAre({Level2HeaderPath}),
+                       AllOf(Not(IsTU()), includesAre({Level2HeaderPath}),
                              HasDigest(digest(Level1HeaderCode)))),
                   Pair(toUri(Level2HeaderPath),
-                       AllOf(Not(IsTU()), IncludesAre({}),
+                       AllOf(Not(IsTU()), includesAre({}),
                              HasDigest(digest(Level2HeaderCode))))));
 }
 
@@ -156,9 +156,9 @@
   EXPECT_THAT(
       Nodes,
       UnorderedElementsAre(
-          Pair(toUri(MainFilePath), AllOf(IsTU(), IncludesAre({HeaderPath}),
+          Pair(toUri(MainFilePath), AllOf(IsTU(), includesAre({HeaderPath}),
                                           HasDigest(digest(MainCode)))),
-          Pair(toUri(HeaderPath), AllOf(Not(IsTU()), IncludesAre({HeaderPath}),
+          Pair(toUri(HeaderPath), AllOf(Not(IsTU()), includesAre({HeaderPath}),
                                         HasDigest(digest(HeaderCode))))));
 }
 
@@ -191,13 +191,13 @@
   EXPECT_THAT(
       Nodes, UnorderedElementsAre(
                  Pair(toUri(MainFilePath),
-                      AllOf(IsTU(), IncludesAre({HeaderPath, CommonHeaderPath}),
+                      AllOf(IsTU(), includesAre({HeaderPath, CommonHeaderPath}),
                             HasDigest(digest(MainCode)))),
                  Pair(toUri(HeaderPath),
-                      AllOf(Not(IsTU()), IncludesAre({CommonHeaderPath}),
+                      AllOf(Not(IsTU()), includesAre({CommonHeaderPath}),
                             HasDigest(digest(HeaderCode)))),
                  Pair(toUri(CommonHeaderPath),
-                      AllOf(Not(IsTU()), IncludesAre({}),
+                      AllOf(Not(IsTU()), includesAre({}),
                             HasDigest(digest(CommonHeaderCode))))));
 }
 
@@ -224,9 +224,9 @@
       Nodes,
       UnorderedElementsAre(
           Pair(toUri(MainFilePath),
-               AllOf(IsTU(), IncludesAre({MainFilePath, HeaderPath}),
+               AllOf(IsTU(), includesAre({MainFilePath, HeaderPath}),
                      HasDigest(digest(MainCode)))),
-          Pair(toUri(HeaderPath), AllOf(Not(IsTU()), IncludesAre({}),
+          Pair(toUri(HeaderPath), AllOf(Not(IsTU()), includesAre({}),
                                         HasDigest(digest(HeaderCode))))));
 }
 
diff --git a/clang-tools-extra/clangd/unittests/JSONTransportTests.cpp b/clang-tools-extra/clangd/unittests/JSONTransportTests.cpp
--- a/clang-tools-extra/clangd/unittests/JSONTransportTests.cpp
+++ b/clang-tools-extra/clangd/unittests/JSONTransportTests.cpp
@@ -40,7 +40,7 @@
 
   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:
@@ -129,7 +129,7 @@
       "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
@@ -185,7 +185,7 @@
   "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.
@@ -199,7 +199,7 @@
   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
diff --git a/clang-tools-extra/clangd/unittests/QualityTests.cpp b/clang-tools-extra/clangd/unittests/QualityTests.cpp
--- a/clang-tools-extra/clangd/unittests/QualityTests.cpp
+++ b/clang-tools-extra/clangd/unittests/QualityTests.cpp
@@ -136,7 +136,7 @@
   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))
@@ -151,10 +151,10 @@
   };
 
   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";
 
diff --git a/clang-tools-extra/clangd/unittests/SerializationTests.cpp b/clang-tools-extra/clangd/unittests/SerializationTests.cpp
--- a/clang-tools-extra/clangd/unittests/SerializationTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SerializationTests.cpp
@@ -191,20 +191,20 @@
   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));
@@ -227,12 +227,12 @@
   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) {
@@ -262,10 +262,10 @@
     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);
diff --git a/clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp b/clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
--- a/clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
@@ -102,7 +102,7 @@
   return arg == Relation{Subject.ID, RelationKind::OverriddenBy, Object.ID};
 }
 ::testing::Matcher<const std::vector<Ref> &>
-HaveRanges(const std::vector<Range> Ranges) {
+haveRanges(const std::vector<Range> Ranges) {
   return ::testing::UnorderedPointwise(RefRange(), Ranges);
 }
 
@@ -738,14 +738,14 @@
   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 =
@@ -873,18 +873,18 @@
   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) {
@@ -896,7 +896,7 @@
   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) {
@@ -967,9 +967,9 @@
     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))));
   }
 }
 
@@ -988,7 +988,7 @@
   // 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) {
@@ -1011,7 +1011,7 @@
   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) {
@@ -1030,9 +1030,9 @@
   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");
@@ -1041,9 +1041,9 @@
   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");
@@ -1051,9 +1051,9 @@
   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) {
@@ -1066,9 +1066,9 @@
   )");
   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) {
diff --git a/clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp b/clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp
--- a/clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp
@@ -26,10 +26,10 @@
 
 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) {
diff --git a/clang-tools-extra/clangd/unittests/TestIndex.cpp b/clang-tools-extra/clangd/unittests/TestIndex.cpp
--- a/clang-tools-extra/clangd/unittests/TestIndex.cpp
+++ b/clang-tools-extra/clangd/unittests/TestIndex.cpp
@@ -82,8 +82,8 @@
 
 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);
 }
 
diff --git a/clang-tools-extra/clangd/unittests/TypeHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/TypeHierarchyTests.cpp
--- a/clang-tools-extra/clangd/unittests/TypeHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/TypeHierarchyTests.cpp
@@ -39,12 +39,12 @@
 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...)));
 }
@@ -372,15 +372,15 @@
         *Result,
         AllOf(
             WithName("Child"), WithKind(SymbolKind::Struct),
-            Parents(AllOf(WithName("Parent1"), WithKind(SymbolKind::Struct),
+            parents(AllOf(WithName("Parent1"), WithKind(SymbolKind::Struct),
                           SelectionRangeIs(Source.range("Parent1Def")),
-                          Parents()),
+                          parents()),
                     AllOf(WithName("Parent3"), WithKind(SymbolKind::Struct),
                           SelectionRangeIs(Source.range("Parent3Def")),
-                          Parents(AllOf(
+                          parents(AllOf(
                               WithName("Parent2"), WithKind(SymbolKind::Struct),
                               SelectionRangeIs(Source.range("Parent2Def")),
-                              Parents()))))));
+                              parents()))))));
   }
 }
 
@@ -410,12 +410,12 @@
   EXPECT_THAT(
       *Result,
       AllOf(WithName("S<0>"), WithKind(SymbolKind::Struct),
-            Parents(
+            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()))))));
+                                    parents()))))));
 }
 
 TEST(TypeHierarchy, RecursiveHierarchyBounded) {
@@ -444,19 +444,19 @@
   EXPECT_THAT(
       *Result,
       AllOf(WithName("S<2>"), WithKind(SymbolKind::Struct),
-            Parents(AllOf(
+            parents(AllOf(
                 WithName("S<1>"), WithKind(SymbolKind::Struct),
                 SelectionRangeIs(Source.range("SDef")),
-                Parents(AllOf(WithName("S<0>"), WithKind(SymbolKind::Struct),
-                              Parents()))))));
+                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()))));
+            parents(AllOf(WithName("S"), WithKind(SymbolKind::Struct),
+                          SelectionRangeIs(Source.range("SDef")), parents()))));
 }
 
 TEST(TypeHierarchy, DeriveFromImplicitSpec) {
@@ -481,10 +481,10 @@
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(*Result,
               AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
-                    Children(AllOf(WithName("Child1"),
-                                   WithKind(SymbolKind::Struct), Children()),
+                    children(AllOf(WithName("Child1"),
+                                   WithKind(SymbolKind::Struct), children()),
                              AllOf(WithName("Child2"),
-                                   WithKind(SymbolKind::Struct), Children()))));
+                                   WithKind(SymbolKind::Struct), children()))));
 }
 
 TEST(TypeHierarchy, DeriveFromPartialSpec) {
@@ -506,7 +506,7 @@
       testPath(TU.Filename));
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(*Result, AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
-                             Children()));
+                             children()));
 }
 
 TEST(TypeHierarchy, DeriveFromTemplate) {
@@ -533,8 +533,8 @@
   ASSERT_TRUE(bool(Result));
   EXPECT_THAT(*Result,
               AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
-                    Children(AllOf(WithName("Child"),
-                                   WithKind(SymbolKind::Struct), Children()))));
+                    children(AllOf(WithName("Child"),
+                                   WithKind(SymbolKind::Struct), children()))));
 }
 
 TEST(TypeHierarchy, Preamble) {
@@ -559,9 +559,9 @@
   EXPECT_THAT(
       *Result,
       AllOf(WithName("Child"),
-            Parents(AllOf(WithName("Parent"),
+            parents(AllOf(WithName("Parent"),
                           SelectionRangeIs(HeaderInPreambleAnnotations.range()),
-                          Parents()))));
+                          parents()))));
 }
 
 SymbolID findSymbolIDByName(SymbolIndex *Index, llvm::StringRef Name,
@@ -736,7 +736,7 @@
       *Result,
       AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
             ParentsNotResolved(),
-            Children(AllOf(WithName("Child1"), WithKind(SymbolKind::Struct),
+            children(AllOf(WithName("Child1"), WithKind(SymbolKind::Struct),
                            ParentsNotResolved(), ChildrenNotResolved()))));
 
   resolveTypeHierarchy((*Result->children)[0], /*ResolveLevels=*/1,
@@ -746,7 +746,7 @@
       (*Result->children)[0],
       AllOf(WithName("Child1"), WithKind(SymbolKind::Struct),
             ParentsNotResolved(),
-            Children(AllOf(WithName("Child2a"), WithKind(SymbolKind::Struct),
+            children(AllOf(WithName("Child2a"), WithKind(SymbolKind::Struct),
                            ParentsNotResolved(), ChildrenNotResolved()),
                      AllOf(WithName("Child2b"), WithKind(SymbolKind::Struct),
                            ParentsNotResolved(), ChildrenNotResolved()))));
diff --git a/clang-tools-extra/clangd/unittests/XRefsTests.cpp b/clang-tools-extra/clangd/unittests/XRefsTests.cpp
--- a/clang-tools-extra/clangd/unittests/XRefsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/XRefsTests.cpp
@@ -58,7 +58,7 @@
 // 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();
@@ -132,7 +132,7 @@
     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;
   }
 }
@@ -269,7 +269,7 @@
     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;
   }
 }
diff --git a/clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp b/clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp
--- a/clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp
+++ b/clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp
@@ -29,7 +29,7 @@
   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) {
@@ -44,7 +44,7 @@
       // 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();
@@ -56,7 +56,7 @@
     {
       std::lock_guard<std::mutex> Lock(Mutex);
       Counter = 0;
-      scheduleIncrements();
+      ScheduleIncrements();
     }
   }
   // Check that destructor has waited for tasks to finish.
diff --git a/clang-tools-extra/clangd/unittests/support/TraceTests.cpp b/clang-tools-extra/clangd/unittests/support/TraceTests.cpp
--- a/clang-tools-extra/clangd/unittests/support/TraceTests.cpp
+++ b/clang-tools-extra/clangd/unittests/support/TraceTests.cpp
@@ -39,7 +39,7 @@
 
 // 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) {
@@ -118,15 +118,15 @@
   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());
 }