[clang-tools-extra] 8edfc2f - [clangd] Cleanup of readability-identifier-naming
Christian Kühnel via cfe-commits
cfe-commits at lists.llvm.org
Tue Feb 1 05:32:02 PST 2022
Author: Christian Kühnel
Date: 2022-02-01T13:31:52Z
New Revision: 8edfc2f814fe107bf31e3470478aa9bcacdf5aed
URL: https://github.com/llvm/llvm-project/commit/8edfc2f814fe107bf31e3470478aa9bcacdf5aed
DIFF: https://github.com/llvm/llvm-project/commit/8edfc2f814fe107bf31e3470478aa9bcacdf5aed.diff
LOG: [clangd] Cleanup of readability-identifier-naming
Auto-generated patch based on clang-tidy readability-identifier-naming.
Only some manual cleanup for `extern "C"` declarations and a GTest change was required.
I'm not sure if this cleanup is actually very useful. It cleans up clang-tidy findings to the number of warnings from clang-tidy should be lower. Since it was easy to do and required only little cleanup I thought I'd upload it for discussion.
One pattern that keeps recurring: Test **matchers** are also supposed to start with a lowercase letter as per LLVM convention. However GTest naming convention for matchers start with upper case. I would propose to keep stay consistent with the GTest convention there. However that would imply a lot of `//NOLINT` throughout these files.
To re-product this patch run:
```
run-clang-tidy -checks="-*,readability-identifier-naming" -fix -format ./clang-tools-extra/clangd
```
To convert the macro names, I was using this script with some manual cleanup afterwards:
https://gist.github.com/ChristianKuehnel/a01cc4362b07c58281554ab46235a077
Differential Revision: https://reviews.llvm.org/D115634
Added:
Modified:
.clang-tidy
clang-tools-extra/clangd/ClangdLSPServer.cpp
clang-tools-extra/clangd/SourceCode.cpp
clang-tools-extra/clangd/TUScheduler.cpp
clang-tools-extra/clangd/XRefs.cpp
clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp
clang-tools-extra/clangd/fuzzer/clangd-fuzzer.cpp
clang-tools-extra/clangd/index/YAMLSerialization.cpp
clang-tools-extra/clangd/unittests/BackgroundIndexTests.cpp
clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
clang-tools-extra/clangd/unittests/CompileCommandsTests.cpp
clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp
clang-tools-extra/clangd/unittests/ConfigProviderTests.cpp
clang-tools-extra/clangd/unittests/ConfigTesting.h
clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp
clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
clang-tools-extra/clangd/unittests/DumpASTTests.cpp
clang-tools-extra/clangd/unittests/ExpectedTypeTest.cpp
clang-tools-extra/clangd/unittests/FileIndexTests.cpp
clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp
clang-tools-extra/clangd/unittests/HeadersTests.cpp
clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp
clang-tools-extra/clangd/unittests/IndexActionTests.cpp
clang-tools-extra/clangd/unittests/IndexTests.cpp
clang-tools-extra/clangd/unittests/JSONTransportTests.cpp
clang-tools-extra/clangd/unittests/ParsedASTTests.cpp
clang-tools-extra/clangd/unittests/QualityTests.cpp
clang-tools-extra/clangd/unittests/SerializationTests.cpp
clang-tools-extra/clangd/unittests/SourceCodeTests.cpp
clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp
clang-tools-extra/clangd/unittests/TestIndex.cpp
clang-tools-extra/clangd/unittests/TypeHierarchyTests.cpp
clang-tools-extra/clangd/unittests/URITests.cpp
clang-tools-extra/clangd/unittests/XRefsTests.cpp
clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp
clang-tools-extra/clangd/unittests/support/TraceTests.cpp
Removed:
################################################################################
diff --git a/.clang-tidy b/.clang-tidy
index 879c3661b302..f3710d19f94f 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -6,6 +6,10 @@ CheckOptions:
value: CamelCase
- key: readability-identifier-naming.FunctionCase
value: camelBack
+ # Exclude from scanning as this is an exported symbol used for fuzzing
+ # throughout the code base.
+ - key: readability-identifier-naming.FunctionIgnoredRegexp
+ value: "LLVMFuzzerTestOneInput"
- key: readability-identifier-naming.MemberCase
value: CamelCase
- key: readability-identifier-naming.ParameterCase
diff --git a/clang-tools-extra/clangd/ClangdLSPServer.cpp b/clang-tools-extra/clangd/ClangdLSPServer.cpp
index 5b1d04687265..8bd95b075fb9 100644
--- a/clang-tools-extra/clangd/ClangdLSPServer.cpp
+++ b/clang-tools-extra/clangd/ClangdLSPServer.cpp
@@ -71,8 +71,8 @@ llvm::Optional<int64_t> decodeVersion(llvm::StringRef Encoded) {
return llvm::None;
}
-const llvm::StringLiteral APPLY_FIX_COMMAND = "clangd.applyFix";
-const llvm::StringLiteral APPLY_TWEAK_COMMAND = "clangd.applyTweak";
+const llvm::StringLiteral ApplyFixCommand = "clangd.applyFix";
+const llvm::StringLiteral ApplyTweakCommand = "clangd.applyTweak";
/// Transforms a tweak into a code action that would apply it if executed.
/// EXPECTS: T.prepare() was called and returned true.
@@ -88,7 +88,7 @@ CodeAction toCodeAction(const ClangdServer::TweakRef &T, const URIForFile &File,
// 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;
@@ -950,7 +950,7 @@ static llvm::Optional<Command> asCommand(const CodeAction &Action) {
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;
@@ -1495,8 +1495,8 @@ void ClangdLSPServer::bindMethods(LSPBinder &Bind,
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
index e005fe4b3736..d4a38a56e610 100644
--- a/clang-tools-extra/clangd/SourceCode.cpp
+++ b/clang-tools-extra/clangd/SourceCode.cpp
@@ -1177,10 +1177,10 @@ bool isProtoFile(SourceLocation Loc, const SourceManager &SM) {
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
index 9b98791e748c..dfabdb64fd58 100644
--- a/clang-tools-extra/clangd/TUScheduler.cpp
+++ b/clang-tools-extra/clangd/TUScheduler.cpp
@@ -100,10 +100,10 @@ namespace {
class ASTWorker;
} // namespace
-static clang::clangd::Key<std::string> kFileBeingProcessed;
+static clang::clangd::Key<std::string> FileBeingProcessed;
llvm::Optional<llvm::StringRef> TUScheduler::getFileBeingProcessedInContext() {
- if (auto *File = Context::current().get(kFileBeingProcessed))
+ if (auto *File = Context::current().get(FileBeingProcessed))
return llvm::StringRef(*File);
return None;
}
@@ -1228,7 +1228,7 @@ void ASTWorker::startTask(llvm::StringRef Name,
}
// Allow this request to be cancelled if invalidated.
- Context Ctx = Context::current().derive(kFileBeingProcessed, FileName);
+ Context Ctx = Context::current().derive(FileBeingProcessed, FileName);
Canceler Invalidate = nullptr;
if (Invalidation) {
WithContext WC(std::move(Ctx));
@@ -1656,7 +1656,7 @@ void TUScheduler::runWithPreamble(llvm::StringRef Name, PathRef File,
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(FileBeingProcessed,
std::string(File)),
Action = std::move(Action), this]() mutable {
ThreadCrashReporter ScopedReporter([&Name, &Contents, &Command]() {
diff --git a/clang-tools-extra/clangd/XRefs.cpp b/clang-tools-extra/clangd/XRefs.cpp
index fbe60849daa4..c6a24450c0d1 100644
--- a/clang-tools-extra/clangd/XRefs.cpp
+++ b/clang-tools-extra/clangd/XRefs.cpp
@@ -1861,7 +1861,9 @@ static QualType typeForNode(const SelectionTree::Node *N) {
QualType VisitCXXThrowExpr(const CXXThrowExpr *S) {
return S->getSubExpr()->getType();
}
- QualType VisitCoyieldStmt(const CoyieldExpr *S) {
+ // FIXME(sammccall): this should be VisitCoyieldExpr
+ // see https://reviews.llvm.org/D115634
+ QualType visitCoyieldStmt(const CoyieldExpr *S) {
return type(S->getOperand());
}
// Treat a designated initializer like a reference to the field.
diff --git a/clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp b/clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp
index 77fca2a81569..bd32041bbe1f 100644
--- a/clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp
+++ b/clang-tools-extra/clangd/benchmarks/IndexBenchmark.cpp
@@ -73,29 +73,29 @@ std::vector<FuzzyFindRequest> extractQueriesFromLogs() {
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/clangd-fuzzer.cpp b/clang-tools-extra/clangd/fuzzer/clangd-fuzzer.cpp
index 1c1ac5bf0c77..7295f03852e7 100644
--- a/clang-tools-extra/clangd/fuzzer/clangd-fuzzer.cpp
+++ b/clang-tools-extra/clangd/fuzzer/clangd-fuzzer.cpp
@@ -19,12 +19,12 @@
using namespace clang::clangd;
-extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size) {
- if (size == 0)
+extern "C" int LLVMFuzzerTestOneInput(uint8_t *Data, size_t Size) {
+ if (Size == 0)
return 0;
// fmemopen isn't portable, but I think we only run the fuzzer on Linux.
- std::FILE *In = fmemopen(data, size, "r");
+ std::FILE *In = fmemopen(Data, Size, "r");
auto Transport = newJSONTransport(In, llvm::nulls(),
/*InMirror=*/nullptr, /*Pretty=*/false,
/*Style=*/JSONStreamStyle::Delimited);
diff --git a/clang-tools-extra/clangd/index/YAMLSerialization.cpp b/clang-tools-extra/clangd/index/YAMLSerialization.cpp
index 84bf5146b411..ddab56ea1bbc 100644
--- a/clang-tools-extra/clangd/index/YAMLSerialization.cpp
+++ b/clang-tools-extra/clangd/index/YAMLSerialization.cpp
@@ -161,19 +161,19 @@ template <> struct MappingTraits<SymbolLocation> {
};
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
index 9b60d6209ae3..247ddf6ced11 100644
--- a/clang-tools-extra/clangd/unittests/BackgroundIndexTests.cpp
+++ b/clang-tools-extra/clangd/unittests/BackgroundIndexTests.cpp
@@ -28,28 +28,28 @@ using ::testing::UnorderedElementsAre;
namespace clang {
namespace clangd {
-MATCHER_P(Named, N, "") { return arg.Name == N; }
-MATCHER_P(QName, N, "") { return (arg.Scope + arg.Name).str() == N; }
-MATCHER(Declared, "") {
+MATCHER_P(named, N, "") { return arg.Name == N; }
+MATCHER_P(qName, N, "") { return (arg.Scope + arg.Name).str() == N; }
+MATCHER(declared, "") {
return !StringRef(arg.CanonicalDeclaration.FileURI).empty();
}
-MATCHER(Defined, "") { return !StringRef(arg.Definition.FileURI).empty(); }
-MATCHER_P(FileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
+MATCHER(defined, "") { return !StringRef(arg.Definition.FileURI).empty(); }
+MATCHER_P(fileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
::testing::Matcher<const RefSlab &>
-RefsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
+refsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
return ElementsAre(::testing::Pair(_, UnorderedElementsAreArray(Matchers)));
}
// URI cannot be empty since it references keys in the IncludeGraph.
-MATCHER(EmptyIncludeNode, "") {
+MATCHER(emptyIncludeNode, "") {
return arg.Flags == IncludeGraphNode::SourceFlag::None && !arg.URI.empty() &&
arg.Digest == FileDigest{{0}} && arg.DirectIncludes.empty();
}
-MATCHER(HadErrors, "") {
+MATCHER(hadErrors, "") {
return arg.Flags & IncludeGraphNode::SourceFlag::HadErrors;
}
-MATCHER_P(NumReferences, N, "") { return arg.References == N; }
+MATCHER_P(numReferences, N, "") { return arg.References == N; }
class MemoryShardStorage : public BackgroundIndexStorage {
mutable std::mutex StorageMu;
@@ -159,8 +159,8 @@ TEST_F(BackgroundIndexTest, Config) {
// Wait for both files to be indexed.
ASSERT_TRUE(Idx.blockUntilIdleForTest());
EXPECT_THAT(runFuzzyFind(Idx, ""),
- UnorderedElementsAre(QName("foo"), QName("foo::two"),
- QName("bar"), QName("bar::one")));
+ UnorderedElementsAre(qName("foo"), qName("foo::two"),
+ qName("bar"), qName("bar::one")));
}
TEST_F(BackgroundIndexTest, IndexTwoFiles) {
@@ -203,11 +203,11 @@ TEST_F(BackgroundIndexTest, IndexTwoFiles) {
ASSERT_TRUE(Idx.blockUntilIdleForTest());
EXPECT_THAT(runFuzzyFind(Idx, ""),
- UnorderedElementsAre(AllOf(Named("common"), NumReferences(1U)),
- AllOf(Named("A_CC"), NumReferences(0U)),
- AllOf(Named("g"), NumReferences(1U)),
- AllOf(Named("f_b"), Declared(),
- Not(Defined()), NumReferences(0U))));
+ UnorderedElementsAre(AllOf(named("common"), numReferences(1U)),
+ AllOf(named("A_CC"), numReferences(0U)),
+ AllOf(named("g"), numReferences(1U)),
+ AllOf(named("f_b"), declared(),
+ Not(defined()), numReferences(0U))));
Cmd.Filename = testPath("root/B.cc");
Cmd.CommandLine = {"clang++", Cmd.Filename};
@@ -216,22 +216,22 @@ TEST_F(BackgroundIndexTest, IndexTwoFiles) {
ASSERT_TRUE(Idx.blockUntilIdleForTest());
// B_CC is dropped as we don't collect symbols from A.h in this compilation.
EXPECT_THAT(runFuzzyFind(Idx, ""),
- UnorderedElementsAre(AllOf(Named("common"), NumReferences(5U)),
- AllOf(Named("A_CC"), NumReferences(0U)),
- AllOf(Named("g"), NumReferences(1U)),
- AllOf(Named("f_b"), Declared(), Defined(),
- NumReferences(1U))));
+ UnorderedElementsAre(AllOf(named("common"), numReferences(5U)),
+ AllOf(named("A_CC"), numReferences(0U)),
+ AllOf(named("g"), numReferences(1U)),
+ AllOf(named("f_b"), declared(), defined(),
+ numReferences(1U))));
auto Syms = runFuzzyFind(Idx, "common");
- EXPECT_THAT(Syms, UnorderedElementsAre(Named("common")));
+ EXPECT_THAT(Syms, UnorderedElementsAre(named("common")));
auto Common = *Syms.begin();
EXPECT_THAT(getRefs(Idx, Common.ID),
- RefsAre({FileURI("unittest:///root/A.h"),
- FileURI("unittest:///root/A.cc"),
- FileURI("unittest:///root/B.cc"),
- FileURI("unittest:///root/B.cc"),
- FileURI("unittest:///root/B.cc"),
- FileURI("unittest:///root/B.cc")}));
+ refsAre({fileURI("unittest:///root/A.h"),
+ fileURI("unittest:///root/A.cc"),
+ fileURI("unittest:///root/B.cc"),
+ fileURI("unittest:///root/B.cc"),
+ fileURI("unittest:///root/B.cc"),
+ fileURI("unittest:///root/B.cc")}));
}
TEST_F(BackgroundIndexTest, MainFileRefs) {
@@ -259,8 +259,8 @@ TEST_F(BackgroundIndexTest, MainFileRefs) {
ASSERT_TRUE(Idx.blockUntilIdleForTest());
EXPECT_THAT(
runFuzzyFind(Idx, ""),
- UnorderedElementsAre(AllOf(Named("header_sym"), NumReferences(1U)),
- AllOf(Named("main_sym"), NumReferences(1U))));
+ UnorderedElementsAre(AllOf(named("header_sym"), numReferences(1U)),
+ AllOf(named("main_sym"), numReferences(1U))));
}
TEST_F(BackgroundIndexTest, ShardStorageTest) {
@@ -270,7 +270,6 @@ TEST_F(BackgroundIndexTest, ShardStorageTest) {
void f_b();
class A_CC {};
)cpp";
- std::string A_CC = "";
FS.Files[testPath("root/A.cc")] = R"cpp(
#include "A.h"
void g() { (void)common; }
@@ -310,19 +309,19 @@ TEST_F(BackgroundIndexTest, ShardStorageTest) {
EXPECT_NE(ShardHeader, nullptr);
EXPECT_THAT(
*ShardHeader->Symbols,
- UnorderedElementsAre(Named("common"), Named("A_CC"),
- AllOf(Named("f_b"), Declared(), Not(Defined()))));
+ UnorderedElementsAre(named("common"), named("A_CC"),
+ AllOf(named("f_b"), declared(), Not(defined()))));
for (const auto &Ref : *ShardHeader->Refs)
EXPECT_THAT(Ref.second,
- UnorderedElementsAre(FileURI("unittest:///root/A.h")));
+ UnorderedElementsAre(fileURI("unittest:///root/A.h")));
auto ShardSource = MSS.loadShard(testPath("root/A.cc"));
EXPECT_NE(ShardSource, nullptr);
EXPECT_THAT(*ShardSource->Symbols,
- UnorderedElementsAre(Named("g"), Named("B_CC")));
+ UnorderedElementsAre(named("g"), named("B_CC")));
for (const auto &Ref : *ShardSource->Refs)
EXPECT_THAT(Ref.second,
- UnorderedElementsAre(FileURI("unittest:///root/A.cc")));
+ UnorderedElementsAre(fileURI("unittest:///root/A.cc")));
// The BaseOf relationship between A_CC and B_CC is stored in both the file
// containing the definition of the subject (A_CC) and the file containing
@@ -344,8 +343,8 @@ TEST_F(BackgroundIndexTest, DirectIncludesTest) {
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;
+ FS.Files[testPath("root/A.cc")] =
+ "#include \"A.h\"\nvoid g() { (void)common; }";
llvm::StringMap<std::string> Storage;
size_t CacheHits = 0;
@@ -372,7 +371,7 @@ TEST_F(BackgroundIndexTest, DirectIncludesTest) {
EXPECT_NE(ShardSource->Sources->lookup("unittest:///root/A.cc").Digest,
FileDigest{{0}});
EXPECT_THAT(ShardSource->Sources->lookup("unittest:///root/A.h"),
- EmptyIncludeNode());
+ emptyIncludeNode());
auto ShardHeader = MSS.loadShard(testPath("root/A.h"));
EXPECT_TRUE(ShardHeader->Sources);
@@ -383,7 +382,7 @@ TEST_F(BackgroundIndexTest, DirectIncludesTest) {
EXPECT_NE(ShardHeader->Sources->lookup("unittest:///root/A.h").Digest,
FileDigest{{0}});
EXPECT_THAT(ShardHeader->Sources->lookup("unittest:///root/B.h"),
- EmptyIncludeNode());
+ emptyIncludeNode());
}
TEST_F(BackgroundIndexTest, ShardStorageLoad) {
@@ -432,7 +431,7 @@ TEST_F(BackgroundIndexTest, ShardStorageLoad) {
// Check if the new symbol has arrived.
auto ShardHeader = MSS.loadShard(testPath("root/A.h"));
EXPECT_NE(ShardHeader, nullptr);
- EXPECT_THAT(*ShardHeader->Symbols, Contains(Named("A_CCnew")));
+ EXPECT_THAT(*ShardHeader->Symbols, Contains(named("A_CCnew")));
// Change source.
FS.Files[testPath("root/A.cc")] =
@@ -450,11 +449,11 @@ TEST_F(BackgroundIndexTest, ShardStorageLoad) {
// Check if the new symbol has arrived.
ShardHeader = MSS.loadShard(testPath("root/A.h"));
EXPECT_NE(ShardHeader, nullptr);
- EXPECT_THAT(*ShardHeader->Symbols, Contains(Named("A_CCnew")));
+ EXPECT_THAT(*ShardHeader->Symbols, Contains(named("A_CCnew")));
auto ShardSource = MSS.loadShard(testPath("root/A.cc"));
EXPECT_NE(ShardSource, nullptr);
EXPECT_THAT(*ShardSource->Symbols,
- Contains(AllOf(Named("f_b"), Declared(), Defined())));
+ Contains(AllOf(named("f_b"), declared(), defined())));
}
TEST_F(BackgroundIndexTest, ShardStorageEmptyFile) {
@@ -522,7 +521,7 @@ TEST_F(BackgroundIndexTest, ShardStorageEmptyFile) {
ShardHeader = MSS.loadShard(testPath("root/B.h"));
EXPECT_NE(ShardHeader, nullptr);
EXPECT_THAT(*ShardHeader->Symbols,
- Contains(AllOf(Named("new_func"), Declared(), Not(Defined()))));
+ Contains(AllOf(named("new_func"), declared(), Not(defined()))));
}
TEST_F(BackgroundIndexTest, NoDotsInAbsPath) {
@@ -587,27 +586,27 @@ TEST_F(BackgroundIndexTest, UncompilableFiles) {
{
auto Shard = MSS.loadShard(testPath("A.cc"));
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("foo")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(named("foo")));
EXPECT_THAT(Shard->Sources->keys(),
UnorderedElementsAre("unittest:///A.cc", "unittest:///A.h",
"unittest:///B.h"));
- EXPECT_THAT(Shard->Sources->lookup("unittest:///A.cc"), HadErrors());
+ EXPECT_THAT(Shard->Sources->lookup("unittest:///A.cc"), hadErrors());
}
{
auto Shard = MSS.loadShard(testPath("A.h"));
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("foo")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(named("foo")));
EXPECT_THAT(Shard->Sources->keys(),
UnorderedElementsAre("unittest:///A.h"));
- EXPECT_THAT(Shard->Sources->lookup("unittest:///A.h"), HadErrors());
+ EXPECT_THAT(Shard->Sources->lookup("unittest:///A.h"), hadErrors());
}
{
auto Shard = MSS.loadShard(testPath("B.h"));
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(Named("asdf")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(named("asdf")));
EXPECT_THAT(Shard->Sources->keys(),
UnorderedElementsAre("unittest:///B.h", "unittest:///C.h"));
- EXPECT_THAT(Shard->Sources->lookup("unittest:///B.h"), HadErrors());
+ EXPECT_THAT(Shard->Sources->lookup("unittest:///B.h"), hadErrors());
}
{
@@ -615,7 +614,7 @@ TEST_F(BackgroundIndexTest, UncompilableFiles) {
EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre());
EXPECT_THAT(Shard->Sources->keys(),
UnorderedElementsAre("unittest:///C.h"));
- EXPECT_THAT(Shard->Sources->lookup("unittest:///C.h"), HadErrors());
+ EXPECT_THAT(Shard->Sources->lookup("unittest:///C.h"), hadErrors());
}
}
diff --git a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
index a9d0385654dd..b2f3a14f1247 100644
--- a/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CallHierarchyTests.cpp
@@ -52,15 +52,15 @@ using ::testing::Matcher;
using ::testing::UnorderedElementsAre;
// Helpers for matching call hierarchy data structures.
-MATCHER_P(WithName, N, "") { return arg.name == N; }
-MATCHER_P(WithSelectionRange, R, "") { return arg.selectionRange == R; }
+MATCHER_P(withName, N, "") { return arg.name == N; }
+MATCHER_P(withSelectionRange, R, "") { return arg.selectionRange == R; }
template <class ItemMatcher>
-::testing::Matcher<CallHierarchyIncomingCall> From(ItemMatcher M) {
+::testing::Matcher<CallHierarchyIncomingCall> from(ItemMatcher M) {
return Field(&CallHierarchyIncomingCall::from, M);
}
template <class... RangeMatchers>
-::testing::Matcher<CallHierarchyIncomingCall> FromRanges(RangeMatchers... M) {
+::testing::Matcher<CallHierarchyIncomingCall> fromRanges(RangeMatchers... M) {
return Field(&CallHierarchyIncomingCall::fromRanges,
UnorderedElementsAre(M...));
}
@@ -86,23 +86,23 @@ TEST(CallHierarchy, IncomingOneFileCpp) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Source.range("Callee")))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Source.range("Callee")))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
ASSERT_THAT(IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Source.range("Caller1A"),
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Source.range("Caller1A"),
Source.range("Caller1B"))),
- AllOf(From(WithName("caller3")),
- FromRanges(Source.range("Caller1C")))));
+ AllOf(from(withName("caller3")),
+ fromRanges(Source.range("Caller1C")))));
auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
ASSERT_THAT(IncomingLevel3,
- ElementsAre(AllOf(From(WithName("caller3")),
- FromRanges(Source.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller3")),
+ fromRanges(Source.range("Caller2")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
@@ -131,23 +131,23 @@ TEST(CallHierarchy, IncomingOneFileObjC) {
auto Index = TU.index();
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Source.range("Callee")))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Source.range("Callee")))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
ASSERT_THAT(IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Source.range("Caller1A"),
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Source.range("Caller1A"),
Source.range("Caller1B"))),
- AllOf(From(WithName("caller3")),
- FromRanges(Source.range("Caller1C")))));
+ AllOf(from(withName("caller3")),
+ fromRanges(Source.range("Caller1C")))));
auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
ASSERT_THAT(IncomingLevel3,
- ElementsAre(AllOf(From(WithName("caller3")),
- FromRanges(Source.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller3")),
+ fromRanges(Source.range("Caller2")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
@@ -174,16 +174,16 @@ TEST(CallHierarchy, MainFileOnlyRef) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Source.range("Callee")))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Source.range("Callee")))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
EXPECT_THAT(IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Source.range("Caller1")))));
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Source.range("Caller1")))));
}
TEST(CallHierarchy, IncomingQualified) {
@@ -207,13 +207,13 @@ TEST(CallHierarchy, IncomingQualified) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("Waldo::find")));
+ ASSERT_THAT(Items, ElementsAre(withName("Waldo::find")));
auto Incoming = incomingCalls(Items[0], Index.get());
EXPECT_THAT(Incoming,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Source.range("Caller1"))),
- AllOf(From(WithName("caller2")),
- FromRanges(Source.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Source.range("Caller1"))),
+ AllOf(from(withName("caller2")),
+ fromRanges(Source.range("Caller2")))));
}
TEST(CallHierarchy, IncomingMultiFileCpp) {
@@ -273,24 +273,24 @@ TEST(CallHierarchy, IncomingMultiFileCpp) {
auto CheckCallHierarchy = [&](ParsedAST &AST, Position Pos, PathRef TUPath) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Pos, TUPath);
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Caller1C.range()))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Caller1C.range()))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
ASSERT_THAT(
IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Caller2C.range("A"), Caller2C.range("B"))),
- AllOf(From(WithName("caller3")),
- FromRanges(Caller3C.range("Caller1")))));
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Caller2C.range("A"), Caller2C.range("B"))),
+ AllOf(from(withName("caller3")),
+ fromRanges(Caller3C.range("Caller1")))));
auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
ASSERT_THAT(IncomingLevel3,
- ElementsAre(AllOf(From(WithName("caller3")),
- FromRanges(Caller3C.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller3")),
+ fromRanges(Caller3C.range("Caller2")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
@@ -382,24 +382,24 @@ TEST(CallHierarchy, IncomingMultiFileObjC) {
auto CheckCallHierarchy = [&](ParsedAST &AST, Position Pos, PathRef TUPath) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Pos, TUPath);
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
- ElementsAre(AllOf(From(WithName("caller1")),
- FromRanges(Caller1C.range()))));
+ ElementsAre(AllOf(from(withName("caller1")),
+ fromRanges(Caller1C.range()))));
auto IncomingLevel2 = incomingCalls(IncomingLevel1[0].from, Index.get());
ASSERT_THAT(
IncomingLevel2,
- ElementsAre(AllOf(From(WithName("caller2")),
- FromRanges(Caller2C.range("A"), Caller2C.range("B"))),
- AllOf(From(WithName("caller3")),
- FromRanges(Caller3C.range("Caller1")))));
+ ElementsAre(AllOf(from(withName("caller2")),
+ fromRanges(Caller2C.range("A"), Caller2C.range("B"))),
+ AllOf(from(withName("caller3")),
+ fromRanges(Caller3C.range("Caller1")))));
auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
ASSERT_THAT(IncomingLevel3,
- ElementsAre(AllOf(From(WithName("caller3")),
- FromRanges(Caller3C.range("Caller2")))));
+ ElementsAre(AllOf(from(withName("caller3")),
+ fromRanges(Caller3C.range("Caller2")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
@@ -444,15 +444,15 @@ TEST(CallHierarchy, CallInLocalVarDecl) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
- ASSERT_THAT(Items, ElementsAre(WithName("callee")));
+ ASSERT_THAT(Items, ElementsAre(withName("callee")));
auto Incoming = incomingCalls(Items[0], Index.get());
ASSERT_THAT(
Incoming,
ElementsAre(
- AllOf(From(WithName("caller1")), FromRanges(Source.range("call1"))),
- AllOf(From(WithName("caller2")), FromRanges(Source.range("call2"))),
- AllOf(From(WithName("caller3")), FromRanges(Source.range("call3")))));
+ AllOf(from(withName("caller1")), fromRanges(Source.range("call1"))),
+ AllOf(from(withName("caller2")), fromRanges(Source.range("call2"))),
+ AllOf(from(withName("caller3")), fromRanges(Source.range("call3")))));
}
} // namespace
diff --git a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
index b3eaae69c751..722a5fb699f6 100644
--- a/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ClangdLSPServerTests.cpp
@@ -27,7 +27,7 @@ namespace {
using llvm::Succeeded;
using testing::ElementsAre;
-MATCHER_P(DiagMessage, M, "") {
+MATCHER_P(diagMessage, M, "") {
if (const auto *O = arg.getAsObject()) {
if (const auto Msg = O->getString("message"))
return *Msg == M;
@@ -125,12 +125,12 @@ TEST_F(LSPTest, Diagnostics) {
Client.didOpen("foo.cpp", "void main(int, char**);");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("'main' must return 'int' (fix available)"))));
+ diagMessage("'main' must return 'int' (fix available)"))));
Client.didChange("foo.cpp", "int x = \"42\";");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Cannot initialize a variable of type 'int' with "
+ diagMessage("Cannot initialize a variable of type 'int' with "
"an lvalue of type 'const char[3]'"))));
Client.didClose("foo.cpp");
@@ -145,8 +145,8 @@ TEST_F(LSPTest, DiagnosticsHeaderSaved) {
)cpp");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("'foo.h' file not found"),
- DiagMessage("Use of undeclared identifier 'VAR'"))));
+ diagMessage("'foo.h' file not found"),
+ diagMessage("Use of undeclared identifier 'VAR'"))));
// Now create the header.
FS.Files["foo.h"] = "#define VAR original";
Client.notify(
@@ -154,7 +154,7 @@ TEST_F(LSPTest, DiagnosticsHeaderSaved) {
llvm::json::Object{{"textDocument", Client.documentID("foo.h")}});
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Use of undeclared identifier 'original'"))));
+ diagMessage("Use of undeclared identifier 'original'"))));
// Now modify the header from within the "editor".
FS.Files["foo.h"] = "#define VAR changed";
Client.notify(
@@ -163,7 +163,7 @@ TEST_F(LSPTest, DiagnosticsHeaderSaved) {
// Foo.cpp should be rebuilt with new diagnostics.
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Use of undeclared identifier 'changed'"))));
+ diagMessage("Use of undeclared identifier 'changed'"))));
}
TEST_F(LSPTest, RecordsLatencies) {
@@ -221,12 +221,12 @@ TEST_F(LSPTest, CDBConfigIntegration) {
Client.didOpen("foo.cpp", "int x = FOO;");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Use of undeclared identifier 'FOO'"))));
+ diagMessage("Use of undeclared identifier 'FOO'"))));
// bar.cpp shows the configured compile command.
Client.didOpen("bar.cpp", "int x = FOO;");
EXPECT_THAT(Client.diagnostics("bar.cpp"),
llvm::ValueIs(testing::ElementsAre(
- DiagMessage("Use of undeclared identifier 'BAR'"))));
+ diagMessage("Use of undeclared identifier 'BAR'"))));
}
TEST_F(LSPTest, ModulesTest) {
@@ -384,7 +384,7 @@ TEST_F(LSPTest, DiagModuleTest) {
auto &Client = start();
Client.didOpen("foo.cpp", "test;");
EXPECT_THAT(Client.diagnostics("foo.cpp"),
- llvm::ValueIs(testing::ElementsAre(DiagMessage(DiagMsg))));
+ llvm::ValueIs(testing::ElementsAre(diagMessage(DiagMsg))));
}
} // namespace
} // namespace clangd
diff --git a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
index c602627c3595..a0fcb62575e9 100644
--- a/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CodeCompleteTests.cpp
@@ -52,47 +52,47 @@ using ::testing::UnorderedElementsAre;
using ContextKind = CodeCompletionContext::Kind;
// GMock helpers for matching completion items.
-MATCHER_P(Named, Name, "") { return arg.Name == Name; }
-MATCHER_P(MainFileRefs, Refs, "") { return arg.MainFileRefs == Refs; }
-MATCHER_P(ScopeRefs, Refs, "") { return arg.ScopeRefsInFile == Refs; }
-MATCHER_P(NameStartsWith, Prefix, "") {
+MATCHER_P(named, Name, "") { return arg.Name == Name; }
+MATCHER_P(mainFileRefs, Refs, "") { return arg.MainFileRefs == Refs; }
+MATCHER_P(scopeRefs, Refs, "") { return arg.ScopeRefsInFile == Refs; }
+MATCHER_P(nameStartsWith, Prefix, "") {
return llvm::StringRef(arg.Name).startswith(Prefix);
}
-MATCHER_P(Scope, S, "") { return arg.Scope == S; }
-MATCHER_P(Qualifier, Q, "") { return arg.RequiredQualifier == Q; }
-MATCHER_P(Labeled, Label, "") {
+MATCHER_P(scope, S, "") { return arg.Scope == S; }
+MATCHER_P(qualifier, Q, "") { return arg.RequiredQualifier == Q; }
+MATCHER_P(labeled, Label, "") {
return arg.RequiredQualifier + arg.Name + arg.Signature == Label;
}
-MATCHER_P(SigHelpLabeled, Label, "") { return arg.label == Label; }
-MATCHER_P(Kind, K, "") { return arg.Kind == K; }
-MATCHER_P(Doc, D, "") {
+MATCHER_P(sigHelpLabeled, Label, "") { return arg.label == Label; }
+MATCHER_P(kind, K, "") { return arg.Kind == K; }
+MATCHER_P(doc, D, "") {
return arg.Documentation && arg.Documentation->asPlainText() == D;
}
-MATCHER_P(ReturnType, D, "") { return arg.ReturnType == D; }
-MATCHER_P(HasInclude, IncludeHeader, "") {
+MATCHER_P(returnType, D, "") { return arg.ReturnType == D; }
+MATCHER_P(hasInclude, IncludeHeader, "") {
return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader;
}
-MATCHER_P(InsertInclude, IncludeHeader, "") {
+MATCHER_P(insertInclude, IncludeHeader, "") {
return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader &&
bool(arg.Includes[0].Insertion);
}
-MATCHER(InsertInclude, "") {
+MATCHER(insertInclude, "") {
return !arg.Includes.empty() && bool(arg.Includes[0].Insertion);
}
-MATCHER_P(SnippetSuffix, Text, "") { return arg.SnippetSuffix == Text; }
-MATCHER_P(Origin, OriginSet, "") { return arg.Origin == OriginSet; }
-MATCHER_P(Signature, S, "") { return arg.Signature == S; }
+MATCHER_P(snippetSuffix, Text, "") { return arg.SnippetSuffix == Text; }
+MATCHER_P(origin, OriginSet, "") { return arg.Origin == OriginSet; }
+MATCHER_P(signature, S, "") { return arg.Signature == S; }
-// Shorthand for Contains(Named(Name)).
-Matcher<const std::vector<CodeCompletion> &> Has(std::string Name) {
- return Contains(Named(std::move(Name)));
+// Shorthand for Contains(named(Name)).
+Matcher<const std::vector<CodeCompletion> &> has(std::string Name) {
+ return Contains(named(std::move(Name)));
}
-Matcher<const std::vector<CodeCompletion> &> Has(std::string Name,
+Matcher<const std::vector<CodeCompletion> &> has(std::string Name,
CompletionItemKind K) {
- return Contains(AllOf(Named(std::move(Name)), Kind(K)));
+ return Contains(AllOf(named(std::move(Name)), kind(K)));
}
-MATCHER(IsDocumented, "") { return arg.Documentation.hasValue(); }
-MATCHER(Deprecated, "") { return arg.Deprecated; }
+MATCHER(isDocumented, "") { return arg.Documentation.hasValue(); }
+MATCHER(deprecated, "") { return arg.Deprecated; }
std::unique_ptr<SymbolIndex> memIndex(std::vector<Symbol> Symbols) {
SymbolSlab::Builder Slab;
@@ -177,7 +177,7 @@ int func() { MemberAccess().ABG^ }
)cpp",
/*IndexSymbols=*/{}, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(Named("ABG"), Named("AlphaBetaGamma")));
+ ElementsAre(named("ABG"), named("AlphaBetaGamma")));
}
TEST(DecisionForestRankingModel, ReferencesAffectRanking) {
@@ -189,13 +189,13 @@ TEST(DecisionForestRankingModel, ReferencesAffectRanking) {
{ns("clangA"), withReferences(NumReferences, func("clangD"))},
Opts)
.Completions,
- ElementsAre(Named("clangD"), Named("clangA")));
+ ElementsAre(named("clangD"), named("clangA")));
EXPECT_THAT(
completions("int main() { clang^ }",
{withReferences(NumReferences, ns("clangA")), func("clangD")},
Opts)
.Completions,
- ElementsAre(Named("clangA"), Named("clangD")));
+ ElementsAre(named("clangA"), named("clangD")));
}
TEST(DecisionForestRankingModel, DecisionForestScorerCallbackTest) {
@@ -240,7 +240,7 @@ int main() { ClassWithMembers().^ }
/*IndexSymbols=*/{}, Opts);
EXPECT_TRUE(Results.HasMore);
- EXPECT_THAT(Results.Completions, ElementsAre(Named("AAA"), Named("BBB")));
+ EXPECT_THAT(Results.Completions, ElementsAre(named("AAA"), named("BBB")));
}
TEST(CompletionTest, Filter) {
@@ -256,16 +256,16 @@ TEST(CompletionTest, Filter) {
// 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) {
@@ -281,7 +281,7 @@ void testAfterDotCompletion(clangd::CodeCompleteOptions Opts) {
struct GlobalClass {};
struct ClassWithMembers {
- /// Doc for method.
+ /// doc for method.
int method();
int field;
@@ -292,7 +292,7 @@ void testAfterDotCompletion(clangd::CodeCompleteOptions Opts) {
int test() {
struct LocalClass {};
- /// Doc for local_var.
+ /// doc for local_var.
int local_var;
ClassWithMembers().^
@@ -304,22 +304,22 @@ void testAfterDotCompletion(clangd::CodeCompleteOptions Opts) {
// Class members. The only items that must be present in after-dot
// completion.
EXPECT_THAT(Results.Completions,
- AllOf(Has("method"), Has("field"), Not(Has("ClassWithMembers")),
- Not(Has("operator=")), Not(Has("~ClassWithMembers"))));
+ AllOf(has("method"), has("field"), Not(has("ClassWithMembers")),
+ Not(has("operator=")), Not(has("~ClassWithMembers"))));
EXPECT_IFF(Opts.IncludeIneligibleResults, Results.Completions,
- Has("private_field"));
+ has("private_field"));
// Global items.
EXPECT_THAT(
Results.Completions,
- Not(AnyOf(Has("global_var"), Has("index_var"), Has("global_func"),
- Has("global_func()"), Has("index_func"), Has("GlobalClass"),
- Has("IndexClass"), Has("MACRO"), Has("LocalClass"))));
+ Not(AnyOf(has("global_var"), has("index_var"), has("global_func"),
+ has("global_func()"), has("index_func"), has("GlobalClass"),
+ has("IndexClass"), has("MACRO"), has("LocalClass"))));
// There should be no code patterns (aka snippets) in after-dot
// completion. At least there aren't any we're aware of.
EXPECT_THAT(Results.Completions,
- Not(Contains(Kind(CompletionItemKind::Snippet))));
+ Not(Contains(kind(CompletionItemKind::Snippet))));
// Check documentation.
- EXPECT_THAT(Results.Completions, Contains(IsDocumented()));
+ EXPECT_THAT(Results.Completions, Contains(isDocumented()));
}
void testGlobalScopeCompletion(clangd::CodeCompleteOptions Opts) {
@@ -334,14 +334,14 @@ void testGlobalScopeCompletion(clangd::CodeCompleteOptions Opts) {
struct GlobalClass {};
struct ClassWithMembers {
- /// Doc for method.
+ /// doc for method.
int method();
};
int test() {
struct LocalClass {};
- /// Doc for local_var.
+ /// doc for local_var.
int local_var;
^
@@ -352,20 +352,20 @@ void testGlobalScopeCompletion(clangd::CodeCompleteOptions Opts) {
EXPECT_TRUE(Results.RanParser);
// Class members. Should never be present in global completions.
EXPECT_THAT(Results.Completions,
- Not(AnyOf(Has("method"), Has("method()"), Has("field"))));
+ Not(AnyOf(has("method"), has("method()"), has("field"))));
// Global items.
EXPECT_THAT(Results.Completions,
- AllOf(Has("global_var"), Has("index_var"), Has("global_func"),
- Has("index_func" /* our fake symbol doesn't include () */),
- Has("GlobalClass"), Has("IndexClass")));
+ AllOf(has("global_var"), has("index_var"), has("global_func"),
+ has("index_func" /* our fake symbol doesn't include () */),
+ has("GlobalClass"), has("IndexClass")));
// A macro.
- EXPECT_THAT(Results.Completions, Has("MACRO"));
+ EXPECT_THAT(Results.Completions, has("MACRO"));
// Local items. Must be present always.
EXPECT_THAT(Results.Completions,
- AllOf(Has("local_var"), Has("LocalClass"),
- Contains(Kind(CompletionItemKind::Snippet))));
+ AllOf(has("local_var"), has("LocalClass"),
+ Contains(kind(CompletionItemKind::Snippet))));
// Check documentation.
- EXPECT_THAT(Results.Completions, Contains(IsDocumented()));
+ EXPECT_THAT(Results.Completions, Contains(isDocumented()));
}
TEST(CompletionTest, CompletionOptions) {
@@ -397,7 +397,7 @@ TEST(CompletionTest, Accessible) {
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 {
@@ -411,7 +411,7 @@ TEST(CompletionTest, Accessible) {
}
)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) {
@@ -426,40 +426,40 @@ TEST(CompletionTest, Qualifiers) {
void test() { Bar().^ }
)cpp");
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Qualifier(""), Named("bar"))));
+ Contains(AllOf(qualifier(""), named("bar"))));
// Hidden members are not shown.
EXPECT_THAT(Results.Completions,
- Not(Contains(AllOf(Qualifier("Foo::"), Named("foo")))));
+ Not(Contains(AllOf(qualifier("Foo::"), named("foo")))));
// Private members are not shown.
EXPECT_THAT(Results.Completions,
- Not(Contains(AllOf(Qualifier(""), Named("foo")))));
+ Not(Contains(AllOf(qualifier(""), named("foo")))));
}
TEST(CompletionTest, InjectedTypename) {
// These are suppressed when accessed as a member...
EXPECT_THAT(completions("struct X{}; void foo(){ X().^ }").Completions,
- Not(Has("X")));
+ Not(has("X")));
EXPECT_THAT(completions("struct X{ void foo(){ this->^ } };").Completions,
- Not(Has("X")));
+ Not(has("X")));
// ...but accessible in other, more useful cases.
EXPECT_THAT(completions("struct X{ void foo(){ ^ } };").Completions,
- Has("X"));
+ has("X"));
EXPECT_THAT(
completions("struct Y{}; struct X:Y{ void foo(){ ^ } };").Completions,
- Has("Y"));
+ has("Y"));
EXPECT_THAT(
completions(
"template<class> struct Y{}; struct X:Y<int>{ void foo(){ ^ } };")
.Completions,
- Has("Y"));
+ has("Y"));
// This case is marginal (`using X::X` is useful), we allow it for now.
EXPECT_THAT(completions("struct X{}; void foo(){ X::^ }").Completions,
- Has("X"));
+ has("X"));
}
TEST(CompletionTest, SkipInjectedWhenUnqualified) {
EXPECT_THAT(completions("struct X { void f() { X^ }};").Completions,
- ElementsAre(Named("X"), Named("~X")));
+ ElementsAre(named("X"), named("~X")));
}
TEST(CompletionTest, Snippets) {
@@ -478,8 +478,8 @@ TEST(CompletionTest, Snippets) {
/*IndexSymbols=*/{}, Opts);
EXPECT_THAT(
Results.Completions,
- HasSubsequence(Named("a"),
- SnippetSuffix("(${1:int i}, ${2:const float f})")));
+ HasSubsequence(named("a"),
+ snippetSuffix("(${1:int i}, ${2:const float f})")));
}
TEST(CompletionTest, NoSnippetsInUsings) {
@@ -495,8 +495,8 @@ TEST(CompletionTest, NoSnippetsInUsings) {
)cpp",
/*IndexSymbols=*/{}, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("func"), Labeled("func(int a, int b)"),
- SnippetSuffix(""))));
+ ElementsAre(AllOf(named("func"), labeled("func(int a, int b)"),
+ snippetSuffix(""))));
// Check index completions too.
auto Func = func("ns::func");
@@ -510,8 +510,8 @@ TEST(CompletionTest, NoSnippetsInUsings) {
)cpp",
/*IndexSymbols=*/{Func}, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("func"), Labeled("func(int a, int b)"),
- SnippetSuffix(""))));
+ ElementsAre(AllOf(named("func"), labeled("func(int a, int b)"),
+ snippetSuffix(""))));
// Check all-scopes completions too.
Opts.AllScopes = true;
@@ -520,8 +520,8 @@ TEST(CompletionTest, NoSnippetsInUsings) {
)cpp",
/*IndexSymbols=*/{Func}, Opts);
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Named("func"), Labeled("ns::func(int a, int b)"),
- SnippetSuffix(""))));
+ Contains(AllOf(named("func"), labeled("ns::func(int a, int b)"),
+ snippetSuffix(""))));
}
TEST(CompletionTest, Kinds) {
@@ -536,18 +536,18 @@ TEST(CompletionTest, Kinds) {
)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(
@@ -561,7 +561,7 @@ TEST(CompletionTest, Kinds) {
)cpp");
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("a"), Kind(CompletionItemKind::Field))));
+ UnorderedElementsAre(AllOf(named("a"), kind(CompletionItemKind::Field))));
// Completion kinds for templates should not be unknown.
Results = completions(
@@ -580,13 +580,13 @@ TEST(CompletionTest, Kinds) {
EXPECT_THAT(
Results.Completions,
UnorderedElementsAre(
- AllOf(Named("complete_class"), Kind(CompletionItemKind::Class)),
- AllOf(Named("complete_function"), Kind(CompletionItemKind::Function)),
- AllOf(Named("complete_type_alias"),
- Kind(CompletionItemKind::Interface)),
- AllOf(Named("complete_variable"), Kind(CompletionItemKind::Variable)),
- AllOf(Named("complete_static_member"),
- Kind(CompletionItemKind::Property))));
+ AllOf(named("complete_class"), kind(CompletionItemKind::Class)),
+ AllOf(named("complete_function"), kind(CompletionItemKind::Function)),
+ AllOf(named("complete_type_alias"),
+ kind(CompletionItemKind::Interface)),
+ AllOf(named("complete_variable"), kind(CompletionItemKind::Variable)),
+ AllOf(named("complete_static_member"),
+ kind(CompletionItemKind::Property))));
Results = completions(
R"cpp(
@@ -597,7 +597,7 @@ TEST(CompletionTest, Kinds) {
)cpp");
EXPECT_THAT(
Results.Completions,
- Contains(AllOf(Named("Red"), Kind(CompletionItemKind::EnumMember))));
+ Contains(AllOf(named("Red"), kind(CompletionItemKind::EnumMember))));
}
TEST(CompletionTest, NoDuplicates) {
@@ -613,7 +613,7 @@ TEST(CompletionTest, NoDuplicates) {
{cls("Adapter")});
// Make sure there are no duplicate entries of 'Adapter'.
- EXPECT_THAT(Results.Completions, ElementsAre(Named("Adapter")));
+ EXPECT_THAT(Results.Completions, ElementsAre(named("Adapter")));
}
TEST(CompletionTest, ScopedNoIndex) {
@@ -624,7 +624,7 @@ TEST(CompletionTest, ScopedNoIndex) {
")cpp");
// Babble is a better match than BigBang. Box doesn't match at all.
EXPECT_THAT(Results.Completions,
- ElementsAre(Named("Babble"), Named("BigBang")));
+ ElementsAre(named("Babble"), named("BigBang")));
}
TEST(CompletionTest, Scoped) {
@@ -635,7 +635,7 @@ TEST(CompletionTest, Scoped) {
")cpp",
{var("fake::BigBang")});
EXPECT_THAT(Results.Completions,
- ElementsAre(Named("Babble"), Named("BigBang")));
+ ElementsAre(named("Babble"), named("BigBang")));
}
TEST(CompletionTest, ScopedWithFilter) {
@@ -644,17 +644,17 @@ TEST(CompletionTest, ScopedWithFilter) {
void f() { ns::x^ }
)cpp",
{cls("ns::XYZ"), func("ns::foo")});
- EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("XYZ")));
+ EXPECT_THAT(Results.Completions, UnorderedElementsAre(named("XYZ")));
}
TEST(CompletionTest, ReferencesAffectRanking) {
EXPECT_THAT(completions("int main() { abs^ }", {func("absA"), func("absB")})
.Completions,
- HasSubsequence(Named("absA"), Named("absB")));
+ HasSubsequence(named("absA"), named("absB")));
EXPECT_THAT(completions("int main() { abs^ }",
{func("absA"), withReferences(1000, func("absB"))})
.Completions,
- HasSubsequence(Named("absB"), Named("absA")));
+ HasSubsequence(named("absB"), named("absA")));
}
TEST(CompletionTest, ContextWords) {
@@ -669,7 +669,7 @@ TEST(CompletionTest, ContextWords) {
// Yellow would normally sort last (alphabetic).
// But the recent mention should bump it up.
ASSERT_THAT(Results.Completions,
- HasSubsequence(Named("YELLOW"), Named("BLUE")));
+ HasSubsequence(named("YELLOW"), named("BLUE")));
}
TEST(CompletionTest, GlobalQualified) {
@@ -679,8 +679,8 @@ TEST(CompletionTest, GlobalQualified) {
)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) {
@@ -691,8 +691,8 @@ TEST(CompletionTest, FullyQualified) {
)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) {
@@ -705,10 +705,10 @@ TEST(CompletionTest, SemaIndexMerge) {
// We get results from both index and sema, with no duplicates.
EXPECT_THAT(Results.Completions,
UnorderedElementsAre(
- AllOf(Named("local"), Origin(SymbolOrigin::AST)),
- AllOf(Named("Index"), Origin(SymbolOrigin::Static)),
- AllOf(Named("both"),
- Origin(SymbolOrigin::AST | SymbolOrigin::Static))));
+ AllOf(named("local"), origin(SymbolOrigin::AST)),
+ AllOf(named("Index"), origin(SymbolOrigin::Static)),
+ AllOf(named("both"),
+ origin(SymbolOrigin::AST | SymbolOrigin::Static))));
}
TEST(CompletionTest, SemaIndexMergeWithLimit) {
@@ -738,13 +738,13 @@ TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
TU.Code = Test.code().str();
auto Results = completions(TU, Test.point(), {Sym});
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("X"), InsertInclude("\"bar.h\""))));
+ ElementsAre(AllOf(named("X"), insertInclude("\"bar.h\""))));
// Can be disabled via option.
CodeCompleteOptions NoInsertion;
NoInsertion.InsertIncludes = CodeCompleteOptions::NeverInsert;
Results = completions(TU, Test.point(), {Sym}, NoInsertion);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("X"), Not(InsertInclude()))));
+ ElementsAre(AllOf(named("X"), Not(insertInclude()))));
// Duplicate based on inclusions in preamble.
Test = Annotations(R"cpp(
#include "sub/bar.h" // not shortest, so should only match resolved.
@@ -752,8 +752,8 @@ TEST(CompletionTest, IncludeInsertionPreprocessorIntegrationTests) {
)cpp");
TU.Code = Test.code().str();
Results = completions(TU, Test.point(), {Sym});
- EXPECT_THAT(Results.Completions, ElementsAre(AllOf(Named("X"), Labeled("X"),
- Not(InsertInclude()))));
+ EXPECT_THAT(Results.Completions, ElementsAre(AllOf(named("X"), labeled("X"),
+ Not(insertInclude()))));
}
TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
@@ -775,8 +775,8 @@ TEST(CompletionTest, NoIncludeInsertionWhenDeclFoundInFile) {
)cpp",
{SymX, SymY});
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Named("X"), Not(InsertInclude())),
- AllOf(Named("Y"), Not(InsertInclude()))));
+ ElementsAre(AllOf(named("X"), Not(insertInclude())),
+ AllOf(named("Y"), Not(insertInclude()))));
}
TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
@@ -795,14 +795,14 @@ TEST(CompletionTest, IndexSuppressesPreambleCompletions) {
Opts.Index = I.get();
auto WithIndex = completions(TU, Test.point(), {}, Opts);
EXPECT_THAT(WithIndex.Completions,
- UnorderedElementsAre(Named("local"), Named("index")));
+ UnorderedElementsAre(named("local"), named("index")));
auto ClassFromPreamble = completions(TU, Test.point("2"), {}, Opts);
- EXPECT_THAT(ClassFromPreamble.Completions, Contains(Named("member")));
+ EXPECT_THAT(ClassFromPreamble.Completions, Contains(named("member")));
Opts.Index = nullptr;
auto WithoutIndex = completions(TU, Test.point(), {}, Opts);
EXPECT_THAT(WithoutIndex.Completions,
- UnorderedElementsAre(Named("local"), Named("preamble")));
+ UnorderedElementsAre(named("local"), named("preamble")));
}
// This verifies that we get normal preprocessor completions in the preamble.
@@ -818,7 +818,7 @@ TEST(CompletionTest, CompletionInPreamble) {
#endif
)cpp")
.Completions;
- EXPECT_THAT(Results, ElementsAre(Named("ifndef")));
+ EXPECT_THAT(Results, ElementsAre(named("ifndef")));
}
TEST(CompletionTest, CompletionRecoveryASTType) {
@@ -830,7 +830,7 @@ TEST(CompletionTest, CompletionRecoveryASTType) {
overloaded().^
})cpp")
.Completions;
- EXPECT_THAT(Results, ElementsAre(Named("member")));
+ EXPECT_THAT(Results, ElementsAre(named("member")));
}
TEST(CompletionTest, DynamicIndexIncludeInsertion) {
@@ -864,8 +864,8 @@ TEST(CompletionTest, DynamicIndexIncludeInsertion) {
llvm::cantFail(runCodeComplete(Server, File, Test.point(), {}));
EXPECT_THAT(CompletionList.Completions,
- ElementsAre(AllOf(Named("Foo"), HasInclude("\"foo_header.h\""),
- InsertInclude())));
+ ElementsAre(AllOf(named("Foo"), hasInclude("\"foo_header.h\""),
+ insertInclude())));
}
TEST(CompletionTest, DynamicIndexMultiFile) {
@@ -896,12 +896,12 @@ TEST(CompletionTest, DynamicIndexMultiFile) {
auto Results = cantFail(runCodeComplete(Server, File, Test.point(), {}));
// "XYZ" and "foo" are not included in the file being completed but are still
// visible through the index.
- EXPECT_THAT(Results.Completions, Has("XYZ", CompletionItemKind::Class));
- EXPECT_THAT(Results.Completions, Has("foo", CompletionItemKind::Function));
- EXPECT_THAT(Results.Completions, Has("XXX", CompletionItemKind::Class));
+ EXPECT_THAT(Results.Completions, has("XYZ", CompletionItemKind::Class));
+ EXPECT_THAT(Results.Completions, has("foo", CompletionItemKind::Function));
+ EXPECT_THAT(Results.Completions, has("XXX", CompletionItemKind::Class));
EXPECT_THAT(Results.Completions,
- Contains((Named("fooooo"), Kind(CompletionItemKind::Function),
- Doc("Doooc"), ReturnType("void"))));
+ Contains((named("fooooo"), kind(CompletionItemKind::Function),
+ doc("Doooc"), returnType("void"))));
}
TEST(CompletionTest, Documentation) {
@@ -920,13 +920,14 @@ TEST(CompletionTest, Documentation) {
int x = ^
)cpp");
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Named("foo"),
- Doc("Annotation: custom_annotation\nNon-doxygen comment."))));
+ Contains(AllOf(
+ named("foo"),
+ doc("Annotation: custom_annotation\nNon-doxygen comment."))));
EXPECT_THAT(
Results.Completions,
- Contains(AllOf(Named("bar"), Doc("Doxygen comment.\n\\param int a"))));
+ Contains(AllOf(named("bar"), doc("Doxygen comment.\n\\param int a"))));
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Named("baz"), Doc("Multi-line block comment"))));
+ Contains(AllOf(named("baz"), doc("Multi-line block comment"))));
}
TEST(CompletionTest, CommentsFromSystemHeaders) {
@@ -956,7 +957,7 @@ int x = foo^
EXPECT_THAT(
CompletionList.Completions,
- Contains(AllOf(Named("foo"), Doc("This comment should be retained!"))));
+ Contains(AllOf(named("foo"), doc("This comment should be retained!"))));
}
TEST(CompletionTest, GlobalCompletionFiltering) {
@@ -991,8 +992,8 @@ TEST(CodeCompleteTest, NoColonColonAtTheEnd) {
}
)cpp");
- EXPECT_THAT(Results.Completions, Contains(Labeled("clang")));
- EXPECT_THAT(Results.Completions, Not(Contains(Labeled("clang::"))));
+ EXPECT_THAT(Results.Completions, Contains(labeled("clang")));
+ EXPECT_THAT(Results.Completions, Not(Contains(labeled("clang::"))));
}
TEST(CompletionTest, BacktrackCrashes) {
@@ -1005,7 +1006,7 @@ TEST(CompletionTest, BacktrackCrashes) {
int foo(ns::FooBar^
)cpp");
- EXPECT_THAT(Results.Completions, ElementsAre(Labeled("FooBarBaz")));
+ EXPECT_THAT(Results.Completions, ElementsAre(labeled("FooBarBaz")));
// Check we don't crash in that case too.
completions(R"cpp(
@@ -1032,7 +1033,7 @@ int f(int input_num) {
)cpp");
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Named("X"), Named("Y")));
+ UnorderedElementsAre(named("X"), named("Y")));
}
TEST(CompletionTest, CompleteInMacroAndNamespaceWithStringification) {
@@ -1049,7 +1050,7 @@ int f(int input_num) {
} // namespace ns
)cpp");
- EXPECT_THAT(Results.Completions, Contains(Named("X")));
+ EXPECT_THAT(Results.Completions, Contains(named("X")));
}
TEST(CompletionTest, IgnoreCompleteInExcludedPPBranchWithRecoveryContext) {
@@ -1080,14 +1081,14 @@ TEST(CompletionTest, DefaultArgs) {
int Z(int A, int B = 0, int C = 0, int D = 0);
)cpp";
EXPECT_THAT(completions(Context + "int y = X^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("X(int A = 0)")));
+ UnorderedElementsAre(labeled("X(int A = 0)")));
EXPECT_THAT(completions(Context + "int y = Y^", {}, Opts).Completions,
- UnorderedElementsAre(AllOf(Labeled("Y(int A, int B = 0)"),
- SnippetSuffix("(${1:int A})"))));
+ UnorderedElementsAre(AllOf(labeled("Y(int A, int B = 0)"),
+ snippetSuffix("(${1:int A})"))));
EXPECT_THAT(completions(Context + "int y = Z^", {}, Opts).Completions,
UnorderedElementsAre(
- AllOf(Labeled("Z(int A, int B = 0, int C = 0, int D = 0)"),
- SnippetSuffix("(${1:int A})"))));
+ AllOf(labeled("Z(int A, int B = 0, int C = 0, int D = 0)"),
+ snippetSuffix("(${1:int A})"))));
}
TEST(CompletionTest, NoCrashWithTemplateParamsAndPreferredTypes) {
@@ -1097,7 +1098,7 @@ template <template <class> class TT> int foo() {
}
)cpp")
.Completions;
- EXPECT_THAT(Completions, Contains(Named("TT")));
+ EXPECT_THAT(Completions, Contains(named("TT")));
}
TEST(CompletionTest, NestedTemplateHeuristics) {
@@ -1111,7 +1112,7 @@ template <typename T> void foo(Templ<T> &t) {
}
)cpp")
.Completions;
- EXPECT_THAT(Completions, Contains(Named("xxx")));
+ EXPECT_THAT(Completions, Contains(named("xxx")));
}
TEST(CompletionTest, RecordCCResultCallback) {
@@ -1126,7 +1127,7 @@ TEST(CompletionTest, RecordCCResultCallback) {
completions("int xy1, xy2; int a = xy^", /*IndexSymbols=*/{}, Opts);
EXPECT_THAT(RecordedCompletions,
- UnorderedElementsAre(Named("xy1"), Named("xy2")));
+ UnorderedElementsAre(named("xy1"), named("xy2")));
}
TEST(CompletionTest, ASTSignals) {
@@ -1164,12 +1165,12 @@ TEST(CompletionTest, ASTSignals) {
Opts);
EXPECT_THAT(RecordedCompletions,
UnorderedElementsAre(
- AllOf(Named("xy1"), MainFileRefs(3u), ScopeRefs(0u)),
- AllOf(Named("xy2"), MainFileRefs(1u), ScopeRefs(0u)),
- AllOf(Named("xyindex"), MainFileRefs(10u), ScopeRefs(0u)),
- AllOf(Named("xytar"), MainFileRefs(0u), ScopeRefs(5u)),
- AllOf(/*both from sema and index*/ Named("xybar"),
- MainFileRefs(0u), ScopeRefs(3u))));
+ AllOf(named("xy1"), mainFileRefs(3u), scopeRefs(0u)),
+ AllOf(named("xy2"), mainFileRefs(1u), scopeRefs(0u)),
+ AllOf(named("xyindex"), mainFileRefs(10u), scopeRefs(0u)),
+ AllOf(named("xytar"), mainFileRefs(0u), scopeRefs(5u)),
+ AllOf(/*both from sema and index*/ named("xybar"),
+ mainFileRefs(0u), scopeRefs(3u))));
}
SignatureHelp
@@ -1216,7 +1217,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
const ExpectedParameter &P) {
return OS << P.Text;
}
-MATCHER_P(ParamsAre, P, "") {
+MATCHER_P(paramsAre, P, "") {
if (P.size() != arg.parameters.size())
return false;
for (unsigned I = 0; I < P.size(); ++I) {
@@ -1226,11 +1227,11 @@ MATCHER_P(ParamsAre, P, "") {
}
return true;
}
-MATCHER_P(SigDoc, Doc, "") { return arg.documentation.value == Doc; }
+MATCHER_P(sigDoc, doc, "") { return arg.documentation.value == doc; }
/// \p AnnotatedLabel is a signature label with ranges marking parameters, e.g.
/// foo([[int p1]], [[double p2]]) -> void
-Matcher<SignatureInformation> Sig(llvm::StringRef AnnotatedLabel) {
+Matcher<SignatureInformation> sig(llvm::StringRef AnnotatedLabel) {
llvm::Annotations A(AnnotatedLabel);
std::string Label = std::string(A.code());
std::vector<ExpectedParameter> Parameters;
@@ -1242,7 +1243,7 @@ Matcher<SignatureInformation> Sig(llvm::StringRef AnnotatedLabel) {
P.Offsets.first = lspLength(llvm::StringRef(Label).substr(0, Range.Begin));
P.Offsets.second = lspLength(llvm::StringRef(Label).substr(1, Range.End));
}
- return AllOf(SigHelpLabeled(Label), ParamsAre(Parameters));
+ return AllOf(sigHelpLabeled(Label), paramsAre(Parameters));
}
TEST(SignatureHelpTest, Overloads) {
@@ -1255,10 +1256,10 @@ TEST(SignatureHelpTest, Overloads) {
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);
@@ -1274,7 +1275,7 @@ TEST(SignatureHelpTest, Constructors) {
auto CheckParenInit = [&](std::string Init) {
EXPECT_THAT(signatures(Top + Init).signatures,
- UnorderedElementsAre(Sig("S([[int]])")))
+ UnorderedElementsAre(sig("S([[int]])")))
<< Init;
};
CheckParenInit("S s(^);");
@@ -1283,7 +1284,7 @@ TEST(SignatureHelpTest, Constructors) {
auto CheckBracedInit = [&](std::string Init) {
EXPECT_THAT(signatures(Top + Init).signatures,
- UnorderedElementsAre(Sig("S{[[int]]}")))
+ UnorderedElementsAre(sig("S{[[int]]}")))
<< Init;
};
CheckBracedInit("S s{^};");
@@ -1300,11 +1301,11 @@ TEST(SignatureHelpTest, Aggregates) {
int a, b, c, d;
};
)cpp";
- auto AggregateSig = Sig("S{[[int a]], [[int b]], [[int c]], [[int d]]}");
+ auto AggregateSig = sig("S{[[int a]], [[int b]], [[int c]], [[int d]]}");
EXPECT_THAT(signatures(Top + "S s{^}").signatures,
- UnorderedElementsAre(AggregateSig, Sig("S{}"),
- Sig("S{[[const S &]]}"),
- Sig("S{[[S &&]]}")));
+ UnorderedElementsAre(AggregateSig, sig("S{}"),
+ sig("S{[[const S &]]}"),
+ sig("S{[[S &&]]}")));
EXPECT_THAT(signatures(Top + "S s{1,^}").signatures,
ElementsAre(AggregateSig));
EXPECT_EQ(signatures(Top + "S s{1,^}").activeParameter, 1);
@@ -1323,7 +1324,7 @@ TEST(SignatureHelpTest, OverloadInitListRegression) {
f(^);
}
)cpp");
- EXPECT_THAT(Results.signatures, UnorderedElementsAre(Sig("f() -> void")));
+ EXPECT_THAT(Results.signatures, UnorderedElementsAre(sig("f() -> void")));
}
TEST(SignatureHelpTest, DefaultArgs) {
@@ -1334,8 +1335,8 @@ TEST(SignatureHelpTest, DefaultArgs) {
)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);
}
@@ -1346,7 +1347,7 @@ TEST(SignatureHelpTest, ActiveArg) {
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);
}
@@ -1450,7 +1451,7 @@ TEST(SignatureHelpTest, StalePreamble) {
auto Results =
signatureHelp(testPath(TU.Filename), Test.point(), *EmptyPreamble,
TU.inputs(FS), MarkupKind::PlainText);
- EXPECT_THAT(Results.signatures, ElementsAre(Sig("foo([[int x]]) -> int")));
+ EXPECT_THAT(Results.signatures, ElementsAre(sig("foo([[int x]]) -> int")));
EXPECT_EQ(0, Results.activeSignature);
EXPECT_EQ(0, Results.activeParameter);
}
@@ -1662,9 +1663,9 @@ TEST(CompletionTest, NoIndexCompletionsInsideClasses) {
{func("::SomeNameInTheIndex"), func("::Foo::SomeNameInTheIndex")});
EXPECT_THAT(Completions.Completions,
- AllOf(Contains(Labeled("SomeNameOfField")),
- Contains(Labeled("SomeNameOfTypedefField")),
- Not(Contains(Labeled("SomeNameInTheIndex")))));
+ AllOf(Contains(labeled("SomeNameOfField")),
+ Contains(labeled("SomeNameOfTypedefField")),
+ Not(Contains(labeled("SomeNameInTheIndex")))));
}
TEST(CompletionTest, NoIndexCompletionsInsideDependentCode) {
@@ -1679,7 +1680,7 @@ TEST(CompletionTest, NoIndexCompletionsInsideDependentCode) {
{func("::SomeNameInTheIndex")});
EXPECT_THAT(Completions.Completions,
- Not(Contains(Labeled("SomeNameInTheIndex"))));
+ Not(Contains(labeled("SomeNameInTheIndex"))));
}
{
@@ -1693,7 +1694,7 @@ TEST(CompletionTest, NoIndexCompletionsInsideDependentCode) {
{func("::SomeNameInTheIndex")});
EXPECT_THAT(Completions.Completions,
- Not(Contains(Labeled("SomeNameInTheIndex"))));
+ Not(Contains(labeled("SomeNameInTheIndex"))));
}
{
@@ -1707,7 +1708,7 @@ TEST(CompletionTest, NoIndexCompletionsInsideDependentCode) {
{func("::SomeNameInTheIndex")});
EXPECT_THAT(Completions.Completions,
- Not(Contains(Labeled("SomeNameInTheIndex"))));
+ Not(Contains(labeled("SomeNameInTheIndex"))));
}
}
@@ -1732,17 +1733,17 @@ TEST(CompletionTest, OverloadBundling) {
// Member completions are bundled.
EXPECT_THAT(completions(Context + "int y = X().^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("a(…)"), Labeled("b(float)")));
+ UnorderedElementsAre(labeled("a(…)"), labeled("b(float)")));
// Constructor completions are bundled.
EXPECT_THAT(completions(Context + "X z = X^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("X"), Labeled("X(…)")));
+ UnorderedElementsAre(labeled("X"), labeled("X(…)")));
// Non-member completions are bundled, including index+sema.
Symbol NoArgsGFunc = func("GFuncC");
EXPECT_THAT(
completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
- UnorderedElementsAre(Labeled("GFuncC(…)"), Labeled("GFuncD(int)")));
+ UnorderedElementsAre(labeled("GFuncC(…)"), labeled("GFuncD(int)")));
// Differences in header-to-insert suppress bundling.
std::string DeclFile = URI::create(testPath("foo")).toString();
@@ -1750,8 +1751,8 @@ TEST(CompletionTest, OverloadBundling) {
NoArgsGFunc.IncludeHeaders.emplace_back("<foo>", 1);
EXPECT_THAT(
completions(Context + "int y = GFunc^", {NoArgsGFunc}, Opts).Completions,
- UnorderedElementsAre(AllOf(Named("GFuncC"), InsertInclude("<foo>")),
- Labeled("GFuncC(int)"), Labeled("GFuncD(int)")));
+ UnorderedElementsAre(AllOf(named("GFuncC"), insertInclude("<foo>")),
+ labeled("GFuncC(int)"), labeled("GFuncD(int)")));
// Examine a bundled completion in detail.
auto A =
@@ -1828,7 +1829,7 @@ TEST(CompletionTest, DocumentationFromChangedFileCrash) {
// We shouldn't crash. Unfortunately, current workaround is to not produce
// comments for symbols from headers.
EXPECT_THAT(Completions.Completions,
- Contains(AllOf(Not(IsDocumented()), Named("func"))));
+ Contains(AllOf(Not(isDocumented()), named("func"))));
}
TEST(CompletionTest, NonDocComments) {
@@ -1872,16 +1873,16 @@ TEST(CompletionTest, NonDocComments) {
// We should not get any of those comments in completion.
EXPECT_THAT(
completions(Text).Completions,
- UnorderedElementsAre(AllOf(Not(IsDocumented()), Named("comments_foo")),
- AllOf(IsDocumented(), Named("comments_baz")),
- AllOf(IsDocumented(), Named("comments_quux")),
- AllOf(Not(IsDocumented()), Named("comments_ns")),
+ UnorderedElementsAre(AllOf(Not(isDocumented()), named("comments_foo")),
+ AllOf(isDocumented(), named("comments_baz")),
+ AllOf(isDocumented(), named("comments_quux")),
+ AllOf(Not(isDocumented()), named("comments_ns")),
// FIXME(ibiryukov): the following items should have
// empty documentation, since they are separated from
// a comment with an empty line. Unfortunately, I
// couldn't make Sema tests pass if we ignore those.
- AllOf(IsDocumented(), Named("comments_bar")),
- AllOf(IsDocumented(), Named("comments_qux"))));
+ AllOf(isDocumented(), named("comments_bar")),
+ AllOf(isDocumented(), named("comments_qux"))));
}
TEST(CompletionTest, CompleteOnInvalidLine) {
@@ -1911,7 +1912,7 @@ TEST(CompletionTest, QualifiedNames) {
// We get results from both index and sema, with no duplicates.
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(Scope("ns::"), Scope("ns::"), Scope("ns::")));
+ UnorderedElementsAre(scope("ns::"), scope("ns::"), scope("ns::")));
}
TEST(CompletionTest, Render) {
@@ -1991,7 +1992,7 @@ TEST(CompletionTest, IgnoreRecoveryResults) {
if (auto x = ns::NotRecover^)
}
)cpp");
- EXPECT_THAT(Results.Completions, UnorderedElementsAre(Named("NotRecovered")));
+ EXPECT_THAT(Results.Completions, UnorderedElementsAre(named("NotRecovered")));
}
TEST(CompletionTest, ScopeOfClassFieldInConstructorInitializer) {
@@ -2003,7 +2004,7 @@ TEST(CompletionTest, ScopeOfClassFieldInConstructorInitializer) {
}
)cpp");
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Scope("ns::X::"), Named("x_"))));
+ UnorderedElementsAre(AllOf(scope("ns::X::"), named("x_"))));
}
// Like other class members, constructor init lists have to parse what's below,
@@ -2020,7 +2021,7 @@ TEST(CompletionTest, ConstructorInitListIncomplete) {
};
}
)cpp");
- EXPECT_THAT(Results.Completions, ElementsAre(Named("xyz_")));
+ EXPECT_THAT(Results.Completions, ElementsAre(named("xyz_")));
Results = completions(
R"cpp(
@@ -2033,7 +2034,7 @@ TEST(CompletionTest, ConstructorInitListIncomplete) {
};
}
)cpp");
- EXPECT_THAT(Results.Completions, ElementsAre(Named("foo")));
+ EXPECT_THAT(Results.Completions, ElementsAre(named("foo")));
}
TEST(CompletionTest, CodeCompletionContext) {
@@ -2219,11 +2220,11 @@ TEST(SignatureHelpTest, OverloadsOrdering) {
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);
@@ -2240,7 +2241,7 @@ TEST(SignatureHelpTest, InstantiatedSignatures) {
)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>
@@ -2251,7 +2252,7 @@ TEST(SignatureHelpTest, InstantiatedSignatures) {
})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>
@@ -2263,7 +2264,7 @@ TEST(SignatureHelpTest, InstantiatedSignatures) {
)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
@@ -2283,14 +2284,14 @@ TEST(SignatureHelpTest, InstantiatedSignatures) {
)cpp";
EXPECT_THAT(signatures(Sig3).signatures,
- ElementsAre(Sig("foo([[T]], [[U]]) -> void")));
+ ElementsAre(sig("foo([[T]], [[U]]) -> void")));
}
TEST(SignatureHelpTest, IndexDocumentation) {
Symbol Foo0 = sym("foo", index::SymbolKind::Function, "@F@\\0#");
- Foo0.Documentation = "Doc from the index";
+ Foo0.Documentation = "doc from the index";
Symbol Foo1 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#");
- Foo1.Documentation = "Doc from the index";
+ Foo1.Documentation = "doc from the index";
Symbol Foo2 = sym("foo", index::SymbolKind::Function, "@F@\\0#I#I#");
StringRef Sig0 = R"cpp(
@@ -2304,14 +2305,14 @@ TEST(SignatureHelpTest, IndexDocumentation) {
EXPECT_THAT(
signatures(Sig0, {Foo0}).signatures,
- ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Doc from the index")),
- AllOf(Sig("foo([[double]]) -> int"), SigDoc(""))));
+ ElementsAre(AllOf(sig("foo() -> int"), sigDoc("doc from the index")),
+ AllOf(sig("foo([[double]]) -> int"), sigDoc(""))));
StringRef Sig1 = R"cpp(
int foo();
// Overriden doc from sema
int foo(int);
- // Doc from sema
+ // doc from sema
int foo(int, int);
void test() {
@@ -2322,9 +2323,9 @@ TEST(SignatureHelpTest, IndexDocumentation) {
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) {
@@ -2354,7 +2355,7 @@ TEST(SignatureHelpTest, DynamicIndexDocumentation) {
EXPECT_THAT(llvm::cantFail(runSignatureHelp(Server, File, FileContent.point(),
MarkupKind::PlainText))
.signatures,
- ElementsAre(AllOf(Sig("foo() -> int"), SigDoc("Member doc"))));
+ ElementsAre(AllOf(sig("foo() -> int"), sigDoc("Member doc"))));
}
TEST(CompletionTest, CompletionFunctionArgsDisabled) {
@@ -2371,8 +2372,8 @@ TEST(CompletionTest, CompletionFunctionArgsDisabled) {
{}, Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("()")),
- AllOf(Named("xfoo"), SnippetSuffix("($0)"))));
+ UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix("()")),
+ AllOf(named("xfoo"), snippetSuffix("($0)"))));
}
{
auto Results = completions(
@@ -2381,7 +2382,7 @@ TEST(CompletionTest, CompletionFunctionArgsDisabled) {
void f() { xba^ })cpp",
{}, Opts);
EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf(
- Named("xbar"), SnippetSuffix("()"))));
+ named("xbar"), snippetSuffix("()"))));
}
{
Opts.BundleOverloads = true;
@@ -2393,7 +2394,7 @@ TEST(CompletionTest, CompletionFunctionArgsDisabled) {
{}, Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("($0)"))));
+ UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix("($0)"))));
}
{
auto Results = completions(
@@ -2404,7 +2405,7 @@ TEST(CompletionTest, CompletionFunctionArgsDisabled) {
{}, Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("xfoo"), SnippetSuffix("<$1>($0)"))));
+ UnorderedElementsAre(AllOf(named("xfoo"), snippetSuffix("<$1>($0)"))));
}
{
auto Results = completions(
@@ -2417,8 +2418,8 @@ TEST(CompletionTest, CompletionFunctionArgsDisabled) {
{}, Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Named("foo_class"), SnippetSuffix("<$0>")),
- AllOf(Named("foo_alias"), SnippetSuffix("<$0>"))));
+ UnorderedElementsAre(AllOf(named("foo_class"), snippetSuffix("<$0>")),
+ AllOf(named("foo_alias"), snippetSuffix("<$0>"))));
}
{
auto Results = completions(
@@ -2427,7 +2428,7 @@ TEST(CompletionTest, CompletionFunctionArgsDisabled) {
FO^ )cpp",
{}, Opts);
EXPECT_THAT(Results.Completions, UnorderedElementsAre(AllOf(
- Named("FOO"), SnippetSuffix("($0)"))));
+ named("FOO"), snippetSuffix("($0)"))));
}
}
@@ -2452,11 +2453,11 @@ TEST(CompletionTest, SuggestOverrides) {
const auto Results = completions(Text);
EXPECT_THAT(
Results.Completions,
- AllOf(Contains(AllOf(Labeled("void vfunc(bool param, int p) override"),
- NameStartsWith("vfunc"))),
- Contains(AllOf(Labeled("void ttt(bool param) const override"),
- NameStartsWith("ttt"))),
- Not(Contains(Labeled("void vfunc(bool param) override")))));
+ AllOf(Contains(AllOf(labeled("void vfunc(bool param, int p) override"),
+ nameStartsWith("vfunc"))),
+ Contains(AllOf(labeled("void ttt(bool param) const override"),
+ nameStartsWith("ttt"))),
+ Not(Contains(labeled("void vfunc(bool param) override")))));
}
TEST(CompletionTest, OverridesNonIdentName) {
@@ -2577,7 +2578,7 @@ TEST(CompletionTest, InsertTheMostPopularHeader) {
auto Results = completions("Fun^", {Sym}).Completions;
assert(!Results.empty());
- EXPECT_THAT(Results[0], AllOf(Named("Func"), InsertInclude("\"bar.h\"")));
+ EXPECT_THAT(Results[0], AllOf(named("Func"), insertInclude("\"bar.h\"")));
EXPECT_EQ(Results[0].Includes.size(), 2u);
}
@@ -2596,8 +2597,8 @@ TEST(CompletionTest, NoInsertIncludeIfOnePresent) {
Sym.IncludeHeaders.emplace_back("\"bar.h\"", 1000);
EXPECT_THAT(completions(TU, Test.point(), {Sym}).Completions,
- UnorderedElementsAre(AllOf(Named("Func"), HasInclude("\"foo.h\""),
- Not(InsertInclude()))));
+ UnorderedElementsAre(AllOf(named("Func"), hasInclude("\"foo.h\""),
+ Not(insertInclude()))));
}
TEST(CompletionTest, MergeMacrosFromIndexAndSema) {
@@ -2608,7 +2609,7 @@ TEST(CompletionTest, MergeMacrosFromIndexAndSema) {
Sym.Flags |= Symbol::IndexedForCodeCompletion;
EXPECT_THAT(completions("#define Clangd_Macro_Test\nClangd_Macro_T^", {Sym})
.Completions,
- UnorderedElementsAre(Named("Clangd_Macro_Test")));
+ UnorderedElementsAre(named("Clangd_Macro_Test")));
}
TEST(CompletionTest, MacroFromPreamble) {
@@ -2624,9 +2625,9 @@ TEST(CompletionTest, MacroFromPreamble) {
// We should get results from the main file, including the preamble section.
// However no results from included files (the index should cover them).
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Named("CLANGD_PREAMBLE_MAIN"),
- Named("CLANGD_MAIN"),
- Named("CLANGD_INDEX")));
+ UnorderedElementsAre(named("CLANGD_PREAMBLE_MAIN"),
+ named("CLANGD_MAIN"),
+ named("CLANGD_INDEX")));
}
TEST(CompletionTest, DeprecatedResults) {
@@ -2637,8 +2638,8 @@ TEST(CompletionTest, DeprecatedResults) {
EXPECT_THAT(
completions(Body + "int main() { TestClang^ }").Completions,
- UnorderedElementsAre(AllOf(Named("TestClangd"), Not(Deprecated())),
- AllOf(Named("TestClangc"), Deprecated())));
+ UnorderedElementsAre(AllOf(named("TestClangd"), Not(deprecated())),
+ AllOf(named("TestClangc"), deprecated())));
}
TEST(SignatureHelpTest, PartialSpec) {
@@ -2646,7 +2647,7 @@ TEST(SignatureHelpTest, PartialSpec) {
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);
}
@@ -2658,8 +2659,8 @@ TEST(SignatureHelpTest, InsideArgument) {
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);
}
{
@@ -2669,8 +2670,8 @@ TEST(SignatureHelpTest, InsideArgument) {
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);
}
{
@@ -2680,8 +2681,8 @@ TEST(SignatureHelpTest, InsideArgument) {
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);
}
{
@@ -2692,7 +2693,7 @@ TEST(SignatureHelpTest, InsideArgument) {
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);
}
}
@@ -2707,8 +2708,8 @@ TEST(SignatureHelpTest, ConstructorInitializeFields) {
};
)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(
@@ -2732,8 +2733,8 @@ TEST(SignatureHelpTest, ConstructorInitializeFields) {
};
)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(
@@ -2750,8 +2751,8 @@ TEST(SignatureHelpTest, ConstructorInitializeFields) {
};
)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 &]])")));
}
}
@@ -2764,17 +2765,17 @@ TEST(SignatureHelpTest, Variadic) {
{
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)));
}
}
@@ -2788,17 +2789,17 @@ TEST(SignatureHelpTest, VariadicTemplate) {
{
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)));
}
}
@@ -2814,17 +2815,17 @@ TEST(SignatureHelpTest, VariadicMethod) {
{
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)));
}
}
@@ -2839,17 +2840,17 @@ TEST(SignatureHelpTest, VariadicType) {
{
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)));
}
}
@@ -2861,8 +2862,8 @@ TEST(CompletionTest, IncludedCompletionKinds) {
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) {
@@ -2883,7 +2884,7 @@ TEST(CompletionTest, NoAllScopesCompletionWhenQualified) {
{cls("na::ClangdA"), cls("nx::ClangdX"), cls("Clangd3")}, Opts);
EXPECT_THAT(Results.Completions,
UnorderedElementsAre(
- AllOf(Qualifier(""), Scope("na::"), Named("ClangdA"))));
+ AllOf(qualifier(""), scope("na::"), named("ClangdA"))));
}
TEST(CompletionTest, AllScopesCompletion) {
@@ -2901,10 +2902,10 @@ TEST(CompletionTest, AllScopesCompletion) {
Opts);
EXPECT_THAT(
Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier("nx::"), Named("Clangd1")),
- AllOf(Qualifier("ny::"), Named("Clangd2")),
- AllOf(Qualifier(""), Scope(""), Named("Clangd3")),
- AllOf(Qualifier("nb::"), Named("Clangd4"))));
+ UnorderedElementsAre(AllOf(qualifier("nx::"), named("Clangd1")),
+ AllOf(qualifier("ny::"), named("Clangd2")),
+ AllOf(qualifier(""), scope(""), named("Clangd3")),
+ AllOf(qualifier("nb::"), named("Clangd4"))));
}
TEST(CompletionTest, NoQualifierIfShadowed) {
@@ -2920,8 +2921,8 @@ TEST(CompletionTest, NoQualifierIfShadowed) {
// Although Clangd1 is from another namespace, Sema tells us it's in-scope and
// needs no qualifier.
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Named("Clangd1")),
- AllOf(Qualifier("nx::"), Named("Clangd2"))));
+ UnorderedElementsAre(AllOf(qualifier(""), named("Clangd1")),
+ AllOf(qualifier("nx::"), named("Clangd2"))));
}
TEST(CompletionTest, NoCompletionsForNewNames) {
@@ -2988,11 +2989,11 @@ TEST(CompletionTest, ObjectiveCMethodNoArguments) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("value")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(ReturnType("int")));
- EXPECT_THAT(C, ElementsAre(Signature("")));
- EXPECT_THAT(C, ElementsAre(SnippetSuffix("")));
+ EXPECT_THAT(C, ElementsAre(named("value")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(returnType("int")));
+ EXPECT_THAT(C, ElementsAre(signature("")));
+ EXPECT_THAT(C, ElementsAre(snippetSuffix("")));
}
TEST(CompletionTest, ObjectiveCMethodOneArgument) {
@@ -3006,11 +3007,11 @@ TEST(CompletionTest, ObjectiveCMethodOneArgument) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(ReturnType("int")));
- EXPECT_THAT(C, ElementsAre(Signature("(char)")));
- EXPECT_THAT(C, ElementsAre(SnippetSuffix("${1:(char)}")));
+ EXPECT_THAT(C, ElementsAre(named("valueForCharacter:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(returnType("int")));
+ EXPECT_THAT(C, ElementsAre(signature("(char)")));
+ EXPECT_THAT(C, ElementsAre(snippetSuffix("${1:(char)}")));
}
TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromBeginning) {
@@ -3024,12 +3025,12 @@ TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromBeginning) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("fooWithValue:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(ReturnType("id")));
- EXPECT_THAT(C, ElementsAre(Signature("(int) fooey:(unsigned int)")));
+ EXPECT_THAT(C, ElementsAre(named("fooWithValue:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(returnType("id")));
+ EXPECT_THAT(C, ElementsAre(signature("(int) fooey:(unsigned int)")));
EXPECT_THAT(
- C, ElementsAre(SnippetSuffix("${1:(int)} fooey:${2:(unsigned int)}")));
+ C, ElementsAre(snippetSuffix("${1:(int)} fooey:${2:(unsigned int)}")));
}
TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromMiddle) {
@@ -3043,11 +3044,11 @@ TEST(CompletionTest, ObjectiveCMethodTwoArgumentsFromMiddle) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("fooey:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(ReturnType("id")));
- EXPECT_THAT(C, ElementsAre(Signature("(unsigned int)")));
- EXPECT_THAT(C, ElementsAre(SnippetSuffix("${1:(unsigned int)}")));
+ EXPECT_THAT(C, ElementsAre(named("fooey:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(returnType("id")));
+ EXPECT_THAT(C, ElementsAre(signature("(unsigned int)")));
+ EXPECT_THAT(C, ElementsAre(snippetSuffix("${1:(unsigned int)}")));
}
TEST(CompletionTest, ObjectiveCSimpleMethodDeclaration) {
@@ -3063,9 +3064,9 @@ TEST(CompletionTest, ObjectiveCSimpleMethodDeclaration) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("foo")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(Qualifier("- (void)")));
+ EXPECT_THAT(C, ElementsAre(named("foo")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(qualifier("- (void)")));
}
TEST(CompletionTest, ObjectiveCMethodDeclaration) {
@@ -3081,10 +3082,10 @@ TEST(CompletionTest, ObjectiveCMethodDeclaration) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(Qualifier("- (int)")));
- EXPECT_THAT(C, ElementsAre(Signature("(char)c secondArgument:(id)object")));
+ EXPECT_THAT(C, ElementsAre(named("valueForCharacter:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(qualifier("- (int)")));
+ EXPECT_THAT(C, ElementsAre(signature("(char)c secondArgument:(id)object")));
}
TEST(CompletionTest, ObjectiveCMethodDeclarationPrefixTyped) {
@@ -3100,9 +3101,9 @@ TEST(CompletionTest, ObjectiveCMethodDeclarationPrefixTyped) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("valueForCharacter:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(Signature("(char)c")));
+ EXPECT_THAT(C, ElementsAre(named("valueForCharacter:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(signature("(char)c")));
}
TEST(CompletionTest, ObjectiveCMethodDeclarationFromMiddle) {
@@ -3118,9 +3119,9 @@ TEST(CompletionTest, ObjectiveCMethodDeclarationFromMiddle) {
/*Opts=*/{}, "Foo.m");
auto C = Results.Completions;
- EXPECT_THAT(C, ElementsAre(Named("secondArgument:")));
- EXPECT_THAT(C, ElementsAre(Kind(CompletionItemKind::Method)));
- EXPECT_THAT(C, ElementsAre(Signature("(id)object")));
+ EXPECT_THAT(C, ElementsAre(named("secondArgument:")));
+ EXPECT_THAT(C, ElementsAre(kind(CompletionItemKind::Method)));
+ EXPECT_THAT(C, ElementsAre(signature("(id)object")));
}
TEST(CompletionTest, CursorInSnippets) {
@@ -3137,12 +3138,12 @@ TEST(CompletionTest, CursorInSnippets) {
// Last placeholder in code patterns should be $0 to put the cursor there.
EXPECT_THAT(Results.Completions,
Contains(AllOf(
- Named("while"),
- SnippetSuffix(" (${1:condition}) {\n${0:statements}\n}"))));
+ named("while"),
+ snippetSuffix(" (${1:condition}) {\n${0:statements}\n}"))));
// However, snippets for functions must *not* end with $0.
EXPECT_THAT(Results.Completions,
- Contains(AllOf(Named("while_foo"),
- SnippetSuffix("(${1:int a}, ${2:int b})"))));
+ Contains(AllOf(named("while_foo"),
+ snippetSuffix("(${1:int a}, ${2:int b})"))));
}
TEST(CompletionTest, WorksWithNullType) {
@@ -3153,7 +3154,7 @@ TEST(CompletionTest, WorksWithNullType) {
}
}
)cpp");
- EXPECT_THAT(R.Completions, ElementsAre(Named("loopVar")));
+ EXPECT_THAT(R.Completions, ElementsAre(named("loopVar")));
}
TEST(CompletionTest, UsingDecl) {
@@ -3172,8 +3173,8 @@ TEST(CompletionTest, UsingDecl) {
Opts.AllScopes = true;
auto R = completions(Source, {}, Opts);
EXPECT_THAT(R.Completions,
- ElementsAre(AllOf(Scope("std::"), Named("foo"),
- Kind(CompletionItemKind::Reference))));
+ ElementsAre(AllOf(scope("std::"), named("foo"),
+ kind(CompletionItemKind::Reference))));
}
TEST(CompletionTest, ScopeIsUnresolved) {
@@ -3187,7 +3188,7 @@ TEST(CompletionTest, ScopeIsUnresolved) {
)cpp",
{cls("a::b::XYZ")}, Opts);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Named("XYZ"))));
+ UnorderedElementsAre(AllOf(qualifier(""), named("XYZ"))));
}
TEST(CompletionTest, NestedScopeIsUnresolved) {
@@ -3202,7 +3203,7 @@ TEST(CompletionTest, NestedScopeIsUnresolved) {
)cpp",
{cls("a::b::c::XYZ")}, Opts);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Named("XYZ"))));
+ UnorderedElementsAre(AllOf(qualifier(""), named("XYZ"))));
}
// Clang parser gets confused here and doesn't report the ns:: prefix.
@@ -3219,7 +3220,7 @@ TEST(CompletionTest, NamespaceDoubleInsertion) {
)cpp",
{cls("foo::ns::ABCDE")}, Opts);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Named("ABCDE"))));
+ UnorderedElementsAre(AllOf(qualifier(""), named("ABCDE"))));
}
TEST(CompletionTest, DerivedMethodsAreAlwaysVisible) {
@@ -3238,7 +3239,7 @@ TEST(CompletionTest, DerivedMethodsAreAlwaysVisible) {
)cpp")
.Completions;
EXPECT_THAT(Completions,
- ElementsAre(AllOf(ReturnType("int"), Named("size"))));
+ ElementsAre(AllOf(returnType("int"), named("size"))));
}
TEST(CompletionTest, NoCrashWithIncompleteLambda) {
@@ -3246,10 +3247,10 @@ TEST(CompletionTest, NoCrashWithIncompleteLambda) {
// The completion of x itself can cause a problem: in the code completion
// callback, its type is not known, which affects the linkage calculation.
// A bad linkage value gets cached, and subsequently updated.
- EXPECT_THAT(Completions, Contains(Named("x")));
+ EXPECT_THAT(Completions, Contains(named("x")));
auto Signatures = signatures("auto x() { x(^").signatures;
- EXPECT_THAT(Signatures, Contains(Sig("x() -> auto")));
+ EXPECT_THAT(Signatures, Contains(sig("x() -> auto")));
}
TEST(CompletionTest, DelayedTemplateParsing) {
@@ -3263,7 +3264,7 @@ TEST(CompletionTest, DelayedTemplateParsing) {
TU.ExtraArgs.push_back("-fdelayed-template-parsing");
EXPECT_THAT(completions(TU, Test.point()).Completions,
- Contains(Named("xxx")));
+ Contains(named("xxx")));
}
TEST(CompletionTest, CompletionRange) {
@@ -3298,8 +3299,8 @@ TEST(NoCompileCompletionTest, Basic) {
)cpp");
EXPECT_FALSE(Results.RanParser);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Named("void"), Named("func"), Named("int"),
- Named("xyz"), Named("abc")));
+ UnorderedElementsAre(named("void"), named("func"), named("int"),
+ named("xyz"), named("abc")));
}
TEST(NoCompileCompletionTest, WithFilter) {
@@ -3313,7 +3314,7 @@ TEST(NoCompileCompletionTest, WithFilter) {
}
)cpp");
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Named("sym1"), Named("sym2")));
+ UnorderedElementsAre(named("sym1"), named("sym2")));
}
TEST(NoCompileCompletionTest, WithIndex) {
@@ -3332,9 +3333,9 @@ TEST(NoCompileCompletionTest, WithIndex) {
)cpp",
Syms);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Scope("")),
- AllOf(Qualifier(""), Scope("a::")),
- AllOf(Qualifier(""), Scope("ns::b::"))));
+ UnorderedElementsAre(AllOf(qualifier(""), scope("")),
+ AllOf(qualifier(""), scope("a::")),
+ AllOf(qualifier(""), scope("ns::b::"))));
CodeCompleteOptions Opts;
Opts.AllScopes = true;
Results = completionsNoCompile(
@@ -3350,11 +3351,11 @@ TEST(NoCompileCompletionTest, WithIndex) {
)cpp",
Syms, Opts);
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(AllOf(Qualifier(""), Scope("")),
- AllOf(Qualifier(""), Scope("a::")),
- AllOf(Qualifier(""), Scope("ns::b::")),
- AllOf(Qualifier("c::"), Scope("c::")),
- AllOf(Qualifier("d::"), Scope("ns::d::"))));
+ UnorderedElementsAre(AllOf(qualifier(""), scope("")),
+ AllOf(qualifier(""), scope("a::")),
+ AllOf(qualifier(""), scope("ns::b::")),
+ AllOf(qualifier("c::"), scope("c::")),
+ AllOf(qualifier("d::"), scope("ns::d::"))));
Results = completionsNoCompile(
R"cpp(
// Qualified completion.
@@ -3368,7 +3369,7 @@ TEST(NoCompileCompletionTest, WithIndex) {
)cpp",
Syms, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Qualifier(""), Scope("ns::b::"))));
+ ElementsAre(AllOf(qualifier(""), scope("ns::b::"))));
Results = completionsNoCompile(
R"cpp(
// Absolutely qualified completion.
@@ -3382,7 +3383,7 @@ TEST(NoCompileCompletionTest, WithIndex) {
)cpp",
Syms, Opts);
EXPECT_THAT(Results.Completions,
- ElementsAre(AllOf(Qualifier(""), Scope("a::"))));
+ ElementsAre(AllOf(qualifier(""), scope("a::"))));
}
TEST(AllowImplicitCompletion, All) {
@@ -3430,44 +3431,44 @@ TEST(CompletionTest, FunctionArgsExist) {
)cpp";
EXPECT_THAT(completions(Context + "int y = fo^", {}, Opts).Completions,
UnorderedElementsAre(
- AllOf(Labeled("foo(int A)"), SnippetSuffix("(${1:int A})"))));
+ AllOf(labeled("foo(int A)"), snippetSuffix("(${1:int A})"))));
EXPECT_THAT(
completions(Context + "int y = fo^(42)", {}, Opts).Completions,
- UnorderedElementsAre(AllOf(Labeled("foo(int A)"), SnippetSuffix(""))));
+ UnorderedElementsAre(AllOf(labeled("foo(int A)"), snippetSuffix(""))));
// FIXME(kirillbobyrev): No snippet should be produced here.
EXPECT_THAT(completions(Context + "int y = fo^o(42)", {}, Opts).Completions,
UnorderedElementsAre(
- AllOf(Labeled("foo(int A)"), SnippetSuffix("(${1:int A})"))));
+ AllOf(labeled("foo(int A)"), snippetSuffix("(${1:int A})"))));
EXPECT_THAT(
completions(Context + "int y = ba^", {}, Opts).Completions,
- UnorderedElementsAre(AllOf(Labeled("bar()"), SnippetSuffix("()"))));
+ UnorderedElementsAre(AllOf(labeled("bar()"), snippetSuffix("()"))));
EXPECT_THAT(completions(Context + "int y = ba^()", {}, Opts).Completions,
- UnorderedElementsAre(AllOf(Labeled("bar()"), SnippetSuffix(""))));
+ UnorderedElementsAre(AllOf(labeled("bar()"), snippetSuffix(""))));
EXPECT_THAT(
completions(Context + "Object o = Obj^", {}, Opts).Completions,
- Contains(AllOf(Labeled("Object(int B)"), SnippetSuffix("(${1:int B})"),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Object(int B)"), snippetSuffix("(${1:int B})"),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(completions(Context + "Object o = Obj^()", {}, Opts).Completions,
- Contains(AllOf(Labeled("Object(int B)"), SnippetSuffix(""),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Object(int B)"), snippetSuffix(""),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(
completions(Context + "Container c = Cont^", {}, Opts).Completions,
- Contains(AllOf(Labeled("Container<typename T>(int Size)"),
- SnippetSuffix("<${1:typename T}>(${2:int Size})"),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Container<typename T>(int Size)"),
+ snippetSuffix("<${1:typename T}>(${2:int Size})"),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(
completions(Context + "Container c = Cont^()", {}, Opts).Completions,
- Contains(AllOf(Labeled("Container<typename T>(int Size)"),
- SnippetSuffix("<${1:typename T}>"),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Container<typename T>(int Size)"),
+ snippetSuffix("<${1:typename T}>"),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(
completions(Context + "Container c = Cont^<int>()", {}, Opts).Completions,
- Contains(AllOf(Labeled("Container<typename T>(int Size)"),
- SnippetSuffix(""),
- Kind(CompletionItemKind::Constructor))));
+ Contains(AllOf(labeled("Container<typename T>(int Size)"),
+ snippetSuffix(""),
+ kind(CompletionItemKind::Constructor))));
EXPECT_THAT(completions(Context + "MAC^(2)", {}, Opts).Completions,
- Contains(AllOf(Labeled("MACRO(x)"), SnippetSuffix(""),
- Kind(CompletionItemKind::Text))));
+ Contains(AllOf(labeled("MACRO(x)"), snippetSuffix(""),
+ kind(CompletionItemKind::Text))));
}
TEST(CompletionTest, NoCrashDueToMacroOrdering) {
@@ -3476,7 +3477,7 @@ TEST(CompletionTest, NoCrashDueToMacroOrdering) {
#define ECHO2(X) ECHO(X)
int finish_preamble = EC^HO(2);)cpp")
.Completions,
- UnorderedElementsAre(Labeled("ECHO(X)"), Labeled("ECHO2(X)")));
+ UnorderedElementsAre(labeled("ECHO(X)"), labeled("ECHO2(X)")));
}
TEST(CompletionTest, ObjCCategoryDecls) {
@@ -3506,7 +3507,7 @@ TEST(CompletionTest, ObjCCategoryDecls) {
TU.Code = Test.code().str();
auto Results = completions(TU, Test.point());
EXPECT_THAT(Results.Completions,
- UnorderedElementsAre(Labeled("FooExt1"), Labeled("FooExt2")));
+ UnorderedElementsAre(labeled("FooExt1"), labeled("FooExt2")));
}
{
Annotations Test(R"objc(
@@ -3515,7 +3516,7 @@ TEST(CompletionTest, ObjCCategoryDecls) {
)objc");
TU.Code = Test.code().str();
auto Results = completions(TU, Test.point());
- EXPECT_THAT(Results.Completions, UnorderedElementsAre(Labeled("BarExt")));
+ EXPECT_THAT(Results.Completions, UnorderedElementsAre(labeled("BarExt")));
}
}
@@ -3546,19 +3547,19 @@ TEST(CompletionTest, CommentParamName) {
)cpp";
EXPECT_THAT(completions(Code + "fun(/*^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("foo=")));
+ UnorderedElementsAre(labeled("foo=")));
EXPECT_THAT(completions(Code + "fun(1, /*^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("bar=")));
+ UnorderedElementsAre(labeled("bar=")));
EXPECT_THAT(completions(Code + "/*^", {}, Opts).Completions, IsEmpty());
// Test de-duplication.
EXPECT_THAT(
completions(Code + "overloaded(/*^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("param_int="), Labeled("param_char=")));
+ UnorderedElementsAre(labeled("param_int="), labeled("param_char=")));
// Comment already has some text in it.
EXPECT_THAT(completions(Code + "fun(/* ^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("foo=")));
+ UnorderedElementsAre(labeled("foo=")));
EXPECT_THAT(completions(Code + "fun(/* f^", {}, Opts).Completions,
- UnorderedElementsAre(Labeled("foo=")));
+ UnorderedElementsAre(labeled("foo=")));
EXPECT_THAT(completions(Code + "fun(/* x^", {}, Opts).Completions, IsEmpty());
EXPECT_THAT(completions(Code + "fun(/* f ^", {}, Opts).Completions,
IsEmpty());
@@ -3588,13 +3589,13 @@ TEST(SignatureHelp, TemplateArguments) {
auto First = signatures(Top + "bool x = foo<^");
EXPECT_THAT(
First.signatures,
- UnorderedElementsAre(Sig("foo<[[typename T]], [[int]]>() -> bool"),
- Sig("foo<[[int I]], [[int]]>() -> bool")));
+ UnorderedElementsAre(sig("foo<[[typename T]], [[int]]>() -> bool"),
+ sig("foo<[[int I]], [[int]]>() -> bool")));
EXPECT_EQ(First.activeParameter, 0);
auto Second = signatures(Top + "bool x = foo<1, ^");
EXPECT_THAT(Second.signatures,
- ElementsAre(Sig("foo<[[int I]], [[int]]>() -> bool")));
+ ElementsAre(sig("foo<[[int I]], [[int]]>() -> bool")));
EXPECT_EQ(Second.activeParameter, 1);
}
diff --git a/clang-tools-extra/clangd/unittests/CompileCommandsTests.cpp b/clang-tools-extra/clangd/unittests/CompileCommandsTests.cpp
index 3afcf59ac077..e8cbaa2bba32 100644
--- a/clang-tools-extra/clangd/unittests/CompileCommandsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/CompileCommandsTests.cpp
@@ -107,7 +107,7 @@ TEST(CommandMangler, ClangPath) {
// Only run the PATH/symlink resolving test on unix, we need to fiddle
// with permissions and environment variables...
#ifdef LLVM_ON_UNIX
-MATCHER(Ok, "") {
+MATCHER(ok, "") {
if (arg) {
*result_listener << arg.message();
return false;
@@ -124,20 +124,20 @@ TEST(CommandMangler, ClangPathResolve) {
// bar
llvm::SmallString<256> TempDir;
ASSERT_THAT(llvm::sys::fs::createUniqueDirectory("ClangPathResolve", TempDir),
- Ok());
+ ok());
// /var/tmp is a symlink on Mac. Resolve it so we're asserting the right path.
- ASSERT_THAT(llvm::sys::fs::real_path(TempDir.str(), TempDir), Ok());
+ ASSERT_THAT(llvm::sys::fs::real_path(TempDir.str(), TempDir), ok());
auto CleanDir = llvm::make_scope_exit(
[&] { llvm::sys::fs::remove_directories(TempDir); });
- ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/bin"), Ok());
- ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/lib"), Ok());
+ ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/bin"), ok());
+ ASSERT_THAT(llvm::sys::fs::create_directory(TempDir + "/lib"), ok());
int FD;
- ASSERT_THAT(llvm::sys::fs::openFileForWrite(TempDir + "/lib/bar", FD), Ok());
- ASSERT_THAT(llvm::sys::Process::SafelyCloseFileDescriptor(FD), Ok());
+ ASSERT_THAT(llvm::sys::fs::openFileForWrite(TempDir + "/lib/bar", FD), ok());
+ ASSERT_THAT(llvm::sys::Process::SafelyCloseFileDescriptor(FD), ok());
::chmod((TempDir + "/lib/bar").str().c_str(), 0755); // executable
ASSERT_THAT(
llvm::sys::fs::create_link(TempDir + "/lib/bar", TempDir + "/bin/foo"),
- Ok());
+ ok());
// Test the case where the driver is an absolute path to a symlink.
auto Mangler = CommandMangler::forTests();
diff --git a/clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp b/clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp
index 53406c09e92d..e2c32aad0110 100644
--- a/clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ConfigCompileTests.cpp
@@ -150,7 +150,7 @@ TEST_F(ConfigCompileTests, CompilationDatabase) {
Config::CDBSearchSpec::Ancestors)
<< "default value";
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage(
+ ElementsAre(diagMessage(
"CompilationDatabase must be an absolute path, because this "
"fragment is not associated with any directory.")));
@@ -184,7 +184,7 @@ TEST_F(ConfigCompileTests, Index) {
<< "by default";
EXPECT_THAT(
Diags.Diagnostics,
- ElementsAre(DiagMessage(
+ ElementsAre(diagMessage(
"Invalid Background value 'Foo'. Valid values are Build, Skip.")));
}
@@ -325,9 +325,9 @@ TEST_F(ConfigCompileTests, Tidy) {
EXPECT_THAT(
Diags.Diagnostics,
ElementsAre(
- DiagMessage(
+ diagMessage(
"clang-tidy check 'bugprone-use-after-move' was not found"),
- DiagMessage("clang-tidy check 'llvm-include-order' was not found")));
+ diagMessage("clang-tidy check 'llvm-include-order' was not found")));
#endif
}
@@ -342,11 +342,11 @@ TEST_F(ConfigCompileTests, TidyBadChecks) {
EXPECT_THAT(
Diags.Diagnostics,
ElementsAre(
- AllOf(DiagMessage("clang-tidy check 'unknown-check' was not found"),
- DiagKind(llvm::SourceMgr::DK_Warning)),
+ AllOf(diagMessage("clang-tidy check 'unknown-check' was not found"),
+ diagKind(llvm::SourceMgr::DK_Warning)),
AllOf(
- DiagMessage("clang-tidy check 'llvm-includeorder' was not found"),
- DiagKind(llvm::SourceMgr::DK_Warning))));
+ diagMessage("clang-tidy check 'llvm-includeorder' was not found"),
+ diagKind(llvm::SourceMgr::DK_Warning))));
}
TEST_F(ConfigCompileTests, ExternalServerNeedsTrusted) {
@@ -356,7 +356,7 @@ TEST_F(ConfigCompileTests, ExternalServerNeedsTrusted) {
compileAndApply();
EXPECT_THAT(
Diags.Diagnostics,
- ElementsAre(DiagMessage(
+ ElementsAre(diagMessage(
"Remote index may not be specified by untrusted configuration. "
"Copy this into user config to use it.")));
EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
@@ -373,8 +373,8 @@ TEST_F(ConfigCompileTests, ExternalBlockWarnOnMultipleSource) {
EXPECT_THAT(
Diags.Diagnostics,
Contains(
- AllOf(DiagMessage("Exactly one of File, Server or None must be set."),
- DiagKind(llvm::SourceMgr::DK_Error))));
+ AllOf(diagMessage("Exactly one of File, Server or None must be set."),
+ diagKind(llvm::SourceMgr::DK_Error))));
#else
ASSERT_TRUE(Conf.Index.External.hasValue());
EXPECT_EQ(Conf.Index.External->Kind, Config::ExternalIndexSpec::File);
@@ -398,8 +398,8 @@ TEST_F(ConfigCompileTests, ExternalBlockErrOnNoSource) {
EXPECT_THAT(
Diags.Diagnostics,
Contains(
- AllOf(DiagMessage("Exactly one of File, Server or None must be set."),
- DiagKind(llvm::SourceMgr::DK_Error))));
+ AllOf(diagMessage("Exactly one of File, Server or None must be set."),
+ diagKind(llvm::SourceMgr::DK_Error))));
}
TEST_F(ConfigCompileTests, ExternalBlockDisablesBackgroundIndex) {
@@ -437,9 +437,9 @@ TEST_F(ConfigCompileTests, ExternalBlockMountPoint) {
ASSERT_THAT(
Diags.Diagnostics,
ElementsAre(
- AllOf(DiagMessage("MountPoint must be an absolute path, because this "
+ AllOf(diagMessage("MountPoint must be an absolute path, because this "
"fragment is not associated with any directory."),
- DiagKind(llvm::SourceMgr::DK_Error))));
+ diagKind(llvm::SourceMgr::DK_Error))));
EXPECT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::None);
auto FooPath = testPath("foo/", llvm::sys::path::Style::posix);
diff --git a/clang-tools-extra/clangd/unittests/ConfigProviderTests.cpp b/clang-tools-extra/clangd/unittests/ConfigProviderTests.cpp
index 899896dd2fb4..22f69143dadf 100644
--- a/clang-tools-extra/clangd/unittests/ConfigProviderTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ConfigProviderTests.cpp
@@ -63,13 +63,13 @@ TEST(ProviderTest, Combine) {
auto Combined = Provider::combine({&Foo, &Bar});
Config Cfg = Combined->getConfig(Params(), Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("foo"), DiagMessage("bar")));
+ ElementsAre(diagMessage("foo"), diagMessage("bar")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo1", "bar1"));
Diags.Diagnostics.clear();
Cfg = Combined->getConfig(Params(), Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("foo"), DiagMessage("bar")));
+ ElementsAre(diagMessage("foo"), diagMessage("bar")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo2", "bar2"));
}
@@ -101,7 +101,7 @@ TEST(ProviderTest, FromYAMLFile) {
auto P = Provider::fromYAMLFile(testPath("foo.yaml"), /*Directory=*/"", FS);
auto Cfg = P->getConfig(Params(), Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("Unknown CompileFlags key 'Unknown'")));
+ ElementsAre(diagMessage("Unknown CompileFlags key 'Unknown'")));
EXPECT_THAT(Diags.Files, ElementsAre(testPath("foo.yaml")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
Diags.clear();
@@ -115,7 +115,7 @@ TEST(ProviderTest, FromYAMLFile) {
Cfg = P->getConfig(Params(), Diags.callback());
EXPECT_THAT(
Diags.Diagnostics,
- ElementsAre(DiagMessage(
+ ElementsAre(diagMessage(
"Unknown CompileFlags key 'Removr'; did you mean 'Remove'?")));
EXPECT_THAT(Diags.Files, ElementsAre(testPath("foo.yaml")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
@@ -159,7 +159,7 @@ TEST(ProviderTest, FromAncestorRelativeYAMLFiles) {
Cfg = P->getConfig(ABCParams, Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("Unknown CompileFlags key 'Unknown'")));
+ ElementsAre(diagMessage("Unknown CompileFlags key 'Unknown'")));
// FIXME: fails on windows: paths have mixed slashes like C:\a/b\c.yaml
EXPECT_THAT(Diags.Files,
ElementsAre(testPath("a/foo.yaml"), testPath("a/b/c/foo.yaml")));
@@ -194,7 +194,7 @@ TEST(ProviderTest, Staleness) {
FS.Files["foo.yaml"] = AddFooWithErr;
auto Cfg = P->getConfig(StaleOK, Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("Unknown CompileFlags key 'Unknown'")));
+ ElementsAre(diagMessage("Unknown CompileFlags key 'Unknown'")));
EXPECT_THAT(getAddedArgs(Cfg), ElementsAre("foo"));
Diags.clear();
diff --git a/clang-tools-extra/clangd/unittests/ConfigTesting.h b/clang-tools-extra/clangd/unittests/ConfigTesting.h
index 46c51e80b6bc..f31a9c0591a4 100644
--- a/clang-tools-extra/clangd/unittests/ConfigTesting.h
+++ b/clang-tools-extra/clangd/unittests/ConfigTesting.h
@@ -65,10 +65,10 @@ struct CapturedDiags {
}
};
-MATCHER_P(DiagMessage, M, "") { return arg.Message == M; }
-MATCHER_P(DiagKind, K, "") { return arg.Kind == K; }
-MATCHER_P(DiagPos, P, "") { return arg.Pos == P; }
-MATCHER_P(DiagRange, R, "") { return arg.Rng == R; }
+MATCHER_P(diagMessage, M, "") { return arg.Message == M; }
+MATCHER_P(diagKind, K, "") { return arg.Kind == K; }
+MATCHER_P(diagPos, P, "") { return arg.Pos == P; }
+MATCHER_P(diagRange, R, "") { return arg.Rng == R; }
inline Position toPosition(llvm::SMLoc L, const llvm::SourceMgr &SM) {
auto LineCol = SM.getLineAndColumn(L);
diff --git a/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp b/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp
index 3722ee297665..edb458f2a0ed 100644
--- a/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp
@@ -22,6 +22,9 @@
namespace clang {
namespace clangd {
namespace config {
+
+// PrintTo is a magic identifier of GTest
+// NOLINTNEXTLINE (readability-identifier-naming)
template <typename T> void PrintTo(const Located<T> &V, std::ostream *OS) {
*OS << ::testing::PrintToString(*V);
}
@@ -31,7 +34,7 @@ using ::testing::AllOf;
using ::testing::ElementsAre;
using ::testing::IsEmpty;
-MATCHER_P(Val, Value, "") {
+MATCHER_P(val, Value, "") {
if (*arg == Value)
return true;
*result_listener << "value is " << *arg;
@@ -74,10 +77,10 @@ CompileFlags: { Add: [foo, bar] }
EXPECT_THAT(Diags.Files, ElementsAre("config.yaml"));
ASSERT_EQ(Results.size(), 4u);
EXPECT_FALSE(Results[0].If.HasUnrecognizedCondition);
- EXPECT_THAT(Results[0].If.PathMatch, ElementsAre(Val("abc")));
- EXPECT_THAT(Results[0].CompileFlags.Add, ElementsAre(Val("foo"), Val("bar")));
+ EXPECT_THAT(Results[0].If.PathMatch, ElementsAre(val("abc")));
+ EXPECT_THAT(Results[0].CompileFlags.Add, ElementsAre(val("foo"), val("bar")));
- EXPECT_THAT(Results[1].CompileFlags.Add, ElementsAre(Val("b\naz\n")));
+ EXPECT_THAT(Results[1].CompileFlags.Add, ElementsAre(val("b\naz\n")));
ASSERT_TRUE(Results[2].Index.Background);
EXPECT_EQ("Skip", *Results[2].Index.Background.getValue());
@@ -119,18 +122,18 @@ CompileFlags: {$unexpected^
ASSERT_THAT(
Diags.Diagnostics,
- ElementsAre(AllOf(DiagMessage("Unknown If key 'UnknownCondition'"),
- DiagKind(llvm::SourceMgr::DK_Warning),
- DiagPos(YAML.range("unknown").start),
- DiagRange(YAML.range("unknown"))),
- AllOf(DiagMessage("Unexpected token. Expected Key, Flow "
+ ElementsAre(AllOf(diagMessage("Unknown If key 'UnknownCondition'"),
+ diagKind(llvm::SourceMgr::DK_Warning),
+ diagPos(YAML.range("unknown").start),
+ diagRange(YAML.range("unknown"))),
+ AllOf(diagMessage("Unexpected token. Expected Key, Flow "
"Entry, or Flow Mapping End."),
- DiagKind(llvm::SourceMgr::DK_Error),
- DiagPos(YAML.point("unexpected")),
- DiagRange(llvm::None))));
+ diagKind(llvm::SourceMgr::DK_Error),
+ diagPos(YAML.point("unexpected")),
+ diagRange(llvm::None))));
ASSERT_EQ(Results.size(), 1u); // invalid fragment discarded.
- EXPECT_THAT(Results.front().CompileFlags.Add, ElementsAre(Val("first")));
+ EXPECT_THAT(Results.front().CompileFlags.Add, ElementsAre(val("first")));
EXPECT_TRUE(Results.front().If.HasUnrecognizedCondition);
}
@@ -145,8 +148,8 @@ horrible
)yaml";
auto Results = Fragment::parseYAML(YAML, "config.yaml", Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(DiagMessage("If should be a dictionary"),
- DiagMessage("Config should be a dictionary")));
+ ElementsAre(diagMessage("If should be a dictionary"),
+ diagMessage("Config should be a dictionary")));
ASSERT_THAT(Results, IsEmpty());
}
@@ -180,10 +183,10 @@ TEST(ParseYAML, ExternalBlock) {
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
ASSERT_EQ(Results.size(), 1u);
ASSERT_TRUE(Results[0].Index.External);
- EXPECT_THAT(*Results[0].Index.External.getValue()->File, Val("foo"));
- EXPECT_THAT(*Results[0].Index.External.getValue()->MountPoint, Val("baz"));
+ EXPECT_THAT(*Results[0].Index.External.getValue()->File, val("foo"));
+ EXPECT_THAT(*Results[0].Index.External.getValue()->MountPoint, val("baz"));
ASSERT_THAT(Diags.Diagnostics, IsEmpty());
- EXPECT_THAT(*Results[0].Index.External.getValue()->Server, Val("bar"));
+ EXPECT_THAT(*Results[0].Index.External.getValue()->Server, val("bar"));
}
TEST(ParseYAML, AllScopes) {
@@ -196,7 +199,7 @@ TEST(ParseYAML, AllScopes) {
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
ASSERT_THAT(Diags.Diagnostics, IsEmpty());
ASSERT_EQ(Results.size(), 1u);
- EXPECT_THAT(Results[0].Completion.AllScopes, llvm::ValueIs(Val(true)));
+ EXPECT_THAT(Results[0].Completion.AllScopes, llvm::ValueIs(val(true)));
}
TEST(ParseYAML, AllScopesWarn) {
@@ -208,10 +211,10 @@ TEST(ParseYAML, AllScopesWarn) {
auto Results =
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
EXPECT_THAT(Diags.Diagnostics,
- ElementsAre(AllOf(DiagMessage("AllScopes should be a boolean"),
- DiagKind(llvm::SourceMgr::DK_Warning),
- DiagPos(YAML.range("diagrange").start),
- DiagRange(YAML.range("diagrange")))));
+ ElementsAre(AllOf(diagMessage("AllScopes should be a boolean"),
+ diagKind(llvm::SourceMgr::DK_Warning),
+ diagPos(YAML.range("diagrange").start),
+ diagRange(YAML.range("diagrange")))));
ASSERT_EQ(Results.size(), 1u);
EXPECT_THAT(Results[0].Completion.AllScopes, testing::Eq(llvm::None));
}
@@ -226,7 +229,7 @@ TEST(ParseYAML, ShowAKA) {
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
ASSERT_THAT(Diags.Diagnostics, IsEmpty());
ASSERT_EQ(Results.size(), 1u);
- EXPECT_THAT(Results[0].Hover.ShowAKA, llvm::ValueIs(Val(true)));
+ EXPECT_THAT(Results[0].Hover.ShowAKA, llvm::ValueIs(val(true)));
}
TEST(ParseYAML, InlayHints) {
@@ -240,8 +243,8 @@ TEST(ParseYAML, InlayHints) {
Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback());
ASSERT_THAT(Diags.Diagnostics, IsEmpty());
ASSERT_EQ(Results.size(), 1u);
- EXPECT_THAT(Results[0].InlayHints.Enabled, llvm::ValueIs(Val(false)));
- EXPECT_THAT(Results[0].InlayHints.ParameterNames, llvm::ValueIs(Val(true)));
+ EXPECT_THAT(Results[0].InlayHints.Enabled, llvm::ValueIs(val(false)));
+ EXPECT_THAT(Results[0].InlayHints.ParameterNames, llvm::ValueIs(val(true)));
EXPECT_EQ(Results[0].InlayHints.DeducedTypes, llvm::None);
}
diff --git a/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp b/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
index 76dd20177c47..b06093514599 100644
--- a/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/DiagnosticsTests.cpp
@@ -44,32 +44,32 @@ using ::testing::SizeIs;
using ::testing::UnorderedElementsAre;
using testing::UnorderedElementsAreArray;
-::testing::Matcher<const Diag &> WithFix(::testing::Matcher<Fix> FixMatcher) {
+::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher) {
return Field(&Diag::Fixes, ElementsAre(FixMatcher));
}
-::testing::Matcher<const Diag &> WithFix(::testing::Matcher<Fix> FixMatcher1,
+::testing::Matcher<const Diag &> withFix(::testing::Matcher<Fix> FixMatcher1,
::testing::Matcher<Fix> FixMatcher2) {
return Field(&Diag::Fixes, UnorderedElementsAre(FixMatcher1, FixMatcher2));
}
::testing::Matcher<const Diag &>
-WithNote(::testing::Matcher<Note> NoteMatcher) {
+withNote(::testing::Matcher<Note> NoteMatcher) {
return Field(&Diag::Notes, ElementsAre(NoteMatcher));
}
::testing::Matcher<const Diag &>
-WithNote(::testing::Matcher<Note> NoteMatcher1,
+withNote(::testing::Matcher<Note> NoteMatcher1,
::testing::Matcher<Note> NoteMatcher2) {
return Field(&Diag::Notes, UnorderedElementsAre(NoteMatcher1, NoteMatcher2));
}
::testing::Matcher<const Diag &>
-WithTag(::testing::Matcher<DiagnosticTag> TagMatcher) {
+withTag(::testing::Matcher<DiagnosticTag> TagMatcher) {
return Field(&Diag::Tags, Contains(TagMatcher));
}
-MATCHER_P(HasRange, Range, "") { return arg.Range == Range; }
+MATCHER_P(hasRange, Range, "") { return arg.Range == Range; }
MATCHER_P2(Diag, Range, Message,
"Diag at " + llvm::to_string(Range) + " = [" + Message + "]") {
@@ -83,9 +83,9 @@ MATCHER_P3(Fix, Range, Replacement, Message,
arg.Edits[0].range == Range && arg.Edits[0].newText == Replacement;
}
-MATCHER_P(FixMessage, Message, "") { return arg.Message == Message; }
+MATCHER_P(fixMessage, Message, "") { return arg.Message == Message; }
-MATCHER_P(EqualToLSPDiag, LSPDiag,
+MATCHER_P(equalToLSPDiag, LSPDiag,
"LSP diagnostic " + llvm::to_string(LSPDiag)) {
if (toJSON(arg) != toJSON(LSPDiag)) {
*result_listener << llvm::formatv("expected:\n{0:2}\ngot\n{1:2}",
@@ -96,11 +96,11 @@ MATCHER_P(EqualToLSPDiag, LSPDiag,
return true;
}
-MATCHER_P(DiagSource, S, "") { return arg.Source == S; }
-MATCHER_P(DiagName, N, "") { return arg.Name == N; }
-MATCHER_P(DiagSeverity, S, "") { return arg.Severity == S; }
+MATCHER_P(diagSource, S, "") { return arg.Source == S; }
+MATCHER_P(diagName, N, "") { return arg.Name == N; }
+MATCHER_P(diagSeverity, S, "") { return arg.Severity == S; }
-MATCHER_P(EqualToFix, Fix, "LSP fix " + llvm::to_string(Fix)) {
+MATCHER_P(equalToFix, Fix, "LSP fix " + llvm::to_string(Fix)) {
if (arg.Message != Fix.Message)
return false;
if (arg.Edits.size() != Fix.Edits.size())
@@ -114,10 +114,10 @@ MATCHER_P(EqualToFix, Fix, "LSP fix " + llvm::to_string(Fix)) {
}
// 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;
}
@@ -164,20 +164,20 @@ o]]();
AllOf(Diag(Test.range("range"),
"invalid range expression of type 'struct Container *'; "
"did you mean to dereference it with '*'?"),
- WithFix(Fix(Test.range("insertstar"), "*", "insert '*'"))),
+ withFix(Fix(Test.range("insertstar"), "*", "insert '*'"))),
// This range spans lines.
AllOf(Diag(Test.range("typo"),
"use of undeclared identifier 'goo'; did you mean 'foo'?"),
- DiagSource(Diag::Clang), DiagName("undeclared_var_use_suggest"),
- WithFix(
+ diagSource(Diag::Clang), diagName("undeclared_var_use_suggest"),
+ withFix(
Fix(Test.range("typo"), "foo", "change 'go\\…' to 'foo'")),
// This is a pretty normal range.
- WithNote(Diag(Test.range("decl"), "'foo' declared here"))),
+ withNote(Diag(Test.range("decl"), "'foo' declared here"))),
// This range is zero-width and insertion. Therefore make sure we are
// not expanding it into other tokens. Since we are not going to
// replace those.
AllOf(Diag(Test.range("semicolon"), "expected ';' after expression"),
- WithFix(Fix(Test.range("semicolon"), ";", "insert ';'"))),
+ withFix(Fix(Test.range("semicolon"), ";", "insert ';'"))),
// This range isn't provided by clang, we expand to the token.
Diag(Test.range("unk"), "use of undeclared identifier 'unknown'"),
Diag(Test.range("type"),
@@ -188,7 +188,7 @@ o]]();
"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'")))));
}
@@ -217,7 +217,7 @@ TEST(DiagnosticsTest, FlagsMatter) {
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
diff erent diagnostics.
TU.Filename = "Plain.c";
@@ -225,7 +225,7 @@ TEST(DiagnosticsTest, FlagsMatter) {
*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) {
@@ -237,7 +237,7 @@ TEST(DiagnosticsTest, DiagnosticPreamble) {
EXPECT_THAT(*TU.build().getDiagnostics(),
ElementsAre(::testing::AllOf(
Diag(Test.range(), "'not-found.h' file not found"),
- DiagSource(Diag::Clang), DiagName("pp_file_not_found"))));
+ diagSource(Diag::Clang), diagName("pp_file_not_found"))));
}
TEST(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
@@ -255,7 +255,7 @@ TEST(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Test.range(),
"floating point literal has suffix 'f', which is not uppercase"),
- DiagSource(Diag::ClangTidy)))));
+ diagSource(Diag::ClangTidy)))));
Test = Annotations(R"cpp(
template<typename T>
@@ -275,7 +275,7 @@ TEST(DiagnosticsTest, DeduplicatedClangTidyDiagnostics) {
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Test.range(),
"floating point literal has suffix 'f', which is not uppercase"),
- DiagSource(Diag::ClangTidy)))));
+ diagSource(Diag::ClangTidy)))));
}
TEST(DiagnosticsTest, ClangTidy) {
@@ -312,9 +312,9 @@ TEST(DiagnosticsTest, ClangTidy) {
AllOf(Diag(Test.range("deprecated"),
"inclusion of deprecated C++ header 'assert.h'; consider "
"using 'cassert' instead"),
- DiagSource(Diag::ClangTidy),
- DiagName("modernize-deprecated-headers"),
- WithFix(Fix(Test.range("deprecated"), "<cassert>",
+ diagSource(Diag::ClangTidy),
+ diagName("modernize-deprecated-headers"),
+ withFix(Fix(Test.range("deprecated"), "<cassert>",
"change '\"assert.h\"' to '<cassert>'"))),
Diag(Test.range("doubled"),
"suspicious usage of 'sizeof(sizeof(...))'"),
@@ -322,16 +322,16 @@ TEST(DiagnosticsTest, ClangTidy) {
"side effects in the 1st macro argument 'X' are "
"repeated in "
"macro expansion"),
- DiagSource(Diag::ClangTidy),
- DiagName("bugprone-macro-repeated-side-effects"),
- WithNote(Diag(Test.range("macrodef"),
+ diagSource(Diag::ClangTidy),
+ diagName("bugprone-macro-repeated-side-effects"),
+ withNote(Diag(Test.range("macrodef"),
"macro 'SQUARE' defined here"))),
AllOf(Diag(Test.range("main"),
"use a trailing return type for this function"),
- DiagSource(Diag::ClangTidy),
- DiagName("modernize-use-trailing-return-type"),
+ diagSource(Diag::ClangTidy),
+ diagName("modernize-use-trailing-return-type"),
// Verify there's no "[check-name]" suffix in the message.
- WithFix(FixMessage(
+ withFix(fixMessage(
"use a trailing return type for this function"))),
Diag(Test.range("foo"),
"function 'foo' is within a recursive call chain"),
@@ -353,7 +353,7 @@ TEST(DiagnosticsTest, ClangTidyEOF) {
*TU.build().getDiagnostics(),
ifTidyChecks(Contains(
AllOf(Diag(Test.range(), "#includes are not sorted properly"),
- DiagSource(Diag::ClangTidy), DiagName("llvm-include-order")))));
+ diagSource(Diag::ClangTidy), diagName("llvm-include-order")))));
}
TEST(DiagnosticTest, TemplatesInHeaders) {
@@ -371,7 +371,7 @@ TEST(DiagnosticTest, TemplatesInHeaders) {
*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")))));
}
@@ -425,7 +425,7 @@ TEST(DiagnosticTest, NoMultipleDiagnosticInFlight) {
*TU.build().getDiagnostics(),
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Main.range(), "use range-based for loop instead"),
- DiagSource(Diag::ClangTidy), DiagName("modernize-loop-convert")))));
+ diagSource(Diag::ClangTidy), diagName("modernize-loop-convert")))));
}
TEST(DiagnosticTest, RespectsDiagnosticConfig) {
@@ -494,8 +494,8 @@ TEST(DiagnosticTest, ClangTidySuppressionComment) {
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Main.range(), "result of integer division used in a floating "
"point context; possible loss of precision"),
- DiagSource(Diag::ClangTidy),
- DiagName("bugprone-integer-division")))));
+ diagSource(Diag::ClangTidy),
+ diagName("bugprone-integer-division")))));
}
TEST(DiagnosticTest, ClangTidyWarningAsError) {
@@ -513,8 +513,8 @@ TEST(DiagnosticTest, ClangTidyWarningAsError) {
ifTidyChecks(UnorderedElementsAre(::testing::AllOf(
Diag(Main.range(), "result of integer division used in a floating "
"point context; possible loss of precision"),
- DiagSource(Diag::ClangTidy), DiagName("bugprone-integer-division"),
- DiagSeverity(DiagnosticsEngine::Error)))));
+ diagSource(Diag::ClangTidy), diagName("bugprone-integer-division"),
+ diagSeverity(DiagnosticsEngine::Error)))));
}
TidyProvider addClangArgs(std::vector<llvm::StringRef> ExtraArgs) {
@@ -535,8 +535,8 @@ TEST(DiagnosticTest, ClangTidyEnablesClangWarning) {
// This is always emitted as a clang warning, not a clang-tidy diagnostic.
auto UnusedFooWarning =
AllOf(Diag(Main.range(), "unused function 'foo'"),
- DiagName("-Wunused-function"), DiagSource(Diag::Clang),
- DiagSeverity(DiagnosticsEngine::Warning));
+ diagName("-Wunused-function"), diagSource(Diag::Clang),
+ diagSeverity(DiagnosticsEngine::Warning));
// Check the -Wunused warning isn't initially on.
EXPECT_THAT(*TU.build().getDiagnostics(), IsEmpty());
@@ -554,19 +554,19 @@ TEST(DiagnosticTest, ClangTidyEnablesClangWarning) {
TU.ExtraArgs = {"-Werror"};
TU.ClangTidyProvider = addClangArgs({"-Wunused"});
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagSeverity(DiagnosticsEngine::Warning)));
+ ElementsAre(diagSeverity(DiagnosticsEngine::Warning)));
// But clang-tidy extra args won't *downgrade* errors to warnings either.
TU.ExtraArgs = {"-Wunused", "-Werror"};
TU.ClangTidyProvider = addClangArgs({"-Wunused"});
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagSeverity(DiagnosticsEngine::Error)));
+ ElementsAre(diagSeverity(DiagnosticsEngine::Error)));
// FIXME: we're erroneously downgrading the whole group, this should be Error.
TU.ExtraArgs = {"-Wunused-function", "-Werror"};
TU.ClangTidyProvider = addClangArgs({"-Wunused"});
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagSeverity(DiagnosticsEngine::Warning)));
+ ElementsAre(diagSeverity(DiagnosticsEngine::Warning)));
// This looks silly, but it's the typical result if a warning is enabled by a
// high-level .clang-tidy file and disabled by a low-level one.
@@ -603,7 +603,7 @@ TEST(DiagnosticTest, LongFixMessages) {
TestTU TU = TestTU::withCode(Source.code());
EXPECT_THAT(
*TU.build().getDiagnostics(),
- ElementsAre(WithFix(Fix(
+ ElementsAre(withFix(Fix(
Source.range(),
"somereallyreallyreallyreallyreallyreallyreallyreallylongidentifier",
"change 'omereallyreallyreallyreallyreallyreallyreallyreall…' to "
@@ -619,7 +619,7 @@ n]] = 10; // error-ok
)cpp");
TU.Code = std::string(Source.code());
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(WithFix(
+ ElementsAre(withFix(
Fix(Source.range(), "ident", "change 'ide\\…' to 'ident'"))));
}
@@ -629,7 +629,7 @@ TEST(DiagnosticTest, NewLineFixMessage) {
TU.ExtraArgs = {"-Wnewline-eof"};
EXPECT_THAT(
*TU.build().getDiagnostics(),
- ElementsAre(WithFix((Fix(Source.range(), "\n", "insert '\\n'")))));
+ ElementsAre(withFix((Fix(Source.range(), "\n", "insert '\\n'")))));
}
TEST(DiagnosticTest, ClangTidySuppressionCommentTrumpsWarningAsError) {
@@ -714,7 +714,7 @@ TEST(DiagnosticsTest, RecursivePreamble) {
)cpp");
TU.Filename = "foo.h";
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagName("pp_including_mainfile_in_preamble")));
+ ElementsAre(diagName("pp_including_mainfile_in_preamble")));
EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
}
@@ -743,7 +743,7 @@ TEST(DiagnosticsTest, RecursivePreambleIfndefGuard) {
TU.Filename = "foo.h";
// FIXME: should be no errors here.
EXPECT_THAT(*TU.build().getDiagnostics(),
- ElementsAre(DiagName("pp_including_mainfile_in_preamble")));
+ ElementsAre(diagName("pp_including_mainfile_in_preamble")));
EXPECT_THAT(TU.build().getLocalTopLevelDecls(), SizeIs(1));
}
@@ -777,7 +777,7 @@ TEST(DiagnosticsTest, NoFixItInMacro) {
auto TU = TestTU::withCode(Test.code());
EXPECT_THAT(*TU.build().getDiagnostics(),
ElementsAre(AllOf(Diag(Test.range(), "'main' must return 'int'"),
- Not(WithFix(_)))));
+ Not(withFix(_)))));
}
TEST(DiagnosticsTest, PragmaSystemHeader) {
@@ -875,8 +875,8 @@ main.cpp:2:3: error: something terrible happened)";
EXPECT_THAT(
LSPDiags,
- ElementsAre(Pair(EqualToLSPDiag(MainLSP), ElementsAre(EqualToFix(F))),
- Pair(EqualToLSPDiag(NoteInMainLSP), IsEmpty())));
+ ElementsAre(Pair(equalToLSPDiag(MainLSP), ElementsAre(equalToFix(F))),
+ Pair(equalToLSPDiag(NoteInMainLSP), IsEmpty())));
EXPECT_EQ(LSPDiags[0].first.code, "undeclared_var_use");
EXPECT_EQ(LSPDiags[0].first.source, "clang");
EXPECT_EQ(LSPDiags[1].first.code, "");
@@ -902,8 +902,8 @@ main.cpp:2:3: error: something terrible happened)";
NoteInHeaderDRI.location.range = NoteInHeader.Range;
NoteInHeaderDRI.location.uri = HeaderFile;
MainLSP.relatedInformation = {NoteInMainDRI, NoteInHeaderDRI};
- EXPECT_THAT(LSPDiags, ElementsAre(Pair(EqualToLSPDiag(MainLSP),
- ElementsAre(EqualToFix(F)))));
+ EXPECT_THAT(LSPDiags, ElementsAre(Pair(equalToLSPDiag(MainLSP),
+ ElementsAre(equalToFix(F)))));
}
struct SymbolWithHeader {
@@ -967,8 +967,8 @@ TEST(IncludeFixerTest, IncompleteType) {
TU.Code = Main.code().str() + "\n // error-ok";
EXPECT_THAT(
*TU.build().getDiagnostics(),
- ElementsAre(AllOf(DiagName(Case.first), HasRange(Main.range()),
- WithFix(Fix(Range{}, "#include \"x.h\"\n",
+ ElementsAre(AllOf(diagName(Case.first), hasRange(Main.range()),
+ withFix(Fix(Range{}, "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::X")))))
<< Case.second;
}
@@ -998,8 +998,8 @@ TEST(IncludeFixerTest, IncompleteEnum) {
Annotations Main(Case.second);
TU.Code = Main.code().str() + "\n // error-ok";
EXPECT_THAT(*TU.build().getDiagnostics(),
- Contains(AllOf(DiagName(Case.first), HasRange(Main.range()),
- WithFix(Fix(Range{}, "#include \"x.h\"\n",
+ Contains(AllOf(diagName(Case.first), hasRange(Main.range()),
+ withFix(Fix(Range{}, "#include \"x.h\"\n",
"Include \"x.h\" for symbol X")))))
<< Case.second;
}
@@ -1065,29 +1065,29 @@ using Type = ns::$template[[Foo]]<int>;
*TU.build().getDiagnostics(),
UnorderedElementsAre(
AllOf(Diag(Test.range("unqualified1"), "unknown type name 'X'"),
- DiagName("unknown_typename"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("unknown_typename"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::X"))),
Diag(Test.range("unqualified2"), "use of undeclared identifier 'X'"),
AllOf(Diag(Test.range("qualified1"),
"no type named 'X' in namespace 'ns'"),
- DiagName("typename_nested_not_found"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("typename_nested_not_found"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::X"))),
AllOf(Diag(Test.range("qualified2"),
"no member named 'X' in namespace 'ns'"),
- DiagName("no_member"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("no_member"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::X"))),
AllOf(Diag(Test.range("global"),
"no type named 'Global' in the global namespace"),
- DiagName("typename_nested_not_found"),
- WithFix(Fix(Test.range("insert"), "#include \"global.h\"\n",
+ diagName("typename_nested_not_found"),
+ withFix(Fix(Test.range("insert"), "#include \"global.h\"\n",
"Include \"global.h\" for symbol Global"))),
AllOf(Diag(Test.range("template"),
"no template named 'Foo' in namespace 'ns'"),
- DiagName("no_member_template"),
- WithFix(Fix(Test.range("insert"), "#include \"foo.h\"\n",
+ diagName("no_member_template"),
+ withFix(Fix(Test.range("insert"), "#include \"foo.h\"\n",
"Include \"foo.h\" for symbol ns::Foo")))));
}
@@ -1110,8 +1110,8 @@ void foo() {
EXPECT_THAT(*TU.build().getDiagnostics(),
UnorderedElementsAre(AllOf(
Diag(Test.range("unqualified"), "unknown type name 'X'"),
- DiagName("unknown_typename"),
- WithFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
+ diagName("unknown_typename"),
+ withFix(Fix(Test.range("insert"), "#include \"a.h\"\n",
"Include \"a.h\" for symbol na::X"),
Fix(Test.range("insert"), "#include \"b.h\"\n",
"Include \"b.h\" for symbol na::nb::X")))));
@@ -1190,8 +1190,8 @@ void g() { ns::$[[scope]]::X_Y(); }
*TU.build().getDiagnostics(),
UnorderedElementsAre(
AllOf(Diag(Test.range(), "no member named 'scope' in namespace 'ns'"),
- DiagName("no_member"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("no_member"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol ns::scope::X_Y")))));
}
@@ -1219,25 +1219,25 @@ void f() {
UnorderedElementsAre(
AllOf(Diag(Test.range("q1"), "use of undeclared identifier 'clangd'; "
"did you mean 'clang'?"),
- DiagName("undeclared_var_use_suggest"),
- WithFix(_, // change clangd to clang
+ diagName("undeclared_var_use_suggest"),
+ withFix(_, // change clangd to clang
Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol clang::clangd::X"))),
AllOf(Diag(Test.range("x"), "no type named 'X' in namespace 'clang'"),
- DiagName("typename_nested_not_found"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("typename_nested_not_found"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol clang::clangd::X"))),
AllOf(
Diag(Test.range("q2"), "use of undeclared identifier 'clangd'; "
"did you mean 'clang'?"),
- DiagName("undeclared_var_use_suggest"),
- WithFix(_, // change clangd to clang
+ diagName("undeclared_var_use_suggest"),
+ withFix(_, // change clangd to clang
Fix(Test.range("insert"), "#include \"y.h\"\n",
"Include \"y.h\" for symbol clang::clangd::ns::Y"))),
AllOf(Diag(Test.range("ns"),
"no member named 'ns' in namespace 'clang'"),
- DiagName("no_member"),
- WithFix(
+ diagName("no_member"),
+ withFix(
Fix(Test.range("insert"), "#include \"y.h\"\n",
"Include \"y.h\" for symbol clang::clangd::ns::Y")))));
}
@@ -1258,8 +1258,8 @@ namespace c {
EXPECT_THAT(*TU.build().getDiagnostics(),
UnorderedElementsAre(AllOf(
Diag(Test.range(), "no type named 'X' in namespace 'a'"),
- DiagName("typename_nested_not_found"),
- WithFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
+ diagName("typename_nested_not_found"),
+ withFix(Fix(Test.range("insert"), "#include \"x.h\"\n",
"Include \"x.h\" for symbol a::X")))));
}
@@ -1301,7 +1301,7 @@ TEST(IncludeFixerTest, HeaderNamedInDiag) {
ElementsAre(AllOf(
Diag(Test.range(), "implicitly declaring library function 'printf' "
"with type 'int (const char *, ...)'"),
- WithFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
+ withFix(Fix(Test.range("insert"), "#include <stdio.h>\n",
"Include <stdio.h> for symbol printf")))));
}
@@ -1326,7 +1326,7 @@ TEST(IncludeFixerTest, CImplicitFunctionDecl) {
ElementsAre(AllOf(
Diag(Test.range(),
"implicit declaration of function 'foo' is invalid in C99"),
- WithFix(Fix(Range{}, "#include \"foo.h\"\n",
+ withFix(Fix(Range{}, "#include \"foo.h\"\n",
"Include \"foo.h\" for symbol foo")))));
}
@@ -1341,7 +1341,7 @@ TEST(DiagsInHeaders, DiagInsideHeader) {
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) {
@@ -1448,7 +1448,7 @@ TEST(DiagsInHeaders, OnlyErrorOrFatal) {
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) {
@@ -1479,7 +1479,7 @@ TEST(DiagsInHeaders, FromNonWrittenSources) {
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) {
@@ -1606,9 +1606,9 @@ TEST(Diagnostics, Tags) {
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) {
@@ -1644,8 +1644,8 @@ TEST(DiagnosticsTest, IncludeCleaner) {
*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/DumpASTTests.cpp b/clang-tools-extra/clangd/unittests/DumpASTTests.cpp
index 2df310a95258..2f8758da28d3 100644
--- a/clang-tools-extra/clangd/unittests/DumpASTTests.cpp
+++ b/clang-tools-extra/clangd/unittests/DumpASTTests.cpp
@@ -20,7 +20,7 @@ using testing::Contains;
using testing::Not;
using testing::SizeIs;
-MATCHER_P(WithDetail, str, "") { return arg.detail == str; }
+MATCHER_P(withDetail, str, "") { return arg.detail == str; }
TEST(DumpASTTests, BasicInfo) {
std::pair</*Code=*/std::string, /*Expected=*/std::string> Cases[] = {
@@ -168,8 +168,8 @@ TEST(DumpASTTests, NoRange) {
auto Node = dumpAST(
DynTypedNode::create(*AST.getASTContext().getTranslationUnitDecl()),
AST.getTokens(), AST.getASTContext());
- ASSERT_THAT(Node.children, Contains(WithDetail("varFromSource")));
- ASSERT_THAT(Node.children, Not(Contains(WithDetail("funcFromHeader"))));
+ ASSERT_THAT(Node.children, Contains(withDetail("varFromSource")));
+ ASSERT_THAT(Node.children, Not(Contains(withDetail("funcFromHeader"))));
EXPECT_THAT(Node.arcana, testing::StartsWith("TranslationUnitDecl "));
ASSERT_FALSE(Node.range.hasValue())
<< "Expected no range for translation unit";
diff --git a/clang-tools-extra/clangd/unittests/ExpectedTypeTest.cpp b/clang-tools-extra/clangd/unittests/ExpectedTypeTest.cpp
index 7d62e83a9689..88c37005eaec 100644
--- a/clang-tools-extra/clangd/unittests/ExpectedTypeTest.cpp
+++ b/clang-tools-extra/clangd/unittests/ExpectedTypeTest.cpp
@@ -41,7 +41,7 @@ class ExpectedTypeConversionTest : public ::testing::Test {
/// 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 @@ class ExpectedTypeConversionTest : public ::testing::Test {
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 @@ class ExpectedTypeConversionTest : public ::testing::Test {
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 @@ TEST_F(ExpectedTypeConversionTest, BasicTypes) {
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 @@ TEST_F(ExpectedTypeConversionTest, FunctionReturns) {
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 @@ T* var_dependent = nullptr;
int* int_ptr_;
)cpp");
- auto IntPtrTy = *OpaqueType::fromType(ASTCtx(), typeOf("int_ptr_"));
+ auto IntPtrTy = *OpaqueType::fromType(astCtx(), typeOf("int_ptr_"));
EXPECT_EQ(fromCompletionResult(decl("returns_not_dependent")), IntPtrTy);
EXPECT_EQ(fromCompletionResult(decl("returns_dependent")), llvm::None);
diff --git a/clang-tools-extra/clangd/unittests/FileIndexTests.cpp b/clang-tools-extra/clangd/unittests/FileIndexTests.cpp
index fe2f1c395c38..012468b61a96 100644
--- a/clang-tools-extra/clangd/unittests/FileIndexTests.cpp
+++ b/clang-tools-extra/clangd/unittests/FileIndexTests.cpp
@@ -46,28 +46,28 @@ using ::testing::IsEmpty;
using ::testing::Pair;
using ::testing::UnorderedElementsAre;
-MATCHER_P(RefRange, Range, "") {
+MATCHER_P(refRange, Range, "") {
return std::make_tuple(arg.Location.Start.line(), arg.Location.Start.column(),
arg.Location.End.line(), arg.Location.End.column()) ==
std::make_tuple(Range.start.line, Range.start.character,
Range.end.line, Range.end.character);
}
-MATCHER_P(FileURI, F, "") { return llvm::StringRef(arg.Location.FileURI) == F; }
-MATCHER_P(DeclURI, U, "") {
+MATCHER_P(fileURI, F, "") { return llvm::StringRef(arg.Location.FileURI) == F; }
+MATCHER_P(declURI, U, "") {
return llvm::StringRef(arg.CanonicalDeclaration.FileURI) == U;
}
-MATCHER_P(DefURI, U, "") {
+MATCHER_P(defURI, U, "") {
return llvm::StringRef(arg.Definition.FileURI) == U;
}
-MATCHER_P(QName, N, "") { return (arg.Scope + arg.Name).str() == N; }
-MATCHER_P(NumReferences, N, "") { return arg.References == N; }
+MATCHER_P(qName, N, "") { return (arg.Scope + arg.Name).str() == N; }
+MATCHER_P(numReferences, N, "") { return arg.References == N; }
MATCHER_P(hasOrign, O, "") { return bool(arg.Origin & O); }
namespace clang {
namespace clangd {
namespace {
::testing::Matcher<const RefSlab &>
-RefsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
+refsAre(std::vector<::testing::Matcher<Ref>> Matchers) {
return ElementsAre(::testing::Pair(_, UnorderedElementsAreArray(Matchers)));
}
@@ -80,8 +80,8 @@ Symbol symbol(llvm::StringRef ID) {
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());
}
@@ -108,9 +108,9 @@ TEST(FileSymbolsTest, UpdateAndGet) {
FS.update("f1", numSlab(1, 3), refSlab(SymbolID("1"), "f1.cc"), nullptr,
false);
EXPECT_THAT(runFuzzyFind(*FS.buildIndex(IndexType::Light), ""),
- UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
+ UnorderedElementsAre(qName("1"), qName("2"), qName("3")));
EXPECT_THAT(getRefs(*FS.buildIndex(IndexType::Light), SymbolID("1")),
- RefsAre({FileURI("f1.cc")}));
+ refsAre({fileURI("f1.cc")}));
}
TEST(FileSymbolsTest, Overlap) {
@@ -119,8 +119,8 @@ TEST(FileSymbolsTest, Overlap) {
FS.update("f2", numSlab(3, 5), nullptr, nullptr, false);
for (auto Type : {IndexType::Light, IndexType::Heavy})
EXPECT_THAT(runFuzzyFind(*FS.buildIndex(Type), ""),
- UnorderedElementsAre(QName("1"), QName("2"), QName("3"),
- QName("4"), QName("5")));
+ UnorderedElementsAre(qName("1"), qName("2"), qName("3"),
+ qName("4"), qName("5")));
}
TEST(FileSymbolsTest, MergeOverlap) {
@@ -141,7 +141,7 @@ TEST(FileSymbolsTest, MergeOverlap) {
EXPECT_THAT(
runFuzzyFind(*FS.buildIndex(Type, DuplicateHandling::Merge), "x"),
UnorderedElementsAre(
- AllOf(QName("x"), DeclURI("file:///x1"), DefURI("file:///x2"))));
+ AllOf(qName("x"), declURI("file:///x1"), defURI("file:///x2"))));
}
TEST(FileSymbolsTest, SnapshotAliveAfterRemove) {
@@ -152,8 +152,8 @@ TEST(FileSymbolsTest, SnapshotAliveAfterRemove) {
auto Symbols = FS.buildIndex(IndexType::Light);
EXPECT_THAT(runFuzzyFind(*Symbols, ""),
- UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
- EXPECT_THAT(getRefs(*Symbols, ID), RefsAre({FileURI("f1.cc")}));
+ UnorderedElementsAre(qName("1"), qName("2"), qName("3")));
+ EXPECT_THAT(getRefs(*Symbols, ID), refsAre({fileURI("f1.cc")}));
FS.update("f1", nullptr, nullptr, nullptr, false);
auto Empty = FS.buildIndex(IndexType::Light);
@@ -161,8 +161,8 @@ TEST(FileSymbolsTest, SnapshotAliveAfterRemove) {
EXPECT_THAT(getRefs(*Empty, ID), ElementsAre());
EXPECT_THAT(runFuzzyFind(*Symbols, ""),
- UnorderedElementsAre(QName("1"), QName("2"), QName("3")));
- EXPECT_THAT(getRefs(*Symbols, ID), RefsAre({FileURI("f1.cc")}));
+ UnorderedElementsAre(qName("1"), qName("2"), qName("3")));
+ EXPECT_THAT(getRefs(*Symbols, ID), refsAre({fileURI("f1.cc")}));
}
// Adds Basename.cpp, which includes Basename.h, which contains Code.
@@ -181,7 +181,7 @@ TEST(FileIndexTest, CustomizedURIScheme) {
FileIndex M;
update(M, "f", "class string {};");
- EXPECT_THAT(runFuzzyFind(M, ""), ElementsAre(DeclURI("unittest:///f.h")));
+ EXPECT_THAT(runFuzzyFind(M, ""), ElementsAre(declURI("unittest:///f.h")));
}
TEST(FileIndexTest, IndexAST) {
@@ -192,7 +192,7 @@ TEST(FileIndexTest, IndexAST) {
Req.Query = "";
Req.Scopes = {"ns::"};
EXPECT_THAT(runFuzzyFind(M, Req),
- UnorderedElementsAre(QName("ns::f"), QName("ns::X")));
+ UnorderedElementsAre(qName("ns::f"), qName("ns::X")));
}
TEST(FileIndexTest, NoLocal) {
@@ -201,7 +201,7 @@ TEST(FileIndexTest, NoLocal) {
EXPECT_THAT(
runFuzzyFind(M, ""),
- UnorderedElementsAre(QName("ns"), QName("ns::f"), QName("ns::X")));
+ UnorderedElementsAre(qName("ns"), qName("ns::f"), qName("ns::X")));
}
TEST(FileIndexTest, IndexMultiASTAndDeduplicate) {
@@ -213,7 +213,7 @@ TEST(FileIndexTest, IndexMultiASTAndDeduplicate) {
Req.Scopes = {"ns::"};
EXPECT_THAT(
runFuzzyFind(M, Req),
- UnorderedElementsAre(QName("ns::f"), QName("ns::X"), QName("ns::ff")));
+ UnorderedElementsAre(qName("ns::f"), qName("ns::X"), qName("ns::ff")));
}
TEST(FileIndexTest, ClassMembers) {
@@ -221,8 +221,8 @@ TEST(FileIndexTest, ClassMembers) {
update(M, "f1", "class X { static int m1; int m2; static void f(); };");
EXPECT_THAT(runFuzzyFind(M, ""),
- UnorderedElementsAre(QName("X"), QName("X::m1"), QName("X::m2"),
- QName("X::f")));
+ UnorderedElementsAre(qName("X"), qName("X::m1"), qName("X::m2"),
+ qName("X::f")));
}
TEST(FileIndexTest, IncludeCollected) {
@@ -263,7 +263,7 @@ vector<Ty> make_vector(Arg A) {}
auto Symbols = runFuzzyFind(M, "");
EXPECT_THAT(Symbols,
- UnorderedElementsAre(QName("vector"), QName("make_vector")));
+ UnorderedElementsAre(qName("vector"), qName("make_vector")));
auto It = Symbols.begin();
Symbol Vector = *It++;
Symbol MakeVector = *It++;
@@ -327,8 +327,8 @@ TEST(FileIndexTest, RebuildWithPreamble) {
Req.Scopes = {"", "ns_in_header::"};
EXPECT_THAT(runFuzzyFind(Index, Req),
- UnorderedElementsAre(QName("ns_in_header"),
- QName("ns_in_header::func_in_header")));
+ UnorderedElementsAre(qName("ns_in_header"),
+ qName("ns_in_header::func_in_header")));
}
TEST(FileIndexTest, Refs) {
@@ -362,10 +362,10 @@ TEST(FileIndexTest, Refs) {
Index.updateMain(testPath(Test2.Filename), AST);
EXPECT_THAT(getRefs(Index, Foo.ID),
- RefsAre({AllOf(RefRange(MainCode.range("foo")),
- FileURI("unittest:///test.cc")),
- AllOf(RefRange(MainCode.range("foo")),
- FileURI("unittest:///test2.cc"))}));
+ refsAre({AllOf(refRange(MainCode.range("foo")),
+ fileURI("unittest:///test.cc")),
+ AllOf(refRange(MainCode.range("foo")),
+ fileURI("unittest:///test2.cc"))}));
}
TEST(FileIndexTest, MacroRefs) {
@@ -391,21 +391,21 @@ TEST(FileIndexTest, MacroRefs) {
auto HeaderMacro = findSymbol(Test.headerSymbols(), "HEADER_MACRO");
EXPECT_THAT(getRefs(Index, HeaderMacro.ID),
- RefsAre({AllOf(RefRange(MainCode.range("ref1")),
- FileURI("unittest:///test.cc"))}));
+ refsAre({AllOf(refRange(MainCode.range("ref1")),
+ fileURI("unittest:///test.cc"))}));
auto MainFileMacro = findSymbol(Test.headerSymbols(), "MAINFILE_MACRO");
EXPECT_THAT(getRefs(Index, MainFileMacro.ID),
- RefsAre({AllOf(RefRange(MainCode.range("def2")),
- FileURI("unittest:///test.cc")),
- AllOf(RefRange(MainCode.range("ref2")),
- FileURI("unittest:///test.cc"))}));
+ refsAre({AllOf(refRange(MainCode.range("def2")),
+ fileURI("unittest:///test.cc")),
+ AllOf(refRange(MainCode.range("ref2")),
+ fileURI("unittest:///test.cc"))}));
}
TEST(FileIndexTest, CollectMacros) {
FileIndex M;
update(M, "f", "#define CLANGD 1");
- EXPECT_THAT(runFuzzyFind(M, ""), Contains(QName("CLANGD")));
+ EXPECT_THAT(runFuzzyFind(M, ""), Contains(qName("CLANGD")));
}
TEST(FileIndexTest, Relations) {
@@ -470,7 +470,7 @@ TEST(FileIndexTest, ReferencesInMainFileWithPreamble) {
// 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) {
@@ -489,8 +489,8 @@ TEST(FileIndexTest, MergeMainFileSymbols) {
auto Symbols = runFuzzyFind(Index, "");
// Check foo is merged, foo in Cpp wins (as we see the definition there).
- EXPECT_THAT(Symbols, ElementsAre(AllOf(DeclURI("unittest:///foo.h"),
- DefURI("unittest:///foo.cpp"),
+ EXPECT_THAT(Symbols, ElementsAre(AllOf(declURI("unittest:///foo.h"),
+ defURI("unittest:///foo.cpp"),
hasOrign(SymbolOrigin::Merge))));
}
@@ -501,9 +501,9 @@ TEST(FileSymbolsTest, CountReferencesNoRefSlabs) {
EXPECT_THAT(
runFuzzyFind(*FS.buildIndex(IndexType::Light, DuplicateHandling::Merge),
""),
- UnorderedElementsAre(AllOf(QName("1"), NumReferences(0u)),
- AllOf(QName("2"), NumReferences(0u)),
- AllOf(QName("3"), NumReferences(0u))));
+ UnorderedElementsAre(AllOf(qName("1"), numReferences(0u)),
+ AllOf(qName("2"), numReferences(0u)),
+ AllOf(qName("3"), numReferences(0u))));
}
TEST(FileSymbolsTest, CountReferencesWithRefSlabs) {
@@ -523,9 +523,9 @@ TEST(FileSymbolsTest, CountReferencesWithRefSlabs) {
EXPECT_THAT(
runFuzzyFind(*FS.buildIndex(IndexType::Light, DuplicateHandling::Merge),
""),
- UnorderedElementsAre(AllOf(QName("1"), NumReferences(1u)),
- AllOf(QName("2"), NumReferences(1u)),
- AllOf(QName("3"), NumReferences(1u))));
+ UnorderedElementsAre(AllOf(qName("1"), numReferences(1u)),
+ AllOf(qName("2"), numReferences(1u)),
+ AllOf(qName("3"), numReferences(1u))));
}
TEST(FileIndexTest, StalePreambleSymbolsDeleted) {
@@ -539,7 +539,7 @@ TEST(FileIndexTest, StalePreambleSymbolsDeleted) {
M.updatePreamble(testPath(File.Filename), /*Version=*/"null",
AST.getASTContext(), AST.getPreprocessor(),
AST.getCanonicalIncludes());
- EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(QName("a")));
+ EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(qName("a")));
File.Filename = "f2.cpp";
File.HeaderCode = "int b;";
@@ -547,7 +547,7 @@ TEST(FileIndexTest, StalePreambleSymbolsDeleted) {
M.updatePreamble(testPath(File.Filename), /*Version=*/"null",
AST.getASTContext(), AST.getPreprocessor(),
AST.getCanonicalIncludes());
- EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(QName("b")));
+ EXPECT_THAT(runFuzzyFind(M, ""), UnorderedElementsAre(qName("b")));
}
// Verifies that concurrent calls to updateMain don't "lose" any updates.
@@ -644,7 +644,7 @@ TEST(FileShardedIndexTest, Sharding) {
{
auto Shard = ShardedIndex.getShard(AHeaderUri);
ASSERT_TRUE(Shard);
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(QName("1")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(qName("1")));
EXPECT_THAT(*Shard->Refs, IsEmpty());
EXPECT_THAT(
*Shard->Relations,
@@ -658,7 +658,7 @@ TEST(FileShardedIndexTest, Sharding) {
{
auto Shard = ShardedIndex.getShard(BHeaderUri);
ASSERT_TRUE(Shard);
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(QName("2")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(qName("2")));
EXPECT_THAT(*Shard->Refs, IsEmpty());
EXPECT_THAT(
*Shard->Relations,
@@ -673,7 +673,7 @@ TEST(FileShardedIndexTest, Sharding) {
{
auto Shard = ShardedIndex.getShard(BSourceUri);
ASSERT_TRUE(Shard);
- EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(QName("2")));
+ EXPECT_THAT(*Shard->Symbols, UnorderedElementsAre(qName("2")));
EXPECT_THAT(*Shard->Refs, UnorderedElementsAre(Pair(Sym1.ID, _)));
EXPECT_THAT(*Shard->Relations, IsEmpty());
ASSERT_THAT(Shard->Sources->keys(),
diff --git a/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp b/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
index ed6bf334edac..73bd5c1a537a 100644
--- a/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/FindSymbolsTests.cpp
@@ -28,20 +28,20 @@ using ::testing::IsEmpty;
using ::testing::UnorderedElementsAre;
// GMock helpers for matching SymbolInfos items.
-MATCHER_P(QName, Name, "") {
+MATCHER_P(qName, Name, "") {
if (arg.containerName.empty())
return arg.name == Name;
return (arg.containerName + "::" + arg.name) == Name;
}
-MATCHER_P(WithName, N, "") { return arg.name == N; }
-MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
-MATCHER_P(WithDetail, Detail, "") { return arg.detail == Detail; }
-MATCHER_P(SymRange, Range, "") { return arg.range == Range; }
+MATCHER_P(withName, N, "") { return arg.name == N; }
+MATCHER_P(withKind, Kind, "") { return arg.kind == Kind; }
+MATCHER_P(withDetail, Detail, "") { return arg.detail == Detail; }
+MATCHER_P(symRange, Range, "") { return arg.range == Range; }
// GMock helpers for matching DocumentSymbol.
-MATCHER_P(SymNameRange, Range, "") { return arg.selectionRange == Range; }
+MATCHER_P(symNameRange, Range, "") { return arg.selectionRange == Range; }
template <class... ChildMatchers>
-::testing::Matcher<DocumentSymbol> Children(ChildMatchers... ChildrenM) {
+::testing::Matcher<DocumentSymbol> children(ChildMatchers... ChildrenM) {
return Field(&DocumentSymbol::children, UnorderedElementsAre(ChildrenM...));
}
@@ -63,7 +63,7 @@ TEST(WorkspaceSymbols, Macros) {
// indexSymbolKindToSymbolKind() currently maps macros
// to SymbolKind::String.
EXPECT_THAT(getSymbols(TU, "macro"),
- ElementsAre(AllOf(QName("MACRO"), WithKind(SymbolKind::String))));
+ ElementsAre(AllOf(qName("MACRO"), withKind(SymbolKind::String))));
}
TEST(WorkspaceSymbols, NoLocals) {
@@ -73,7 +73,7 @@ TEST(WorkspaceSymbols, NoLocals) {
struct LocalClass {};
int local_var;
})cpp";
- EXPECT_THAT(getSymbols(TU, "l"), ElementsAre(QName("LocalClass")));
+ EXPECT_THAT(getSymbols(TU, "l"), ElementsAre(qName("LocalClass")));
EXPECT_THAT(getSymbols(TU, "p"), IsEmpty());
}
@@ -90,9 +90,9 @@ TEST(WorkspaceSymbols, Globals) {
)cpp";
EXPECT_THAT(getSymbols(TU, "global"),
UnorderedElementsAre(
- AllOf(QName("GlobalStruct"), WithKind(SymbolKind::Struct)),
- AllOf(QName("global_func"), WithKind(SymbolKind::Function)),
- AllOf(QName("global_var"), WithKind(SymbolKind::Variable))));
+ AllOf(qName("GlobalStruct"), withKind(SymbolKind::Struct)),
+ AllOf(qName("global_func"), withKind(SymbolKind::Function)),
+ AllOf(qName("global_var"), withKind(SymbolKind::Variable))));
}
TEST(WorkspaceSymbols, Unnamed) {
@@ -105,11 +105,11 @@ TEST(WorkspaceSymbols, Unnamed) {
#include "foo.h"
)cpp";
EXPECT_THAT(getSymbols(TU, "UnnamedStruct"),
- ElementsAre(AllOf(QName("UnnamedStruct"),
- WithKind(SymbolKind::Variable))));
+ ElementsAre(AllOf(qName("UnnamedStruct"),
+ withKind(SymbolKind::Variable))));
EXPECT_THAT(getSymbols(TU, "InUnnamed"),
- ElementsAre(AllOf(QName("(anonymous struct)::InUnnamed"),
- WithKind(SymbolKind::Field))));
+ ElementsAre(AllOf(qName("(anonymous struct)::InUnnamed"),
+ withKind(SymbolKind::Field))));
}
TEST(WorkspaceSymbols, InMainFile) {
@@ -119,7 +119,7 @@ TEST(WorkspaceSymbols, InMainFile) {
static void test2() {}
)cpp";
EXPECT_THAT(getSymbols(TU, "test"),
- ElementsAre(QName("test"), QName("test2")));
+ ElementsAre(qName("test"), qName("test2")));
}
TEST(WorkspaceSymbols, Namespaces) {
@@ -140,30 +140,30 @@ TEST(WorkspaceSymbols, Namespaces) {
)cpp";
EXPECT_THAT(getSymbols(TU, "a"),
UnorderedElementsAre(
- QName("ans1"), QName("ans1::ai1"), QName("ans1::ans2"),
- QName("ans1::ans2::ai2"), QName("ans1::ans2::ans3"),
- QName("ans1::ans2::ans3::ai3")));
- EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(QName("ans1")));
- EXPECT_THAT(getSymbols(TU, "::a"), ElementsAre(QName("ans1")));
+ qName("ans1"), qName("ans1::ai1"), qName("ans1::ans2"),
+ qName("ans1::ans2::ai2"), qName("ans1::ans2::ans3"),
+ qName("ans1::ans2::ans3::ai3")));
+ EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(qName("ans1")));
+ EXPECT_THAT(getSymbols(TU, "::a"), ElementsAre(qName("ans1")));
EXPECT_THAT(getSymbols(TU, "ans1::"),
- UnorderedElementsAre(QName("ans1::ai1"), QName("ans1::ans2"),
- QName("ans1::ans2::ai2"),
- QName("ans1::ans2::ans3"),
- QName("ans1::ans2::ans3::ai3")));
+ UnorderedElementsAre(qName("ans1::ai1"), qName("ans1::ans2"),
+ qName("ans1::ans2::ai2"),
+ qName("ans1::ans2::ans3"),
+ qName("ans1::ans2::ans3::ai3")));
EXPECT_THAT(getSymbols(TU, "ans2::"),
- UnorderedElementsAre(QName("ans1::ans2::ai2"),
- QName("ans1::ans2::ans3"),
- QName("ans1::ans2::ans3::ai3")));
- EXPECT_THAT(getSymbols(TU, "::ans1"), ElementsAre(QName("ans1")));
+ UnorderedElementsAre(qName("ans1::ans2::ai2"),
+ qName("ans1::ans2::ans3"),
+ qName("ans1::ans2::ans3::ai3")));
+ EXPECT_THAT(getSymbols(TU, "::ans1"), ElementsAre(qName("ans1")));
EXPECT_THAT(getSymbols(TU, "::ans1::"),
- UnorderedElementsAre(QName("ans1::ai1"), QName("ans1::ans2")));
- EXPECT_THAT(getSymbols(TU, "::ans1::ans2"), ElementsAre(QName("ans1::ans2")));
+ UnorderedElementsAre(qName("ans1::ai1"), qName("ans1::ans2")));
+ EXPECT_THAT(getSymbols(TU, "::ans1::ans2"), ElementsAre(qName("ans1::ans2")));
EXPECT_THAT(getSymbols(TU, "::ans1::ans2::"),
- ElementsAre(QName("ans1::ans2::ai2"), QName("ans1::ans2::ans3")));
+ ElementsAre(qName("ans1::ans2::ai2"), qName("ans1::ans2::ans3")));
// Ensure sub-sequence matching works.
EXPECT_THAT(getSymbols(TU, "ans1::ans3::ai"),
- UnorderedElementsAre(QName("ans1::ans2::ans3::ai3")));
+ UnorderedElementsAre(qName("ans1::ans2::ans3::ai3")));
}
TEST(WorkspaceSymbols, AnonymousNamespace) {
@@ -173,7 +173,7 @@ TEST(WorkspaceSymbols, AnonymousNamespace) {
void test() {}
}
)cpp";
- EXPECT_THAT(getSymbols(TU, "test"), ElementsAre(QName("test")));
+ EXPECT_THAT(getSymbols(TU, "test"), ElementsAre(qName("test")));
}
TEST(WorkspaceSymbols, MultiFile) {
@@ -191,7 +191,7 @@ TEST(WorkspaceSymbols, MultiFile) {
#include "foo2.h"
)cpp";
EXPECT_THAT(getSymbols(TU, "foo"),
- UnorderedElementsAre(QName("foo"), QName("foo2")));
+ UnorderedElementsAre(qName("foo"), qName("foo2")));
}
TEST(WorkspaceSymbols, GlobalNamespaceQueries) {
@@ -212,13 +212,13 @@ TEST(WorkspaceSymbols, GlobalNamespaceQueries) {
)cpp";
EXPECT_THAT(getSymbols(TU, "::"),
UnorderedElementsAre(
- AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
- AllOf(QName("foo"), WithKind(SymbolKind::Function)),
- AllOf(QName("ns"), WithKind(SymbolKind::Namespace))));
+ AllOf(qName("Foo"), withKind(SymbolKind::Class)),
+ AllOf(qName("foo"), withKind(SymbolKind::Function)),
+ AllOf(qName("ns"), withKind(SymbolKind::Namespace))));
EXPECT_THAT(getSymbols(TU, ":"), IsEmpty());
EXPECT_THAT(getSymbols(TU, ""),
- UnorderedElementsAre(QName("foo"), QName("Foo"), QName("Foo::a"),
- QName("ns"), QName("ns::foo2")));
+ UnorderedElementsAre(qName("foo"), qName("Foo"), qName("Foo::a"),
+ qName("ns"), qName("ns::foo2")));
}
TEST(WorkspaceSymbols, Enums) {
@@ -248,18 +248,18 @@ TEST(WorkspaceSymbols, Enums) {
TU.Code = R"cpp(
#include "foo.h"
)cpp";
- EXPECT_THAT(getSymbols(TU, "Red"), ElementsAre(QName("Red")));
- EXPECT_THAT(getSymbols(TU, "::Red"), ElementsAre(QName("Red")));
- EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(QName("Green")));
- EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(QName("Green")));
+ EXPECT_THAT(getSymbols(TU, "Red"), ElementsAre(qName("Red")));
+ EXPECT_THAT(getSymbols(TU, "::Red"), ElementsAre(qName("Red")));
+ EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(qName("Green")));
+ EXPECT_THAT(getSymbols(TU, "Green"), ElementsAre(qName("Green")));
EXPECT_THAT(getSymbols(TU, "Color2::Yellow"),
- ElementsAre(QName("Color2::Yellow")));
- EXPECT_THAT(getSymbols(TU, "Yellow"), ElementsAre(QName("Color2::Yellow")));
+ ElementsAre(qName("Color2::Yellow")));
+ EXPECT_THAT(getSymbols(TU, "Yellow"), ElementsAre(qName("Color2::Yellow")));
- EXPECT_THAT(getSymbols(TU, "ns::Black"), ElementsAre(QName("ns::Black")));
- EXPECT_THAT(getSymbols(TU, "ns::Blue"), ElementsAre(QName("ns::Blue")));
+ EXPECT_THAT(getSymbols(TU, "ns::Black"), ElementsAre(qName("ns::Black")));
+ EXPECT_THAT(getSymbols(TU, "ns::Blue"), ElementsAre(qName("ns::Blue")));
EXPECT_THAT(getSymbols(TU, "ns::Color4::White"),
- ElementsAre(QName("ns::Color4::White")));
+ ElementsAre(qName("ns::Color4::White")));
}
TEST(WorkspaceSymbols, Ranking) {
@@ -271,7 +271,7 @@ TEST(WorkspaceSymbols, Ranking) {
TU.Code = R"cpp(
#include "foo.h"
)cpp";
- EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(QName("func"), QName("ns")));
+ EXPECT_THAT(getSymbols(TU, "::"), ElementsAre(qName("func"), qName("ns")));
}
TEST(WorkspaceSymbols, RankingPartialNamespace) {
@@ -282,7 +282,7 @@ TEST(WorkspaceSymbols, RankingPartialNamespace) {
}
namespace ns2 { struct FooB {}; })cpp";
EXPECT_THAT(getSymbols(TU, "ns2::f"),
- ElementsAre(QName("ns2::FooB"), QName("ns1::ns2::Foo")));
+ ElementsAre(qName("ns2::FooB"), qName("ns1::ns2::Foo")));
}
TEST(WorkspaceSymbols, WithLimit) {
@@ -297,10 +297,10 @@ TEST(WorkspaceSymbols, WithLimit) {
// Foo is higher ranked because of exact name match.
EXPECT_THAT(getSymbols(TU, "foo"),
UnorderedElementsAre(
- AllOf(QName("foo"), WithKind(SymbolKind::Variable)),
- AllOf(QName("foo2"), WithKind(SymbolKind::Variable))));
+ AllOf(qName("foo"), withKind(SymbolKind::Variable)),
+ AllOf(qName("foo2"), withKind(SymbolKind::Variable))));
- EXPECT_THAT(getSymbols(TU, "foo", 1), ElementsAre(QName("foo")));
+ EXPECT_THAT(getSymbols(TU, "foo", 1), ElementsAre(qName("foo")));
}
TEST(WorkspaceSymbols, TempSpecs) {
@@ -316,10 +316,10 @@ TEST(WorkspaceSymbols, TempSpecs) {
EXPECT_THAT(
getSymbols(TU, "Foo"),
UnorderedElementsAre(
- AllOf(QName("Foo"), WithKind(SymbolKind::Class)),
- AllOf(QName("Foo<int, T>"), WithKind(SymbolKind::Class)),
- AllOf(QName("Foo<bool, int>"), WithKind(SymbolKind::Class)),
- AllOf(QName("Foo<bool, int, 3>"), WithKind(SymbolKind::Class))));
+ AllOf(qName("Foo"), withKind(SymbolKind::Class)),
+ AllOf(qName("Foo<int, T>"), withKind(SymbolKind::Class)),
+ AllOf(qName("Foo<bool, int>"), withKind(SymbolKind::Class)),
+ AllOf(qName("Foo<bool, int, 3>"), withKind(SymbolKind::Class))));
}
std::vector<DocumentSymbol> getSymbols(ParsedAST AST) {
@@ -377,55 +377,55 @@ TEST(DocumentSymbols, BasicSymbols) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAreArray(
- {AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
- WithDetail("class"), Children()),
- AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
- WithDetail("class"),
- Children(
- AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
- WithDetail("()"), Children()),
- AllOf(WithName("Foo"), WithKind(SymbolKind::Constructor),
- WithDetail("(int)"), Children()),
- AllOf(WithName("f"), WithKind(SymbolKind::Method),
- WithDetail("void ()"), Children()),
- AllOf(WithName("operator="), WithKind(SymbolKind::Method),
- WithDetail("Foo &(const Foo &)"), Children()),
- AllOf(WithName("~Foo"), WithKind(SymbolKind::Constructor),
- WithDetail(""), Children()),
- AllOf(WithName("Nested"), WithKind(SymbolKind::Class),
- WithDetail("class"),
- Children(AllOf(
- WithName("f"), WithKind(SymbolKind::Method),
- WithDetail("void ()"), Children()))))),
- AllOf(WithName("Friend"), WithKind(SymbolKind::Class),
- WithDetail("class"), Children()),
- AllOf(WithName("f1"), WithKind(SymbolKind::Function),
- WithDetail("void ()"), Children()),
- AllOf(WithName("f2"), WithKind(SymbolKind::Function),
- WithDetail("void ()"), Children()),
- AllOf(WithName("KInt"), WithKind(SymbolKind::Variable),
- WithDetail("const int"), Children()),
- AllOf(WithName("kStr"), WithKind(SymbolKind::Variable),
- WithDetail("const char *"), Children()),
- AllOf(WithName("f1"), WithKind(SymbolKind::Function),
- WithDetail("void ()"), Children()),
+ {AllOf(withName("Foo"), withKind(SymbolKind::Class),
+ withDetail("class"), children()),
+ AllOf(withName("Foo"), withKind(SymbolKind::Class),
+ withDetail("class"),
+ children(
+ AllOf(withName("Foo"), withKind(SymbolKind::Constructor),
+ withDetail("()"), children()),
+ AllOf(withName("Foo"), withKind(SymbolKind::Constructor),
+ withDetail("(int)"), children()),
+ AllOf(withName("f"), withKind(SymbolKind::Method),
+ withDetail("void ()"), children()),
+ AllOf(withName("operator="), withKind(SymbolKind::Method),
+ withDetail("Foo &(const Foo &)"), children()),
+ AllOf(withName("~Foo"), withKind(SymbolKind::Constructor),
+ withDetail(""), children()),
+ AllOf(withName("Nested"), withKind(SymbolKind::Class),
+ withDetail("class"),
+ children(AllOf(
+ withName("f"), withKind(SymbolKind::Method),
+ withDetail("void ()"), children()))))),
+ AllOf(withName("Friend"), withKind(SymbolKind::Class),
+ withDetail("class"), children()),
+ AllOf(withName("f1"), withKind(SymbolKind::Function),
+ withDetail("void ()"), children()),
+ AllOf(withName("f2"), withKind(SymbolKind::Function),
+ withDetail("void ()"), children()),
+ AllOf(withName("KInt"), withKind(SymbolKind::Variable),
+ withDetail("const int"), children()),
+ AllOf(withName("kStr"), withKind(SymbolKind::Variable),
+ withDetail("const char *"), children()),
+ AllOf(withName("f1"), withKind(SymbolKind::Function),
+ withDetail("void ()"), children()),
AllOf(
- WithName("foo"), WithKind(SymbolKind::Namespace), WithDetail(""),
- Children(AllOf(WithName("int32"), WithKind(SymbolKind::Class),
- WithDetail("type alias"), Children()),
- AllOf(WithName("int32_t"), WithKind(SymbolKind::Class),
- WithDetail("type alias"), Children()),
- AllOf(WithName("v1"), WithKind(SymbolKind::Variable),
- WithDetail("int"), Children()),
- AllOf(WithName("bar"), WithKind(SymbolKind::Namespace),
- WithDetail(""),
- Children(AllOf(WithName("v2"),
- WithKind(SymbolKind::Variable),
- WithDetail("int"), Children()))),
- AllOf(WithName("baz"), WithKind(SymbolKind::Namespace),
- WithDetail(""), Children()),
- AllOf(WithName("v2"), WithKind(SymbolKind::Namespace),
- WithDetail(""))))}));
+ withName("foo"), withKind(SymbolKind::Namespace), withDetail(""),
+ children(AllOf(withName("int32"), withKind(SymbolKind::Class),
+ withDetail("type alias"), children()),
+ AllOf(withName("int32_t"), withKind(SymbolKind::Class),
+ withDetail("type alias"), children()),
+ AllOf(withName("v1"), withKind(SymbolKind::Variable),
+ withDetail("int"), children()),
+ AllOf(withName("bar"), withKind(SymbolKind::Namespace),
+ withDetail(""),
+ children(AllOf(withName("v2"),
+ withKind(SymbolKind::Variable),
+ withDetail("int"), children()))),
+ AllOf(withName("baz"), withKind(SymbolKind::Namespace),
+ withDetail(""), children()),
+ AllOf(withName("v2"), withKind(SymbolKind::Namespace),
+ withDetail(""))))}));
}
TEST(DocumentSymbols, DeclarationDefinition) {
@@ -442,13 +442,13 @@ TEST(DocumentSymbols, DeclarationDefinition) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
- WithDetail("class"),
- Children(AllOf(WithName("f"), WithKind(SymbolKind::Method),
- WithDetail("void ()"),
- SymNameRange(Main.range("decl"))))),
- AllOf(WithName("Foo::f"), WithKind(SymbolKind::Method),
- WithDetail("void ()"), SymNameRange(Main.range("def")))));
+ AllOf(withName("Foo"), withKind(SymbolKind::Class),
+ withDetail("class"),
+ children(AllOf(withName("f"), withKind(SymbolKind::Method),
+ withDetail("void ()"),
+ symNameRange(Main.range("decl"))))),
+ AllOf(withName("Foo::f"), withKind(SymbolKind::Method),
+ withDetail("void ()"), symNameRange(Main.range("def")))));
}
TEST(DocumentSymbols, Concepts) {
@@ -457,7 +457,7 @@ TEST(DocumentSymbols, Concepts) {
TU.Code = "template <typename T> concept C = requires(T t) { t.foo(); };";
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(AllOf(WithName("C"), WithDetail("concept"))));
+ ElementsAre(AllOf(withName("C"), withDetail("concept"))));
}
TEST(DocumentSymbols, ExternSymbol) {
@@ -487,9 +487,9 @@ TEST(DocumentSymbols, ExternContext) {
})cpp";
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(WithName("foo"), WithName("Foo"),
- AllOf(WithName("ns"),
- Children(WithName("bar"), WithName("Bar")))));
+ ElementsAre(withName("foo"), withName("Foo"),
+ AllOf(withName("ns"),
+ children(withName("bar"), withName("Bar")))));
}
TEST(DocumentSymbols, ExportContext) {
@@ -503,7 +503,7 @@ TEST(DocumentSymbols, ExportContext) {
})cpp";
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(WithName("foo"), WithName("Foo")));
+ ElementsAre(withName("foo"), withName("Foo")));
}
TEST(DocumentSymbols, NoLocals) {
@@ -513,7 +513,7 @@ TEST(DocumentSymbols, NoLocals) {
struct LocalClass {};
int local_var;
})cpp";
- EXPECT_THAT(getSymbols(TU.build()), ElementsAre(WithName("test")));
+ EXPECT_THAT(getSymbols(TU.build()), ElementsAre(withName("test")));
}
TEST(DocumentSymbols, Unnamed) {
@@ -525,14 +525,14 @@ TEST(DocumentSymbols, Unnamed) {
)cpp";
EXPECT_THAT(
getSymbols(TU.build()),
- ElementsAre(AllOf(WithName("(anonymous struct)"),
- WithKind(SymbolKind::Struct), WithDetail("struct"),
- Children(AllOf(WithName("InUnnamed"),
- WithKind(SymbolKind::Field),
- WithDetail("int"), Children()))),
- AllOf(WithName("UnnamedStruct"),
- WithKind(SymbolKind::Variable),
- WithDetail("struct (unnamed)"), Children())));
+ ElementsAre(AllOf(withName("(anonymous struct)"),
+ withKind(SymbolKind::Struct), withDetail("struct"),
+ children(AllOf(withName("InUnnamed"),
+ withKind(SymbolKind::Field),
+ withDetail("int"), children()))),
+ AllOf(withName("UnnamedStruct"),
+ withKind(SymbolKind::Variable),
+ withDetail("struct (unnamed)"), children())));
}
TEST(DocumentSymbols, InHeaderFile) {
@@ -548,7 +548,7 @@ TEST(DocumentSymbols, InHeaderFile) {
}
)cpp";
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(WithName("i"), WithName("test")));
+ ElementsAre(withName("i"), withName("test")));
}
TEST(DocumentSymbols, Template) {
@@ -574,23 +574,23 @@ TEST(DocumentSymbols, Template) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("Tmpl"), WithKind(SymbolKind::Struct),
- WithDetail("template struct"),
- Children(AllOf(WithName("x"), WithKind(SymbolKind::Field),
- WithDetail("T")))),
- AllOf(WithName("Tmpl<int>"), WithKind(SymbolKind::Struct),
- WithDetail("struct"),
- Children(AllOf(WithName("y"), WithDetail("int")))),
- AllOf(WithName("Tmpl<float>"), WithKind(SymbolKind::Struct),
- WithDetail("struct"), Children()),
- AllOf(WithName("Tmpl<double>"), WithKind(SymbolKind::Struct),
- WithDetail("struct"), Children()),
- AllOf(WithName("funcTmpl"), WithDetail("template int (U)"),
- Children()),
- AllOf(WithName("funcTmpl<int>"), WithDetail("int (double)"),
- Children()),
- AllOf(WithName("varTmpl"), WithDetail("template int"), Children()),
- AllOf(WithName("varTmpl<int>"), WithDetail("double"), Children())));
+ AllOf(withName("Tmpl"), withKind(SymbolKind::Struct),
+ withDetail("template struct"),
+ children(AllOf(withName("x"), withKind(SymbolKind::Field),
+ withDetail("T")))),
+ AllOf(withName("Tmpl<int>"), withKind(SymbolKind::Struct),
+ withDetail("struct"),
+ children(AllOf(withName("y"), withDetail("int")))),
+ AllOf(withName("Tmpl<float>"), withKind(SymbolKind::Struct),
+ withDetail("struct"), children()),
+ AllOf(withName("Tmpl<double>"), withKind(SymbolKind::Struct),
+ withDetail("struct"), children()),
+ AllOf(withName("funcTmpl"), withDetail("template int (U)"),
+ children()),
+ AllOf(withName("funcTmpl<int>"), withDetail("int (double)"),
+ children()),
+ AllOf(withName("varTmpl"), withDetail("template int"), children()),
+ AllOf(withName("varTmpl<int>"), withDetail("double"), children())));
}
TEST(DocumentSymbols, Namespaces) {
@@ -621,14 +621,14 @@ TEST(DocumentSymbols, Namespaces) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAreArray<::testing::Matcher<DocumentSymbol>>(
- {AllOf(WithName("ans1"),
- Children(AllOf(WithName("ai1"), Children()),
- AllOf(WithName("ans2"), Children(WithName("ai2"))))),
- AllOf(WithName("(anonymous namespace)"), Children(WithName("test"))),
- AllOf(WithName("na"),
- Children(AllOf(WithName("nb"), Children(WithName("Foo"))))),
- AllOf(WithName("na"),
- Children(AllOf(WithName("nb"), Children(WithName("Bar")))))}));
+ {AllOf(withName("ans1"),
+ children(AllOf(withName("ai1"), children()),
+ AllOf(withName("ans2"), children(withName("ai2"))))),
+ AllOf(withName("(anonymous namespace)"), children(withName("test"))),
+ AllOf(withName("na"),
+ children(AllOf(withName("nb"), children(withName("Foo"))))),
+ AllOf(withName("na"),
+ children(AllOf(withName("nb"), children(withName("Bar")))))}));
}
TEST(DocumentSymbols, Enums) {
@@ -652,16 +652,16 @@ TEST(DocumentSymbols, Enums) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("(anonymous enum)"), WithDetail("enum"),
- Children(AllOf(WithName("Red"), WithDetail("(unnamed)")))),
- AllOf(WithName("Color"), WithDetail("enum"),
- Children(AllOf(WithName("Green"), WithDetail("Color")))),
- AllOf(WithName("Color2"), WithDetail("enum"),
- Children(AllOf(WithName("Yellow"), WithDetail("Color2")))),
- AllOf(WithName("ns"),
- Children(AllOf(WithName("(anonymous enum)"), WithDetail("enum"),
- Children(AllOf(WithName("Black"),
- WithDetail("(unnamed)"))))))));
+ AllOf(withName("(anonymous enum)"), withDetail("enum"),
+ children(AllOf(withName("Red"), withDetail("(unnamed)")))),
+ AllOf(withName("Color"), withDetail("enum"),
+ children(AllOf(withName("Green"), withDetail("Color")))),
+ AllOf(withName("Color2"), withDetail("enum"),
+ children(AllOf(withName("Yellow"), withDetail("Color2")))),
+ AllOf(withName("ns"),
+ children(AllOf(withName("(anonymous enum)"), withDetail("enum"),
+ children(AllOf(withName("Black"),
+ withDetail("(unnamed)"))))))));
}
TEST(DocumentSymbols, Macro) {
@@ -675,8 +675,8 @@ TEST(DocumentSymbols, Macro) {
#define DEFINE_FLAG(X) bool FLAGS_##X; bool FLAGS_no##X
DEFINE_FLAG(pretty);
)cpp",
- AllOf(WithName("DEFINE_FLAG"), WithDetail("(pretty)"),
- Children(WithName("FLAGS_pretty"), WithName("FLAGS_nopretty"))),
+ AllOf(withName("DEFINE_FLAG"), withDetail("(pretty)"),
+ children(withName("FLAGS_pretty"), withName("FLAGS_nopretty"))),
},
{
R"cpp(
@@ -684,10 +684,10 @@ TEST(DocumentSymbols, Macro) {
#define ID(X) X
namespace ID(ns) { int ID(y); }
)cpp",
- AllOf(WithName("ID"), WithDetail("(ns)"),
- Children(AllOf(WithName("ns"),
- Children(AllOf(WithName("ID"), WithDetail("(y)"),
- Children(WithName("y"))))))),
+ AllOf(withName("ID"), withDetail("(ns)"),
+ children(AllOf(withName("ns"),
+ children(AllOf(withName("ID"), withDetail("(y)"),
+ children(withName("y"))))))),
},
{
R"cpp(
@@ -695,10 +695,10 @@ TEST(DocumentSymbols, Macro) {
#define TEST(A, B) class A##_##B { void go(); }; void A##_##B::go()
TEST(DocumentSymbols, Macro) { }
)cpp",
- AllOf(WithName("TEST"), WithDetail("(DocumentSymbols, Macro)"),
- Children(AllOf(WithName("DocumentSymbols_Macro"),
- Children(WithName("go"))),
- WithName("DocumentSymbols_Macro::go"))),
+ AllOf(withName("TEST"), withDetail("(DocumentSymbols, Macro)"),
+ children(AllOf(withName("DocumentSymbols_Macro"),
+ children(withName("go"))),
+ withName("DocumentSymbols_Macro::go"))),
},
{
R"cpp(
@@ -707,14 +707,14 @@ TEST(DocumentSymbols, Macro) {
NAMESPACE(a, NAMESPACE(b, int x;))
)cpp",
AllOf(
- WithName("NAMESPACE"), WithDetail("(a, NAMESPACE(b, int x;))"),
- Children(AllOf(
- WithName("a"),
- Children(AllOf(WithName("NAMESPACE"),
+ withName("NAMESPACE"), withDetail("(a, NAMESPACE(b, int x;))"),
+ children(AllOf(
+ withName("a"),
+ children(AllOf(withName("NAMESPACE"),
// FIXME: nested expansions not in TokenBuffer
- WithDetail(""),
- Children(AllOf(WithName("b"),
- Children(WithName("x"))))))))),
+ withDetail(""),
+ children(AllOf(withName("b"),
+ children(withName("x"))))))))),
},
{
R"cpp(
@@ -723,8 +723,8 @@ TEST(DocumentSymbols, Macro) {
#define OUTER(X) INNER(X)
OUTER(foo);
)cpp",
- AllOf(WithName("OUTER"), WithDetail("(foo)"),
- Children(WithName("foo"))),
+ AllOf(withName("OUTER"), withDetail("(foo)"),
+ children(withName("foo"))),
},
};
for (const Test &T : Tests) {
@@ -757,18 +757,18 @@ TEST(DocumentSymbols, RangeFromMacro) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("FF"), WithDetail("(abc)"),
- Children(AllOf(WithName("abc_Test"), WithDetail("class"),
- SymNameRange(Main.range("expansion1"))))),
- AllOf(WithName("FF2"), WithDetail("()"),
- SymNameRange(Main.range("expansion2")),
- SymRange(Main.range("expansion2parens")),
- Children(AllOf(WithName("Test"), WithDetail("class"),
- SymNameRange(Main.range("expansion2"))))),
- AllOf(WithName("FF3"), WithDetail("()"),
- SymRange(Main.range("fullDef")),
- Children(AllOf(WithName("waldo"), WithDetail("void ()"),
- SymRange(Main.range("fullDef")))))));
+ AllOf(withName("FF"), withDetail("(abc)"),
+ children(AllOf(withName("abc_Test"), withDetail("class"),
+ symNameRange(Main.range("expansion1"))))),
+ AllOf(withName("FF2"), withDetail("()"),
+ symNameRange(Main.range("expansion2")),
+ symRange(Main.range("expansion2parens")),
+ children(AllOf(withName("Test"), withDetail("class"),
+ symNameRange(Main.range("expansion2"))))),
+ AllOf(withName("FF3"), withDetail("()"),
+ symRange(Main.range("fullDef")),
+ children(AllOf(withName("waldo"), withDetail("void ()"),
+ symRange(Main.range("fullDef")))))));
}
TEST(DocumentSymbols, FuncTemplates) {
@@ -783,9 +783,9 @@ TEST(DocumentSymbols, FuncTemplates) {
TU.Code = Source.code().str();
// Make sure we only see the template declaration, not instantiations.
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(AllOf(WithName("foo"), WithDetail("template T ()")),
- AllOf(WithName("x"), WithDetail("int")),
- AllOf(WithName("y"), WithDetail("double"))));
+ ElementsAre(AllOf(withName("foo"), withDetail("template T ()")),
+ AllOf(withName("x"), withDetail("int")),
+ AllOf(withName("y"), withDetail("double"))));
}
TEST(DocumentSymbols, UsingDirectives) {
@@ -802,9 +802,9 @@ TEST(DocumentSymbols, UsingDirectives) {
)cpp");
TU.Code = Source.code().str();
EXPECT_THAT(getSymbols(TU.build()),
- ElementsAre(WithName("ns"), WithName("ns_alias"),
- WithName("using namespace ::ns"),
- WithName("using namespace ns_alias")));
+ ElementsAre(withName("ns"), withName("ns_alias"),
+ withName("using namespace ::ns"),
+ withName("using namespace ns_alias")));
}
TEST(DocumentSymbols, TempSpecs) {
@@ -818,14 +818,14 @@ TEST(DocumentSymbols, TempSpecs) {
// Foo is higher ranked because of exact name match.
EXPECT_THAT(getSymbols(TU.build()),
UnorderedElementsAre(
- AllOf(WithName("Foo"), WithKind(SymbolKind::Class),
- WithDetail("template class")),
- AllOf(WithName("Foo<int, T>"), WithKind(SymbolKind::Class),
- WithDetail("template class")),
- AllOf(WithName("Foo<bool, int>"), WithKind(SymbolKind::Class),
- WithDetail("class")),
- AllOf(WithName("Foo<bool, int, 3>"),
- WithKind(SymbolKind::Class), WithDetail("class"))));
+ AllOf(withName("Foo"), withKind(SymbolKind::Class),
+ withDetail("template class")),
+ AllOf(withName("Foo<int, T>"), withKind(SymbolKind::Class),
+ withDetail("template class")),
+ AllOf(withName("Foo<bool, int>"), withKind(SymbolKind::Class),
+ withDetail("class")),
+ AllOf(withName("Foo<bool, int, 3>"),
+ withKind(SymbolKind::Class), withDetail("class"))));
}
TEST(DocumentSymbols, Qualifiers) {
@@ -855,10 +855,10 @@ TEST(DocumentSymbols, Qualifiers) {
// All the qualifiers should be preserved exactly as written.
EXPECT_THAT(getSymbols(TU.build()),
UnorderedElementsAre(
- WithName("foo"), WithName("foo::bar::Cls"),
- WithName("foo::bar::func1"), WithName("::foo::bar::func2"),
- WithName("using namespace foo"), WithName("bar::func3"),
- WithName("alias"), WithName("::alias::func4")));
+ withName("foo"), withName("foo::bar::Cls"),
+ withName("foo::bar::func1"), withName("::foo::bar::func2"),
+ withName("using namespace foo"), withName("bar::func3"),
+ withName("alias"), withName("::alias::func4")));
}
TEST(DocumentSymbols, QualifiersWithTemplateArgs) {
@@ -887,14 +887,14 @@ TEST(DocumentSymbols, QualifiersWithTemplateArgs) {
)cpp";
EXPECT_THAT(getSymbols(TU.build()),
UnorderedElementsAre(
- AllOf(WithName("Foo"), WithDetail("template class")),
- AllOf(WithName("Foo<int, double>"), WithDetail("class")),
- AllOf(WithName("int_type"), WithDetail("type alias")),
- AllOf(WithName("Foo<int_type, double>::method1"),
- WithDetail("int ()")),
- AllOf(WithName("Foo<int>::method2"), WithDetail("int ()")),
- AllOf(WithName("Foo_type"), WithDetail("type alias")),
- AllOf(WithName("Foo_type::method3"), WithDetail("int ()"))));
+ AllOf(withName("Foo"), withDetail("template class")),
+ AllOf(withName("Foo<int, double>"), withDetail("class")),
+ AllOf(withName("int_type"), withDetail("type alias")),
+ AllOf(withName("Foo<int_type, double>::method1"),
+ withDetail("int ()")),
+ AllOf(withName("Foo<int>::method2"), withDetail("int ()")),
+ AllOf(withName("Foo_type"), withDetail("type alias")),
+ AllOf(withName("Foo_type::method3"), withDetail("int ()"))));
}
TEST(DocumentSymbolsTest, Ranges) {
@@ -932,39 +932,39 @@ TEST(DocumentSymbolsTest, Ranges) {
EXPECT_THAT(
getSymbols(TU.build()),
UnorderedElementsAre(
- AllOf(WithName("foo"), WithKind(SymbolKind::Function),
- WithDetail("int (bool)"), SymRange(Main.range("foo"))),
- AllOf(WithName("GLOBAL_VARIABLE"), WithKind(SymbolKind::Variable),
- WithDetail("char"), SymRange(Main.range("variable"))),
+ AllOf(withName("foo"), withKind(SymbolKind::Function),
+ withDetail("int (bool)"), symRange(Main.range("foo"))),
+ AllOf(withName("GLOBAL_VARIABLE"), withKind(SymbolKind::Variable),
+ withDetail("char"), symRange(Main.range("variable"))),
AllOf(
- WithName("ns"), WithKind(SymbolKind::Namespace),
- SymRange(Main.range("ns")),
- Children(AllOf(
- WithName("Bar"), WithKind(SymbolKind::Class),
- WithDetail("class"), SymRange(Main.range("bar")),
- Children(
- AllOf(WithName("Bar"), WithKind(SymbolKind::Constructor),
- WithDetail("()"), SymRange(Main.range("ctor"))),
- AllOf(WithName("~Bar"), WithKind(SymbolKind::Constructor),
- WithDetail(""), SymRange(Main.range("dtor"))),
- AllOf(WithName("Baz"), WithKind(SymbolKind::Field),
- WithDetail("unsigned int"),
- SymRange(Main.range("field"))),
- AllOf(WithName("getBaz"), WithKind(SymbolKind::Method),
- WithDetail("unsigned int ()"),
- SymRange(Main.range("getbaz"))))))),
- AllOf(WithName("ForwardClassDecl"), WithKind(SymbolKind::Class),
- WithDetail("class"), SymRange(Main.range("forwardclass"))),
- AllOf(WithName("StructDefinition"), WithKind(SymbolKind::Struct),
- WithDetail("struct"), SymRange(Main.range("struct")),
- Children(AllOf(WithName("Pointer"), WithKind(SymbolKind::Field),
- WithDetail("int *"),
- SymRange(Main.range("structfield"))))),
- AllOf(WithName("StructDeclaration"), WithKind(SymbolKind::Struct),
- WithDetail("struct"), SymRange(Main.range("forwardstruct"))),
- AllOf(WithName("forwardFunctionDecl"), WithKind(SymbolKind::Function),
- WithDetail("void (int)"),
- SymRange(Main.range("forwardfunc")))));
+ withName("ns"), withKind(SymbolKind::Namespace),
+ symRange(Main.range("ns")),
+ children(AllOf(
+ withName("Bar"), withKind(SymbolKind::Class),
+ withDetail("class"), symRange(Main.range("bar")),
+ children(
+ AllOf(withName("Bar"), withKind(SymbolKind::Constructor),
+ withDetail("()"), symRange(Main.range("ctor"))),
+ AllOf(withName("~Bar"), withKind(SymbolKind::Constructor),
+ withDetail(""), symRange(Main.range("dtor"))),
+ AllOf(withName("Baz"), withKind(SymbolKind::Field),
+ withDetail("unsigned int"),
+ symRange(Main.range("field"))),
+ AllOf(withName("getBaz"), withKind(SymbolKind::Method),
+ withDetail("unsigned int ()"),
+ symRange(Main.range("getbaz"))))))),
+ AllOf(withName("ForwardClassDecl"), withKind(SymbolKind::Class),
+ withDetail("class"), symRange(Main.range("forwardclass"))),
+ AllOf(withName("StructDefinition"), withKind(SymbolKind::Struct),
+ withDetail("struct"), symRange(Main.range("struct")),
+ children(AllOf(withName("Pointer"), withKind(SymbolKind::Field),
+ withDetail("int *"),
+ symRange(Main.range("structfield"))))),
+ AllOf(withName("StructDeclaration"), withKind(SymbolKind::Struct),
+ withDetail("struct"), symRange(Main.range("forwardstruct"))),
+ AllOf(withName("forwardFunctionDecl"), withKind(SymbolKind::Function),
+ withDetail("void (int)"),
+ symRange(Main.range("forwardfunc")))));
}
TEST(DocumentSymbolsTest, DependentType) {
@@ -982,13 +982,13 @@ TEST(DocumentSymbolsTest, DependentType) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("plus"),
- WithDetail("template auto (T, T) -> decltype(x + y)")),
- AllOf(WithName("Pair"), WithDetail("template class")),
- AllOf(WithName("Context"), WithDetail("template struct"),
- Children(AllOf(
- WithName("Pair<type-parameter-0-0, type-parameter-0-1>"),
- WithDetail("<dependent type>"))))));
+ AllOf(withName("plus"),
+ withDetail("template auto (T, T) -> decltype(x + y)")),
+ AllOf(withName("Pair"), withDetail("template class")),
+ AllOf(withName("Context"), withDetail("template struct"),
+ children(AllOf(
+ withName("Pair<type-parameter-0-0, type-parameter-0-1>"),
+ withDetail("<dependent type>"))))));
}
TEST(DocumentSymbolsTest, ObjCCategoriesAndClassExtensions) {
@@ -1013,18 +1013,18 @@ TEST(DocumentSymbolsTest, ObjCCategoriesAndClassExtensions) {
EXPECT_THAT(
getSymbols(TU.build()),
ElementsAre(
- AllOf(WithName("Cat"), SymRange(Main.range("Cat")),
- Children(AllOf(WithName("+sharedCat"),
- WithKind(SymbolKind::Method)))),
- AllOf(WithName("Cat(Sneaky)"), SymRange(Main.range("SneakyCat")),
- Children(
- AllOf(WithName("-sneak:"), WithKind(SymbolKind::Method)))),
+ AllOf(withName("Cat"), symRange(Main.range("Cat")),
+ children(AllOf(withName("+sharedCat"),
+ withKind(SymbolKind::Method)))),
+ AllOf(withName("Cat(Sneaky)"), symRange(Main.range("SneakyCat")),
+ children(
+ AllOf(withName("-sneak:"), withKind(SymbolKind::Method)))),
AllOf(
- WithName("Cat()"), SymRange(Main.range("MeowCat")),
- Children(AllOf(WithName("-meow"), WithKind(SymbolKind::Method)))),
- AllOf(WithName("Cat()"), SymRange(Main.range("PurCat")),
- Children(
- AllOf(WithName("-pur"), WithKind(SymbolKind::Method))))));
+ withName("Cat()"), symRange(Main.range("MeowCat")),
+ children(AllOf(withName("-meow"), withKind(SymbolKind::Method)))),
+ AllOf(withName("Cat()"), symRange(Main.range("PurCat")),
+ children(
+ AllOf(withName("-pur"), withKind(SymbolKind::Method))))));
}
TEST(DocumentSymbolsTest, PragmaMarkGroups) {
@@ -1059,21 +1059,21 @@ TEST(DocumentSymbolsTest, PragmaMarkGroups) {
EXPECT_THAT(
getSymbols(TU.build()),
UnorderedElementsAre(
- AllOf(WithName("Dog"), SymRange(Main.range("DogDef"))),
- AllOf(WithName("Dog"), SymRange(Main.range("DogImpl")),
- Children(AllOf(WithName("+sharedDoggo"),
- WithKind(SymbolKind::Method)),
- AllOf(WithName("Overrides"),
- SymRange(Main.range("Overrides")),
- Children(AllOf(WithName("-init"),
- WithKind(SymbolKind::Method)),
- AllOf(WithName("-bark"),
- WithKind(SymbolKind::Method)))),
- AllOf(WithName("Dog Specifics"),
- SymRange(Main.range("Specifics")),
- Children(AllOf(WithName("-isAGoodBoy"),
- WithKind(SymbolKind::Method)))))),
- AllOf(WithName("End"), SymRange(Main.range("End")))));
+ AllOf(withName("Dog"), symRange(Main.range("DogDef"))),
+ AllOf(withName("Dog"), symRange(Main.range("DogImpl")),
+ children(AllOf(withName("+sharedDoggo"),
+ withKind(SymbolKind::Method)),
+ AllOf(withName("Overrides"),
+ symRange(Main.range("Overrides")),
+ children(AllOf(withName("-init"),
+ withKind(SymbolKind::Method)),
+ AllOf(withName("-bark"),
+ withKind(SymbolKind::Method)))),
+ AllOf(withName("Dog Specifics"),
+ symRange(Main.range("Specifics")),
+ children(AllOf(withName("-isAGoodBoy"),
+ withKind(SymbolKind::Method)))))),
+ AllOf(withName("End"), symRange(Main.range("End")))));
}
TEST(DocumentSymbolsTest, PragmaMarkGroupsNesting) {
@@ -1093,13 +1093,13 @@ TEST(DocumentSymbolsTest, PragmaMarkGroupsNesting) {
EXPECT_THAT(
getSymbols(TU.build()),
UnorderedElementsAre(AllOf(
- WithName("Foo"),
- Children(AllOf(WithName("Foo"),
- Children(AllOf(WithName("Bar"),
- Children(AllOf(WithName("bar"),
- Children(WithName(
+ withName("Foo"),
+ children(AllOf(withName("Foo"),
+ children(AllOf(withName("Bar"),
+ children(AllOf(withName("bar"),
+ children(withName(
"NotTopDecl"))))))),
- WithName("bar")))));
+ withName("bar")))));
}
TEST(DocumentSymbolsTest, PragmaMarkGroupsNoNesting) {
@@ -1116,9 +1116,9 @@ TEST(DocumentSymbolsTest, PragmaMarkGroupsNoNesting) {
)cpp");
TU.Code = Main.code().str();
EXPECT_THAT(getSymbols(TU.build()),
- UnorderedElementsAre(WithName("Helpers"), WithName("helpA"),
- WithName("(unnamed group)"),
- WithName("Core"), WithName("coreMethod")));
+ UnorderedElementsAre(withName("Helpers"), withName("helpA"),
+ withName("(unnamed group)"),
+ withName("Core"), withName("coreMethod")));
}
} // namespace
diff --git a/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp b/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp
index fbfb080062c1..bebf59ed822c 100644
--- a/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp
+++ b/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp
@@ -74,7 +74,7 @@ TEST(HeaderSourceSwitchTest, FileHeuristic) {
EXPECT_FALSE(PathResult.hasValue());
}
-MATCHER_P(DeclNamed, Name, "") {
+MATCHER_P(declNamed, Name, "") {
if (const NamedDecl *ND = dyn_cast<NamedDecl>(arg))
if (ND->getQualifiedNameAsString() == Name)
return true;
@@ -106,8 +106,8 @@ TEST(HeaderSourceSwitchTest, GetLocalDecls) {
auto AST = TU.build();
EXPECT_THAT(getIndexableLocalDecls(AST),
testing::UnorderedElementsAre(
- DeclNamed("MainF1"), DeclNamed("Foo"), DeclNamed("ns::Foo"),
- DeclNamed("ns::Foo::method"), DeclNamed("ns::Foo::field")));
+ declNamed("MainF1"), declNamed("Foo"), declNamed("ns::Foo"),
+ declNamed("ns::Foo::method"), declNamed("ns::Foo::field")));
}
TEST(HeaderSourceSwitchTest, FromHeaderToSource) {
diff --git a/clang-tools-extra/clangd/unittests/HeadersTests.cpp b/clang-tools-extra/clangd/unittests/HeadersTests.cpp
index 738a2fc18b2d..d7940b997083 100644
--- a/clang-tools-extra/clangd/unittests/HeadersTests.cpp
+++ b/clang-tools-extra/clangd/unittests/HeadersTests.cpp
@@ -139,11 +139,11 @@ class HeadersTest : public ::testing::Test {
std::unique_ptr<CompilerInstance> Clang;
};
-MATCHER_P(Written, Name, "") { return arg.Written == Name; }
-MATCHER_P(Resolved, Name, "") { return arg.Resolved == Name; }
-MATCHER_P(IncludeLine, N, "") { return arg.HashLine == N; }
-MATCHER_P(Directive, D, "") { return arg.Directive == D; }
-MATCHER_P(HasPragmaKeep, H, "") { return arg.BehindPragmaKeep == H; }
+MATCHER_P(written, Name, "") { return arg.Written == Name; }
+MATCHER_P(resolved, Name, "") { return arg.Resolved == Name; }
+MATCHER_P(includeLine, N, "") { return arg.HashLine == N; }
+MATCHER_P(directive, D, "") { return arg.Directive == D; }
+MATCHER_P(hasPragmaKeep, H, "") { return arg.BehindPragmaKeep == H; }
MATCHER_P2(Distance, File, D, "") {
if (arg.getFirst() != File)
@@ -163,7 +163,7 @@ TEST_F(HeadersTest, CollectRewrittenAndResolved) {
auto Includes = collectIncludes();
EXPECT_THAT(Includes.MainFileIncludes,
UnorderedElementsAre(
- AllOf(Written("\"sub/bar.h\""), Resolved(BarHeader))));
+ AllOf(written("\"sub/bar.h\""), resolved(BarHeader))));
EXPECT_THAT(Includes.includeDepth(getID(MainFile, Includes)),
UnorderedElementsAre(Distance(getID(MainFile, Includes), 0u),
Distance(getID(BarHeader, Includes), 1u)));
@@ -182,7 +182,7 @@ TEST_F(HeadersTest, OnlyCollectInclusionsInMain) {
auto Includes = collectIncludes();
EXPECT_THAT(
Includes.MainFileIncludes,
- UnorderedElementsAre(AllOf(Written("\"bar.h\""), Resolved(BarHeader))));
+ UnorderedElementsAre(AllOf(written("\"bar.h\""), resolved(BarHeader))));
EXPECT_THAT(Includes.includeDepth(getID(MainFile, Includes)),
UnorderedElementsAre(Distance(getID(MainFile, Includes), 0u),
Distance(getID(BarHeader, Includes), 1u),
@@ -206,7 +206,7 @@ TEST_F(HeadersTest, PreambleIncludesPresentOnce) {
)cpp");
TU.HeaderFilename = "a.h"; // suppress "not found".
EXPECT_THAT(TU.build().getIncludeStructure().MainFileIncludes,
- ElementsAre(IncludeLine(1), IncludeLine(3), IncludeLine(5)));
+ ElementsAre(includeLine(1), includeLine(3), includeLine(5)));
}
TEST_F(HeadersTest, UnResolvedInclusion) {
@@ -215,7 +215,7 @@ TEST_F(HeadersTest, UnResolvedInclusion) {
)cpp";
EXPECT_THAT(collectIncludes().MainFileIncludes,
- UnorderedElementsAre(AllOf(Written("\"foo.h\""), Resolved(""))));
+ UnorderedElementsAre(AllOf(written("\"foo.h\""), resolved(""))));
EXPECT_THAT(collectIncludes().IncludeChildren, IsEmpty());
}
@@ -254,9 +254,9 @@ TEST_F(HeadersTest, IncludeDirective) {
// ms-compatibility changes meaning of #import, make sure it is turned off.
CDB.ExtraClangFlags.push_back("-fno-ms-compatibility");
EXPECT_THAT(collectIncludes().MainFileIncludes,
- UnorderedElementsAre(Directive(tok::pp_include),
- Directive(tok::pp_import),
- Directive(tok::pp_include_next)));
+ UnorderedElementsAre(directive(tok::pp_include),
+ directive(tok::pp_import),
+ directive(tok::pp_include_next)));
}
TEST_F(HeadersTest, IWYUPragmaKeep) {
@@ -267,8 +267,8 @@ TEST_F(HeadersTest, IWYUPragmaKeep) {
EXPECT_THAT(
collectIncludes().MainFileIncludes,
- UnorderedElementsAre(AllOf(Written("\"foo.h\""), HasPragmaKeep(false)),
- AllOf(Written("\"bar.h\""), HasPragmaKeep(true))));
+ UnorderedElementsAre(AllOf(written("\"foo.h\""), hasPragmaKeep(false)),
+ AllOf(written("\"bar.h\""), hasPragmaKeep(true))));
}
TEST_F(HeadersTest, InsertInclude) {
@@ -369,12 +369,12 @@ TEST_F(HeadersTest, PresumedLocations) {
// Including through non-builtin file has no effects.
FS.Files[MainFile] = "#include \"__preamble_patch__.h\"\n\n";
EXPECT_THAT(collectIncludes().MainFileIncludes,
- Not(Contains(Written("<a.h>"))));
+ Not(Contains(written("<a.h>"))));
// Now include through built-in file.
CDB.ExtraClangFlags = {"-include", testPath(HeaderFile)};
EXPECT_THAT(collectIncludes().MainFileIncludes,
- Contains(AllOf(IncludeLine(2), Written("<a.h>"))));
+ Contains(AllOf(includeLine(2), written("<a.h>"))));
}
TEST_F(HeadersTest, SelfContainedHeaders) {
@@ -445,20 +445,20 @@ TEST(StdlibTest, Recognizer) {
)cpp");
auto AST = TU.build();
- auto &vector_nonstd = findDecl(AST, "vector");
- auto *vec =
+ auto &VectorNonstd = findDecl(AST, "vector");
+ auto *Vec =
cast<VarDecl>(findDecl(AST, "vec")).getType()->getAsCXXRecordDecl();
- auto *nest =
+ auto *Nest =
cast<VarDecl>(findDecl(AST, "nest")).getType()->getAsCXXRecordDecl();
- auto *sec =
+ auto *Sec =
cast<VarDecl>(findDecl(AST, "sec")).getType()->getAsCXXRecordDecl();
- stdlib::Recognizer recognizer;
+ stdlib::Recognizer Recognizer;
- EXPECT_EQ(recognizer(&vector_nonstd), llvm::None);
- EXPECT_EQ(recognizer(vec), stdlib::Symbol::named("std::", "vector"));
- EXPECT_EQ(recognizer(nest), stdlib::Symbol::named("std::", "vector"));
- EXPECT_EQ(recognizer(sec), llvm::None);
+ EXPECT_EQ(Recognizer(&VectorNonstd), llvm::None);
+ EXPECT_EQ(Recognizer(Vec), stdlib::Symbol::named("std::", "vector"));
+ EXPECT_EQ(Recognizer(Nest), stdlib::Symbol::named("std::", "vector"));
+ EXPECT_EQ(Recognizer(Sec), llvm::None);
}
} // namespace
diff --git a/clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp b/clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp
index b7792ca6f90d..ab367fca66e1 100644
--- a/clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp
+++ b/clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp
@@ -272,7 +272,7 @@ TEST(IncludeCleaner, Stdlib) {
}
}
-MATCHER_P(WrittenInclusion, Written, "") {
+MATCHER_P(writtenInclusion, Written, "") {
if (arg.Written != Written)
*result_listener << arg.Written;
return arg.Written == Written;
@@ -302,7 +302,7 @@ TEST(IncludeCleaner, StdlibUnused) {
auto AST = TU.build();
auto Unused = computeUnusedIncludes(AST);
- EXPECT_THAT(Unused, ElementsAre(Pointee(WrittenInclusion("<queue>"))));
+ EXPECT_THAT(Unused, ElementsAre(Pointee(writtenInclusion("<queue>"))));
}
TEST(IncludeCleaner, GetUnusedHeaders) {
diff --git a/clang-tools-extra/clangd/unittests/IndexActionTests.cpp b/clang-tools-extra/clangd/unittests/IndexActionTests.cpp
index 99317f4de53d..babdd93bcecd 100644
--- a/clang-tools-extra/clangd/unittests/IndexActionTests.cpp
+++ b/clang-tools-extra/clangd/unittests/IndexActionTests.cpp
@@ -27,22 +27,22 @@ using ::testing::UnorderedPointwise;
std::string toUri(llvm::StringRef Path) { return URI::create(Path).toString(); }
-MATCHER(IsTU, "") { return arg.Flags & IncludeGraphNode::SourceFlag::IsTU; }
+MATCHER(isTU, "") { return arg.Flags & IncludeGraphNode::SourceFlag::IsTU; }
-MATCHER_P(HasDigest, Digest, "") { return arg.Digest == Digest; }
+MATCHER_P(hasDigest, Digest, "") { return arg.Digest == Digest; }
-MATCHER_P(HasName, Name, "") { return arg.Name == Name; }
+MATCHER_P(hasName, Name, "") { return arg.Name == Name; }
-MATCHER(HasSameURI, "") {
+MATCHER(hasSameURI, "") {
llvm::StringRef URI = ::testing::get<0>(arg);
const std::string &Path = ::testing::get<1>(arg);
return toUri(Path) == URI;
}
::testing::Matcher<const IncludeGraphNode &>
-IncludesAre(const std::vector<std::string> &Includes) {
+includesAre(const std::vector<std::string> &Includes) {
return ::testing::Field(&IncludeGraphNode::DirectIncludes,
- UnorderedPointwise(HasSameURI(), Includes));
+ UnorderedPointwise(hasSameURI(), Includes));
}
void checkNodesAreInitialized(const IndexFileIn &IndexFile,
@@ -127,14 +127,14 @@ TEST_F(IndexActionTest, CollectIncludeGraph) {
EXPECT_THAT(Nodes,
UnorderedElementsAre(
Pair(toUri(MainFilePath),
- AllOf(IsTU(), IncludesAre({Level1HeaderPath}),
- HasDigest(digest(MainCode)))),
+ AllOf(isTU(), includesAre({Level1HeaderPath}),
+ hasDigest(digest(MainCode)))),
Pair(toUri(Level1HeaderPath),
- AllOf(Not(IsTU()), IncludesAre({Level2HeaderPath}),
- HasDigest(digest(Level1HeaderCode)))),
+ AllOf(Not(isTU()), includesAre({Level2HeaderPath}),
+ hasDigest(digest(Level1HeaderCode)))),
Pair(toUri(Level2HeaderPath),
- AllOf(Not(IsTU()), IncludesAre({}),
- HasDigest(digest(Level2HeaderCode))))));
+ AllOf(Not(isTU()), includesAre({}),
+ hasDigest(digest(Level2HeaderCode))))));
}
TEST_F(IndexActionTest, IncludeGraphSelfInclude) {
@@ -156,10 +156,10 @@ TEST_F(IndexActionTest, IncludeGraphSelfInclude) {
EXPECT_THAT(
Nodes,
UnorderedElementsAre(
- Pair(toUri(MainFilePath), AllOf(IsTU(), IncludesAre({HeaderPath}),
- HasDigest(digest(MainCode)))),
- Pair(toUri(HeaderPath), AllOf(Not(IsTU()), IncludesAre({HeaderPath}),
- HasDigest(digest(HeaderCode))))));
+ Pair(toUri(MainFilePath), AllOf(isTU(), includesAre({HeaderPath}),
+ hasDigest(digest(MainCode)))),
+ Pair(toUri(HeaderPath), AllOf(Not(isTU()), includesAre({HeaderPath}),
+ hasDigest(digest(HeaderCode))))));
}
TEST_F(IndexActionTest, IncludeGraphSkippedFile) {
@@ -191,14 +191,14 @@ TEST_F(IndexActionTest, IncludeGraphSkippedFile) {
EXPECT_THAT(
Nodes, UnorderedElementsAre(
Pair(toUri(MainFilePath),
- AllOf(IsTU(), IncludesAre({HeaderPath, CommonHeaderPath}),
- HasDigest(digest(MainCode)))),
+ AllOf(isTU(), includesAre({HeaderPath, CommonHeaderPath}),
+ hasDigest(digest(MainCode)))),
Pair(toUri(HeaderPath),
- AllOf(Not(IsTU()), IncludesAre({CommonHeaderPath}),
- HasDigest(digest(HeaderCode)))),
+ AllOf(Not(isTU()), includesAre({CommonHeaderPath}),
+ hasDigest(digest(HeaderCode)))),
Pair(toUri(CommonHeaderPath),
- AllOf(Not(IsTU()), IncludesAre({}),
- HasDigest(digest(CommonHeaderCode))))));
+ AllOf(Not(isTU()), includesAre({}),
+ hasDigest(digest(CommonHeaderCode))))));
}
TEST_F(IndexActionTest, IncludeGraphDynamicInclude) {
@@ -224,10 +224,10 @@ TEST_F(IndexActionTest, IncludeGraphDynamicInclude) {
Nodes,
UnorderedElementsAre(
Pair(toUri(MainFilePath),
- AllOf(IsTU(), IncludesAre({MainFilePath, HeaderPath}),
- HasDigest(digest(MainCode)))),
- Pair(toUri(HeaderPath), AllOf(Not(IsTU()), IncludesAre({}),
- HasDigest(digest(HeaderCode))))));
+ AllOf(isTU(), includesAre({MainFilePath, HeaderPath}),
+ hasDigest(digest(MainCode)))),
+ Pair(toUri(HeaderPath), AllOf(Not(isTU()), includesAre({}),
+ hasDigest(digest(HeaderCode))))));
}
TEST_F(IndexActionTest, NoWarnings) {
@@ -248,7 +248,7 @@ TEST_F(IndexActionTest, NoWarnings) {
MainFilePath, {"-ferror-limit=1", "-Wparentheses", "-Werror"});
ASSERT_TRUE(IndexFile.Sources);
ASSERT_NE(0u, IndexFile.Sources->size());
- EXPECT_THAT(*IndexFile.Symbols, ElementsAre(HasName("foo"), HasName("bar")));
+ EXPECT_THAT(*IndexFile.Symbols, ElementsAre(hasName("foo"), hasName("bar")));
}
TEST_F(IndexActionTest, SkipFiles) {
@@ -274,8 +274,8 @@ TEST_F(IndexActionTest, SkipFiles) {
};
IndexFileIn IndexFile = runIndexingAction(MainFilePath, {"-std=c++14"});
EXPECT_THAT(*IndexFile.Symbols,
- UnorderedElementsAre(HasName("S"), HasName("s"), HasName("f1"),
- HasName("unskippable1")));
+ UnorderedElementsAre(hasName("S"), hasName("s"), hasName("f1"),
+ hasName("unskippable1")));
for (const auto &Pair : *IndexFile.Refs)
for (const auto &Ref : Pair.second)
EXPECT_THAT(Ref.Location.FileURI, EndsWith("good.h"));
@@ -307,9 +307,9 @@ TEST_F(IndexActionTest, SkipNestedSymbols) {
}
})cpp");
IndexFileIn IndexFile = runIndexingAction(MainFilePath, {"-std=c++14"});
- EXPECT_THAT(*IndexFile.Symbols, testing::Contains(HasName("foo")));
- EXPECT_THAT(*IndexFile.Symbols, testing::Contains(HasName("Bar")));
- EXPECT_THAT(*IndexFile.Symbols, Not(testing::Contains(HasName("Baz"))));
+ EXPECT_THAT(*IndexFile.Symbols, testing::Contains(hasName("foo")));
+ EXPECT_THAT(*IndexFile.Symbols, testing::Contains(hasName("Bar")));
+ EXPECT_THAT(*IndexFile.Symbols, Not(testing::Contains(hasName("Baz"))));
}
} // namespace
} // namespace clangd
diff --git a/clang-tools-extra/clangd/unittests/IndexTests.cpp b/clang-tools-extra/clangd/unittests/IndexTests.cpp
index 0ba157419bf8..1fff45421115 100644
--- a/clang-tools-extra/clangd/unittests/IndexTests.cpp
+++ b/clang-tools-extra/clangd/unittests/IndexTests.cpp
@@ -32,14 +32,14 @@ namespace clang {
namespace clangd {
namespace {
-MATCHER_P(Named, N, "") { return arg.Name == N; }
-MATCHER_P(RefRange, Range, "") {
+MATCHER_P(named, N, "") { return arg.Name == N; }
+MATCHER_P(refRange, Range, "") {
return std::make_tuple(arg.Location.Start.line(), arg.Location.Start.column(),
arg.Location.End.line(), arg.Location.End.column()) ==
std::make_tuple(Range.start.line, Range.start.character,
Range.end.line, Range.end.character);
}
-MATCHER_P(FileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
+MATCHER_P(fileURI, F, "") { return StringRef(arg.Location.FileURI) == F; }
TEST(SymbolLocation, Position) {
using Position = SymbolLocation::Position;
@@ -68,13 +68,13 @@ TEST(SymbolSlab, FindAndIterate) {
B.insert(symbol("X"));
EXPECT_EQ(nullptr, B.find(SymbolID("W")));
for (const char *Sym : {"X", "Y", "Z"})
- EXPECT_THAT(B.find(SymbolID(Sym)), Pointee(Named(Sym)));
+ EXPECT_THAT(B.find(SymbolID(Sym)), Pointee(named(Sym)));
SymbolSlab S = std::move(B).build();
- EXPECT_THAT(S, UnorderedElementsAre(Named("X"), Named("Y"), Named("Z")));
+ EXPECT_THAT(S, UnorderedElementsAre(named("X"), named("Y"), named("Z")));
EXPECT_EQ(S.end(), S.find(SymbolID("W")));
for (const char *Sym : {"X", "Y", "Z"})
- EXPECT_THAT(*S.find(SymbolID(Sym)), Named(Sym));
+ EXPECT_THAT(*S.find(SymbolID(Sym)), named(Sym));
}
TEST(RelationSlab, Lookup) {
@@ -488,10 +488,10 @@ TEST(MergeIndexTest, Refs) {
EXPECT_THAT(
std::move(Results).build(),
ElementsAre(Pair(
- _, UnorderedElementsAre(AllOf(RefRange(Test1Code.range("Foo")),
- FileURI("unittest:///test.cc")),
- AllOf(RefRange(Test2Code.range("Foo")),
- FileURI("unittest:///test2.cc"))))));
+ _, UnorderedElementsAre(AllOf(refRange(Test1Code.range("Foo")),
+ fileURI("unittest:///test.cc")),
+ AllOf(refRange(Test2Code.range("Foo")),
+ fileURI("unittest:///test2.cc"))))));
Request.Limit = 1;
RefSlab::Builder Results2;
@@ -510,8 +510,8 @@ TEST(MergeIndexTest, Refs) {
Merge.refs(Request, [&](const Ref &O) { Results3.insert(Foo.ID, O); }));
EXPECT_THAT(std::move(Results3).build(),
ElementsAre(Pair(_, UnorderedElementsAre(AllOf(
- RefRange(Test2Code.range("Foo")),
- FileURI("unittest:///test2.cc"))))));
+ refRange(Test2Code.range("Foo")),
+ fileURI("unittest:///test2.cc"))))));
}
TEST(MergeIndexTest, IndexedFiles) {
diff --git a/clang-tools-extra/clangd/unittests/JSONTransportTests.cpp b/clang-tools-extra/clangd/unittests/JSONTransportTests.cpp
index 76b7a97a3d61..67c97efbb291 100644
--- a/clang-tools-extra/clangd/unittests/JSONTransportTests.cpp
+++ b/clang-tools-extra/clangd/unittests/JSONTransportTests.cpp
@@ -40,7 +40,7 @@ class JSONTransportTest : public ::testing::Test {
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 @@ Notification exit: null
"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 @@ Notification exit: null
"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 @@ TEST_F(JSONTransportTest, EndOfFile) {
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/ParsedASTTests.cpp b/clang-tools-extra/clangd/unittests/ParsedASTTests.cpp
index eabd174823cc..f5ea5ee61c24 100644
--- a/clang-tools-extra/clangd/unittests/ParsedASTTests.cpp
+++ b/clang-tools-extra/clangd/unittests/ParsedASTTests.cpp
@@ -50,7 +50,7 @@ using ::testing::ElementsAreArray;
using ::testing::IsEmpty;
using ::testing::UnorderedElementsAreArray;
-MATCHER_P(DeclNamed, Name, "") {
+MATCHER_P(declNamed, Name, "") {
if (NamedDecl *ND = dyn_cast<NamedDecl>(arg))
if (ND->getName() == Name)
return true;
@@ -61,7 +61,7 @@ MATCHER_P(DeclNamed, Name, "") {
return false;
}
-MATCHER_P(DeclKind, Kind, "") {
+MATCHER_P(declKind, Kind, "") {
if (NamedDecl *ND = dyn_cast<NamedDecl>(arg))
if (ND->getDeclKindName() == llvm::StringRef(Kind))
return true;
@@ -74,7 +74,7 @@ MATCHER_P(DeclKind, Kind, "") {
// Matches if the Decl has template args equal to ArgName. If the decl is a
// NamedDecl and ArgName is an empty string it also matches.
-MATCHER_P(WithTemplateArgs, ArgName, "") {
+MATCHER_P(withTemplateArgs, ArgName, "") {
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(arg)) {
if (const auto *Args = FD->getTemplateSpecializationArgs()) {
std::string SpecializationArgs;
@@ -97,13 +97,13 @@ MATCHER_P(WithTemplateArgs, ArgName, "") {
return false;
}
-MATCHER_P(RangeIs, R, "") {
+MATCHER_P(rangeIs, R, "") {
return arg.beginOffset() == R.Begin && arg.endOffset() == R.End;
}
-MATCHER_P(PragmaTrivia, P, "") { return arg.Trivia == P; }
+MATCHER_P(pragmaTrivia, P, "") { return arg.Trivia == P; }
-MATCHER(EqInc, "") {
+MATCHER(eqInc, "") {
Inclusion Actual = testing::get<0>(arg);
Inclusion Expected = testing::get<1>(arg);
return std::tie(Actual.HashLine, Actual.Written) ==
@@ -123,8 +123,8 @@ TEST(ParsedASTTest, TopLevelDecls) {
auto AST = TU.build();
EXPECT_THAT(AST.getLocalTopLevelDecls(),
testing::UnorderedElementsAreArray(
- {AllOf(DeclNamed("main"), DeclKind("Function")),
- AllOf(DeclNamed("X"), DeclKind("VarTemplate"))}));
+ {AllOf(declNamed("main"), declKind("Function")),
+ AllOf(declNamed("X"), declKind("VarTemplate"))}));
}
TEST(ParsedASTTest, DoesNotGetIncludedTopDecls) {
@@ -144,7 +144,7 @@ TEST(ParsedASTTest, DoesNotGetIncludedTopDecls) {
}
)cpp";
auto AST = TU.build();
- EXPECT_THAT(AST.getLocalTopLevelDecls(), ElementsAre(DeclNamed("main")));
+ EXPECT_THAT(AST.getLocalTopLevelDecls(), ElementsAre(declNamed("main")));
}
TEST(ParsedASTTest, DoesNotGetImplicitTemplateTopDecls) {
@@ -159,7 +159,7 @@ TEST(ParsedASTTest, DoesNotGetImplicitTemplateTopDecls) {
auto AST = TU.build();
EXPECT_THAT(AST.getLocalTopLevelDecls(),
- ElementsAre(DeclNamed("f"), DeclNamed("s")));
+ ElementsAre(declNamed("f"), declNamed("s")));
}
TEST(ParsedASTTest,
@@ -193,17 +193,17 @@ TEST(ParsedASTTest,
auto AST = TU.build();
EXPECT_THAT(
AST.getLocalTopLevelDecls(),
- ElementsAreArray({AllOf(DeclNamed("f"), WithTemplateArgs("")),
- AllOf(DeclNamed("f"), WithTemplateArgs("<bool>")),
- AllOf(DeclNamed("f"), WithTemplateArgs("<double>")),
- AllOf(DeclNamed("V"), WithTemplateArgs("")),
- AllOf(DeclNamed("V"), WithTemplateArgs("<T *>")),
- AllOf(DeclNamed("V"), WithTemplateArgs("<bool>")),
- AllOf(DeclNamed("foo"), WithTemplateArgs("")),
- AllOf(DeclNamed("i"), WithTemplateArgs("")),
- AllOf(DeclNamed("d"), WithTemplateArgs("")),
- AllOf(DeclNamed("foo"), WithTemplateArgs("<T *>")),
- AllOf(DeclNamed("foo"), WithTemplateArgs("<bool>"))}));
+ ElementsAreArray({AllOf(declNamed("f"), withTemplateArgs("")),
+ AllOf(declNamed("f"), withTemplateArgs("<bool>")),
+ AllOf(declNamed("f"), withTemplateArgs("<double>")),
+ AllOf(declNamed("V"), withTemplateArgs("")),
+ AllOf(declNamed("V"), withTemplateArgs("<T *>")),
+ AllOf(declNamed("V"), withTemplateArgs("<bool>")),
+ AllOf(declNamed("foo"), withTemplateArgs("")),
+ AllOf(declNamed("i"), withTemplateArgs("")),
+ AllOf(declNamed("d"), withTemplateArgs("")),
+ AllOf(declNamed("foo"), withTemplateArgs("<T *>")),
+ AllOf(declNamed("foo"), withTemplateArgs("<bool>"))}));
}
TEST(ParsedASTTest, IgnoresDelayedTemplateParsing) {
@@ -351,7 +351,7 @@ TEST(ParsedASTTest, CollectsMainFileMacroExpansions) {
testing::UnorderedElementsAreArray(TestCase.points()));
}
-MATCHER_P(WithFileName, Inc, "") { return arg.FileName == Inc; }
+MATCHER_P(withFileName, Inc, "") { return arg.FileName == Inc; }
TEST(ParsedASTTest, ReplayPreambleForTidyCheckers) {
struct Inclusion {
@@ -447,7 +447,7 @@ TEST(ParsedASTTest, ReplayPreambleForTidyCheckers) {
EXPECT_EQ(Inc.HashOffset, HashLocs[I]);
auto IncRange = IncludeRanges[I];
- EXPECT_THAT(Inc.IncTok.range(SM), RangeIs(IncRange));
+ EXPECT_THAT(Inc.IncTok.range(SM), rangeIs(IncRange));
EXPECT_EQ(Inc.IncTok.kind(), tok::identifier);
EXPECT_EQ(Inc.IncDirective,
Code.substr(IncRange.Begin, IncRange.End - IncRange.Begin));
@@ -512,7 +512,7 @@ TEST(ParsedASTTest, PatchesAdditionalIncludes) {
// Ensure source location information is correct, including resolved paths.
EXPECT_THAT(PatchedAST->getIncludeStructure().MainFileIncludes,
testing::Pointwise(
- EqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
+ eqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
// Ensure file proximity signals are correct.
auto &SM = PatchedAST->getSourceManager();
auto &FM = SM.getFileManager();
@@ -556,7 +556,7 @@ TEST(ParsedASTTest, PatchesDeletedIncludes) {
// Ensure source location information is correct.
EXPECT_THAT(PatchedAST->getIncludeStructure().MainFileIncludes,
testing::Pointwise(
- EqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
+ eqInc(), ExpectedAST.getIncludeStructure().MainFileIncludes));
// Ensure file proximity signals are correct.
auto &SM = ExpectedAST.getSourceManager();
auto &FM = SM.getFileManager();
@@ -594,7 +594,7 @@ bool mainIsGuarded(const ParsedAST &AST) {
.isFileMultipleIncludeGuarded(MainFE);
}
-MATCHER_P(Diag, Desc, "") {
+MATCHER_P(diag, Desc, "") {
return llvm::StringRef(arg.Message).contains(Desc);
}
@@ -649,7 +649,7 @@ TEST(ParsedASTTest, HeaderGuardsSelfInclude) {
)cpp";
auto AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
TU.Code = R"cpp(
@@ -657,7 +657,7 @@ TEST(ParsedASTTest, HeaderGuardsSelfInclude) {
#include "self.h" // error-ok
)cpp";
AST = TU.build();
- EXPECT_THAT(*AST.getDiagnostics(), ElementsAre(Diag("nested too deeply")));
+ EXPECT_THAT(*AST.getDiagnostics(), ElementsAre(diag("nested too deeply")));
EXPECT_FALSE(mainIsGuarded(AST));
TU.Code = R"cpp(
@@ -696,7 +696,7 @@ TEST(ParsedASTTest, HeaderGuardsSelfInclude) {
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_TRUE(mainIsGuarded(AST));
TU.Code = R"cpp(
@@ -720,7 +720,7 @@ TEST(ParsedASTTest, HeaderGuardsSelfInclude) {
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
TU.Code = R"cpp(
@@ -732,7 +732,7 @@ TEST(ParsedASTTest, HeaderGuardsSelfInclude) {
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
TU.Code = R"cpp(
@@ -753,7 +753,7 @@ TEST(ParsedASTTest, HeaderGuardsSelfInclude) {
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_TRUE(mainIsGuarded(AST));
TU.Code = R"cpp(
@@ -763,7 +763,7 @@ TEST(ParsedASTTest, HeaderGuardsSelfInclude) {
)cpp";
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("recursively when building a preamble")));
+ ElementsAre(diag("recursively when building a preamble")));
EXPECT_TRUE(mainIsGuarded(AST));
}
@@ -814,14 +814,14 @@ TEST(ParsedASTTest, HeaderGuardsImplIface) {
// The diagnostic is unfortunate in this case, but correct per our model.
// Ultimately the include is skipped and the code is parsed correctly though.
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("in included file: main file cannot be included "
+ ElementsAre(diag("in included file: main file cannot be included "
"recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
// Interface is pragma once guarded, same thing.
TU.AdditionalFiles = {{"iface.h", once(Interface)}};
AST = TU.build();
EXPECT_THAT(*AST.getDiagnostics(),
- ElementsAre(Diag("in included file: main file cannot be included "
+ ElementsAre(diag("in included file: main file cannot be included "
"recursively when building a preamble")));
EXPECT_FALSE(mainIsGuarded(AST));
}
@@ -842,9 +842,9 @@ TEST(ParsedASTTest, DiscoversPragmaMarks) {
)cpp";
auto AST = TU.build();
- EXPECT_THAT(AST.getMarks(), ElementsAre(PragmaTrivia(" In Preamble"),
- PragmaTrivia(" - Something Impl"),
- PragmaTrivia(" End")));
+ EXPECT_THAT(AST.getMarks(), ElementsAre(pragmaTrivia(" In Preamble"),
+ pragmaTrivia(" - Something Impl"),
+ pragmaTrivia(" End")));
}
} // namespace
diff --git a/clang-tools-extra/clangd/unittests/QualityTests.cpp b/clang-tools-extra/clangd/unittests/QualityTests.cpp
index 2992f694637d..7e519abfac8c 100644
--- a/clang-tools-extra/clangd/unittests/QualityTests.cpp
+++ b/clang-tools-extra/clangd/unittests/QualityTests.cpp
@@ -139,7 +139,7 @@ TEST(QualityTests, SymbolRelevanceSignalExtraction) {
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))
@@ -154,10 +154,10 @@ TEST(QualityTests, SymbolRelevanceSignalExtraction) {
};
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
index f27775ea2f2d..290e20a082d6 100644
--- a/clang-tools-extra/clangd/unittests/SerializationTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SerializationTests.cpp
@@ -114,8 +114,8 @@ Digest: EED8F5EAF25C453C
...
)";
-MATCHER_P(ID, I, "") { return arg.ID == cantFail(SymbolID::fromStr(I)); }
-MATCHER_P(QName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
+MATCHER_P(id, I, "") { return arg.ID == cantFail(SymbolID::fromStr(I)); }
+MATCHER_P(qName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
MATCHER_P2(IncludeHeaderWithRef, IncludeHeader, References, "") {
return (arg.IncludeHeader == IncludeHeader) && (arg.References == References);
}
@@ -134,14 +134,14 @@ TEST(SerializationTest, YAMLConversions) {
ASSERT_TRUE(bool(ParsedYAML->Symbols));
EXPECT_THAT(
*ParsedYAML->Symbols,
- UnorderedElementsAre(ID("057557CEBF6E6B2D"), ID("057557CEBF6E6B2E")));
+ UnorderedElementsAre(id("057557CEBF6E6B2D"), id("057557CEBF6E6B2E")));
auto Sym1 = *ParsedYAML->Symbols->find(
cantFail(SymbolID::fromStr("057557CEBF6E6B2D")));
auto Sym2 = *ParsedYAML->Symbols->find(
cantFail(SymbolID::fromStr("057557CEBF6E6B2E")));
- EXPECT_THAT(Sym1, QName("clang::Foo1"));
+ EXPECT_THAT(Sym1, qName("clang::Foo1"));
EXPECT_EQ(Sym1.Signature, "");
EXPECT_EQ(Sym1.Documentation, "Foo doc");
EXPECT_EQ(Sym1.ReturnType, "int");
@@ -154,7 +154,7 @@ TEST(SerializationTest, YAMLConversions) {
UnorderedElementsAre(IncludeHeaderWithRef("include1", 7u),
IncludeHeaderWithRef("include2", 3u)));
- EXPECT_THAT(Sym2, QName("clang::Foo2"));
+ EXPECT_THAT(Sym2, qName("clang::Foo2"));
EXPECT_EQ(Sym2.Signature, "-sig");
EXPECT_EQ(Sym2.ReturnType, "");
EXPECT_EQ(llvm::StringRef(Sym2.CanonicalDeclaration.FileURI),
@@ -194,20 +194,20 @@ TEST(SerializationTest, YAMLConversions) {
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));
@@ -230,12 +230,12 @@ TEST(SerializationTest, BinaryConversions) {
ASSERT_TRUE(In2->Relations);
// Assert the YAML serializations match, for nice comparisons and
diff s.
- 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) {
@@ -265,10 +265,10 @@ TEST(SerializationTest, SrcsTest) {
ASSERT_TRUE(In->Sources);
ASSERT_TRUE(In->Sources->count(IGN.URI));
// Assert the YAML serializations match, for nice comparisons and
diff s.
- 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/SourceCodeTests.cpp b/clang-tools-extra/clangd/unittests/SourceCodeTests.cpp
index fdcee9feffb2..167f152a3a39 100644
--- a/clang-tools-extra/clangd/unittests/SourceCodeTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SourceCodeTests.cpp
@@ -34,7 +34,7 @@ MATCHER_P2(Pos, Line, Col, "") {
return arg.line == int(Line) && arg.character == int(Col);
}
-MATCHER_P(MacroName, Name, "") { return arg.Name == Name; }
+MATCHER_P(macroName, Name, "") { return arg.Name == Name; }
/// A helper to make tests easier to read.
Position position(int Line, int Character) {
@@ -542,7 +542,7 @@ TEST(SourceCodeTests, GetMacros) {
ASSERT_TRUE(Id);
auto Result = locateMacroAt(*Id, AST.getPreprocessor());
ASSERT_TRUE(Result);
- EXPECT_THAT(*Result, MacroName("MACRO"));
+ EXPECT_THAT(*Result, macroName("MACRO"));
}
TEST(SourceCodeTests, WorksAtBeginOfFile) {
@@ -556,7 +556,7 @@ TEST(SourceCodeTests, WorksAtBeginOfFile) {
ASSERT_TRUE(Id);
auto Result = locateMacroAt(*Id, AST.getPreprocessor());
ASSERT_TRUE(Result);
- EXPECT_THAT(*Result, MacroName("MACRO"));
+ EXPECT_THAT(*Result, macroName("MACRO"));
}
TEST(SourceCodeTests, IsInsideMainFile) {
diff --git a/clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp b/clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
index a21c085299b2..d8bc315c4b97 100644
--- a/clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp
@@ -45,30 +45,30 @@ using ::testing::UnorderedElementsAre;
using ::testing::UnorderedElementsAreArray;
// GMock helpers for matching Symbol.
-MATCHER_P(Labeled, Label, "") {
+MATCHER_P(labeled, Label, "") {
return (arg.Name + arg.Signature).str() == Label;
}
-MATCHER_P(ReturnType, D, "") { return arg.ReturnType == D; }
-MATCHER_P(Doc, D, "") { return arg.Documentation == D; }
-MATCHER_P(Snippet, S, "") {
+MATCHER_P(returnType, D, "") { return arg.ReturnType == D; }
+MATCHER_P(doc, D, "") { return arg.Documentation == D; }
+MATCHER_P(snippet, S, "") {
return (arg.Name + arg.CompletionSnippetSuffix).str() == S;
}
-MATCHER_P(QName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
-MATCHER_P(HasName, Name, "") { return arg.Name == Name; }
-MATCHER_P(TemplateArgs, TemplArgs, "") {
+MATCHER_P(qName, Name, "") { return (arg.Scope + arg.Name).str() == Name; }
+MATCHER_P(hasName, Name, "") { return arg.Name == Name; }
+MATCHER_P(templateArgs, TemplArgs, "") {
return arg.TemplateSpecializationArgs == TemplArgs;
}
-MATCHER_P(DeclURI, P, "") {
+MATCHER_P(declURI, P, "") {
return StringRef(arg.CanonicalDeclaration.FileURI) == P;
}
-MATCHER_P(DefURI, P, "") { return StringRef(arg.Definition.FileURI) == P; }
-MATCHER(IncludeHeader, "") { return !arg.IncludeHeaders.empty(); }
-MATCHER_P(IncludeHeader, P, "") {
+MATCHER_P(defURI, P, "") { return StringRef(arg.Definition.FileURI) == P; }
+MATCHER(includeHeader, "") { return !arg.IncludeHeaders.empty(); }
+MATCHER_P(includeHeader, P, "") {
return (arg.IncludeHeaders.size() == 1) &&
(arg.IncludeHeaders.begin()->IncludeHeader == P);
}
-MATCHER_P2(IncludeHeaderWithRef, IncludeHeader, References, "") {
- return (arg.IncludeHeader == IncludeHeader) && (arg.References == References);
+MATCHER_P2(IncludeHeaderWithRef, includeHeader, References, "") {
+ return (arg.IncludeHeader == includeHeader) && (arg.References == References);
}
bool rangesMatch(const SymbolLocation &Loc, const Range &R) {
return std::make_tuple(Loc.Start.line(), Loc.Start.column(), Loc.End.line(),
@@ -76,23 +76,23 @@ bool rangesMatch(const SymbolLocation &Loc, const Range &R) {
std::make_tuple(R.start.line, R.start.character, R.end.line,
R.end.character);
}
-MATCHER_P(DeclRange, Pos, "") {
+MATCHER_P(declRange, Pos, "") {
return rangesMatch(arg.CanonicalDeclaration, Pos);
}
-MATCHER_P(DefRange, Pos, "") { return rangesMatch(arg.Definition, Pos); }
-MATCHER_P(RefCount, R, "") { return int(arg.References) == R; }
-MATCHER_P(ForCodeCompletion, IsIndexedForCodeCompletion, "") {
+MATCHER_P(defRange, Pos, "") { return rangesMatch(arg.Definition, Pos); }
+MATCHER_P(refCount, R, "") { return int(arg.References) == R; }
+MATCHER_P(forCodeCompletion, IsIndexedForCodeCompletion, "") {
return static_cast<bool>(arg.Flags & Symbol::IndexedForCodeCompletion) ==
IsIndexedForCodeCompletion;
}
-MATCHER(Deprecated, "") { return arg.Flags & Symbol::Deprecated; }
-MATCHER(ImplementationDetail, "") {
+MATCHER(deprecated, "") { return arg.Flags & Symbol::Deprecated; }
+MATCHER(implementationDetail, "") {
return arg.Flags & Symbol::ImplementationDetail;
}
-MATCHER(VisibleOutsideFile, "") {
+MATCHER(visibleOutsideFile, "") {
return static_cast<bool>(arg.Flags & Symbol::VisibleOutsideFile);
}
-MATCHER(RefRange, "") {
+MATCHER(refRange, "") {
const Ref &Pos = ::testing::get<0>(arg);
const Range &Range = ::testing::get<1>(arg);
return rangesMatch(Pos.Location, Range);
@@ -101,8 +101,8 @@ MATCHER_P2(OverriddenBy, Subject, Object, "") {
return arg == Relation{Subject.ID, RelationKind::OverriddenBy, Object.ID};
}
::testing::Matcher<const std::vector<Ref> &>
-HaveRanges(const std::vector<Range> Ranges) {
- return ::testing::UnorderedPointwise(RefRange(), Ranges);
+haveRanges(const std::vector<Range> Ranges) {
+ return ::testing::UnorderedPointwise(refRange(), Ranges);
}
class ShouldCollectSymbolTest : public ::testing::Test {
@@ -378,28 +378,28 @@ TEST_F(SymbolCollectorTest, CollectSymbols) {
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAreArray(
- {AllOf(QName("Foo"), ForCodeCompletion(true)),
- AllOf(QName("Foo::Foo"), ForCodeCompletion(false)),
- AllOf(QName("Foo::Foo"), ForCodeCompletion(false)),
- AllOf(QName("Foo::f"), ForCodeCompletion(false)),
- AllOf(QName("Foo::~Foo"), ForCodeCompletion(false)),
- AllOf(QName("Foo::operator="), ForCodeCompletion(false)),
- AllOf(QName("Foo::Nested"), ForCodeCompletion(false)),
- AllOf(QName("Foo::Nested::f"), ForCodeCompletion(false)),
- AllOf(QName("ClassInLambda"), ForCodeCompletion(false)),
- AllOf(QName("Friend"), ForCodeCompletion(true)),
- AllOf(QName("f1"), ForCodeCompletion(true)),
- AllOf(QName("f2"), ForCodeCompletion(true)),
- AllOf(QName("KInt"), ForCodeCompletion(true)),
- AllOf(QName("kStr"), ForCodeCompletion(true)),
- AllOf(QName("foo"), ForCodeCompletion(true)),
- AllOf(QName("foo::bar"), ForCodeCompletion(true)),
- AllOf(QName("foo::int32"), ForCodeCompletion(true)),
- AllOf(QName("foo::int32_t"), ForCodeCompletion(true)),
- AllOf(QName("foo::v1"), ForCodeCompletion(true)),
- AllOf(QName("foo::bar::v2"), ForCodeCompletion(true)),
- AllOf(QName("foo::v2"), ForCodeCompletion(true)),
- AllOf(QName("foo::baz"), ForCodeCompletion(true))}));
+ {AllOf(qName("Foo"), forCodeCompletion(true)),
+ AllOf(qName("Foo::Foo"), forCodeCompletion(false)),
+ AllOf(qName("Foo::Foo"), forCodeCompletion(false)),
+ AllOf(qName("Foo::f"), forCodeCompletion(false)),
+ AllOf(qName("Foo::~Foo"), forCodeCompletion(false)),
+ AllOf(qName("Foo::operator="), forCodeCompletion(false)),
+ AllOf(qName("Foo::Nested"), forCodeCompletion(false)),
+ AllOf(qName("Foo::Nested::f"), forCodeCompletion(false)),
+ AllOf(qName("ClassInLambda"), forCodeCompletion(false)),
+ AllOf(qName("Friend"), forCodeCompletion(true)),
+ AllOf(qName("f1"), forCodeCompletion(true)),
+ AllOf(qName("f2"), forCodeCompletion(true)),
+ AllOf(qName("KInt"), forCodeCompletion(true)),
+ AllOf(qName("kStr"), forCodeCompletion(true)),
+ AllOf(qName("foo"), forCodeCompletion(true)),
+ AllOf(qName("foo::bar"), forCodeCompletion(true)),
+ AllOf(qName("foo::int32"), forCodeCompletion(true)),
+ AllOf(qName("foo::int32_t"), forCodeCompletion(true)),
+ AllOf(qName("foo::v1"), forCodeCompletion(true)),
+ AllOf(qName("foo::bar::v2"), forCodeCompletion(true)),
+ AllOf(qName("foo::v2"), forCodeCompletion(true)),
+ AllOf(qName("foo::baz"), forCodeCompletion(true))}));
}
TEST_F(SymbolCollectorTest, FileLocal) {
@@ -422,13 +422,13 @@ TEST_F(SymbolCollectorTest, FileLocal) {
runSymbolCollector(Header, Main);
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Foo"), VisibleOutsideFile()),
- AllOf(QName("bar"), VisibleOutsideFile()),
- AllOf(QName("a"), Not(VisibleOutsideFile())),
- AllOf(QName("B"), Not(VisibleOutsideFile())),
- AllOf(QName("c"), Not(VisibleOutsideFile())),
+ AllOf(qName("Foo"), visibleOutsideFile()),
+ AllOf(qName("bar"), visibleOutsideFile()),
+ AllOf(qName("a"), Not(visibleOutsideFile())),
+ AllOf(qName("B"), Not(visibleOutsideFile())),
+ AllOf(qName("c"), Not(visibleOutsideFile())),
// FIXME: ForwardDecl likely *is* visible outside.
- AllOf(QName("ForwardDecl"), Not(VisibleOutsideFile()))));
+ AllOf(qName("ForwardDecl"), Not(visibleOutsideFile()))));
}
TEST_F(SymbolCollectorTest, Template) {
@@ -444,17 +444,17 @@ TEST_F(SymbolCollectorTest, Template) {
runSymbolCollector(Header.code(), /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Tmpl"), DeclRange(Header.range()),
- ForCodeCompletion(true)),
- AllOf(QName("Tmpl"), DeclRange(Header.range("specdecl")),
- ForCodeCompletion(false)),
- AllOf(QName("Tmpl"), DeclRange(Header.range("partspecdecl")),
- ForCodeCompletion(false)),
- AllOf(QName("Tmpl::x"), DeclRange(Header.range("xdecl")),
- ForCodeCompletion(false))));
+ AllOf(qName("Tmpl"), declRange(Header.range()),
+ forCodeCompletion(true)),
+ AllOf(qName("Tmpl"), declRange(Header.range("specdecl")),
+ forCodeCompletion(false)),
+ AllOf(qName("Tmpl"), declRange(Header.range("partspecdecl")),
+ forCodeCompletion(false)),
+ AllOf(qName("Tmpl::x"), declRange(Header.range("xdecl")),
+ forCodeCompletion(false))));
}
-TEST_F(SymbolCollectorTest, TemplateArgs) {
+TEST_F(SymbolCollectorTest, templateArgs) {
Annotations Header(R"(
template <class X> class $barclasstemp[[Bar]] {};
template <class T, class U, template<typename> class Z, int Q>
@@ -493,30 +493,30 @@ TEST_F(SymbolCollectorTest, TemplateArgs) {
EXPECT_THAT(
Symbols,
AllOf(
- Contains(AllOf(QName("Tmpl"), TemplateArgs("<int, bool, Bar, 3>"),
- DeclRange(Header.range("specdecl")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Tmpl"), TemplateArgs("<bool, U, Bar, T>"),
- DeclRange(Header.range("partspecdecl")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Foo"), TemplateArgs("<Bar<int>, int, double>"),
- DeclRange(Header.range("parampack")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Foo"), TemplateArgs("<T, T>"),
- DeclRange(Header.range("parampackpartial")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Baz"), TemplateArgs("<3, 5, 8>"),
- DeclRange(Header.range("parampacknontype")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Baz"), TemplateArgs("<T, T>"),
- DeclRange(Header.range("parampacknontypepartial")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Foz"), TemplateArgs("<Bar, Bar>"),
- DeclRange(Header.range("parampacktempltempl")),
- ForCodeCompletion(false))),
- Contains(AllOf(QName("Foz"), TemplateArgs("<T, T>"),
- DeclRange(Header.range("parampacktempltemplpartial")),
- ForCodeCompletion(false)))));
+ Contains(AllOf(qName("Tmpl"), templateArgs("<int, bool, Bar, 3>"),
+ declRange(Header.range("specdecl")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Tmpl"), templateArgs("<bool, U, Bar, T>"),
+ declRange(Header.range("partspecdecl")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Foo"), templateArgs("<Bar<int>, int, double>"),
+ declRange(Header.range("parampack")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Foo"), templateArgs("<T, T>"),
+ declRange(Header.range("parampackpartial")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Baz"), templateArgs("<3, 5, 8>"),
+ declRange(Header.range("parampacknontype")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Baz"), templateArgs("<T, T>"),
+ declRange(Header.range("parampacknontypepartial")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Foz"), templateArgs("<Bar, Bar>"),
+ declRange(Header.range("parampacktempltempl")),
+ forCodeCompletion(false))),
+ Contains(AllOf(qName("Foz"), templateArgs("<T, T>"),
+ declRange(Header.range("parampacktempltemplpartial")),
+ forCodeCompletion(false)))));
}
TEST_F(SymbolCollectorTest, ObjCSymbols) {
@@ -550,10 +550,10 @@ TEST_F(SymbolCollectorTest, ObjCSymbols) {
runSymbolCollector(Header, /*Main=*/"", {"-fblocks", "-xobjective-c++"});
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- QName("Person"), QName("Person::someMethodName:lastName:"),
- AllOf(QName("MyCategory"), ForCodeCompletion(false)),
- QName("Person::someMethodName2:"), QName("MyProtocol"),
- QName("MyProtocol::someMethodName3:")));
+ qName("Person"), qName("Person::someMethodName:lastName:"),
+ AllOf(qName("MyCategory"), forCodeCompletion(false)),
+ qName("Person::someMethodName2:"), qName("MyProtocol"),
+ qName("MyProtocol::someMethodName3:")));
}
TEST_F(SymbolCollectorTest, ObjCPropertyImpl) {
@@ -567,8 +567,8 @@ TEST_F(SymbolCollectorTest, ObjCPropertyImpl) {
)";
TestFileName = testPath("test.m");
runSymbolCollector(Header, /*Main=*/"", {"-xobjective-c++"});
- EXPECT_THAT(Symbols, Contains(QName("Container")));
- EXPECT_THAT(Symbols, Contains(QName("Container::magic")));
+ EXPECT_THAT(Symbols, Contains(qName("Container")));
+ EXPECT_THAT(Symbols, Contains(qName("Container::magic")));
// FIXME: Results also contain Container::_magic on some platforms.
// Figure out why it's platform-dependent.
}
@@ -599,14 +599,14 @@ TEST_F(SymbolCollectorTest, ObjCLocations) {
{"-xobjective-c++", "-Wno-objc-root-class"});
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Dog"), DeclRange(Header.range("dogdecl")),
- DefRange(Main.range("dogdef"))),
- AllOf(QName("Fluffy"), DeclRange(Header.range("fluffydecl")),
- DefRange(Main.range("fluffydef"))),
- AllOf(QName("CatDog"), DeclRange(Main.range("catdog")),
- DefRange(Main.range("catdog"))),
- AllOf(QName("Ruff"), DeclRange(Main.range("ruff")),
- DefRange(Main.range("ruff")))));
+ AllOf(qName("Dog"), declRange(Header.range("dogdecl")),
+ defRange(Main.range("dogdef"))),
+ AllOf(qName("Fluffy"), declRange(Header.range("fluffydecl")),
+ defRange(Main.range("fluffydef"))),
+ AllOf(qName("CatDog"), declRange(Main.range("catdog")),
+ defRange(Main.range("catdog"))),
+ AllOf(qName("Ruff"), declRange(Main.range("ruff")),
+ defRange(Main.range("ruff")))));
}
TEST_F(SymbolCollectorTest, ObjCForwardDecls) {
@@ -634,12 +634,12 @@ TEST_F(SymbolCollectorTest, ObjCForwardDecls) {
{"-xobjective-c++", "-Wno-objc-root-class"});
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("CatDog"), DeclRange(Header.range("catdogdecl")),
- DefRange(Main.range("catdogdef"))),
- AllOf(QName("Dog"), DeclRange(Main.range("dogdecl")),
- DefRange(Main.range("dogdef"))),
- AllOf(QName("Barker"), DeclRange(Main.range("barkerdecl"))),
- QName("Barker::woof"), QName("Dog::woof")));
+ AllOf(qName("CatDog"), declRange(Header.range("catdogdecl")),
+ defRange(Main.range("catdogdef"))),
+ AllOf(qName("Dog"), declRange(Main.range("dogdecl")),
+ defRange(Main.range("dogdef"))),
+ AllOf(qName("Barker"), declRange(Main.range("barkerdecl"))),
+ qName("Barker::woof"), qName("Dog::woof")));
}
TEST_F(SymbolCollectorTest, ObjCClassExtensions) {
@@ -659,8 +659,8 @@ TEST_F(SymbolCollectorTest, ObjCClassExtensions) {
{"-xobjective-c++", "-Wno-objc-root-class"});
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Cat"), DeclRange(Header.range("catdecl"))),
- QName("Cat::meow"), QName("Cat::pur")));
+ AllOf(qName("Cat"), declRange(Header.range("catdecl"))),
+ qName("Cat::meow"), qName("Cat::pur")));
}
TEST_F(SymbolCollectorTest, Locations) {
@@ -687,15 +687,15 @@ o]]();
runSymbolCollector(Header.code(), Main.code());
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("X"), DeclRange(Header.range("xdecl")),
- DefRange(Main.range("xdef"))),
- AllOf(QName("Cls"), DeclRange(Header.range("clsdecl")),
- DefRange(Main.range("clsdef"))),
- AllOf(QName("print"), DeclRange(Header.range("printdecl")),
- DefRange(Main.range("printdef"))),
- AllOf(QName("Z"), DeclRange(Header.range("zdecl"))),
- AllOf(QName("foo"), DeclRange(Header.range("foodecl"))),
- AllOf(QName("Y"), DeclRange(Main.range("ydecl")))));
+ AllOf(qName("X"), declRange(Header.range("xdecl")),
+ defRange(Main.range("xdef"))),
+ AllOf(qName("Cls"), declRange(Header.range("clsdecl")),
+ defRange(Main.range("clsdef"))),
+ AllOf(qName("print"), declRange(Header.range("printdecl")),
+ defRange(Main.range("printdef"))),
+ AllOf(qName("Z"), declRange(Header.range("zdecl"))),
+ AllOf(qName("foo"), declRange(Header.range("foodecl"))),
+ AllOf(qName("Y"), declRange(Main.range("ydecl")))));
}
TEST_F(SymbolCollectorTest, Refs) {
@@ -737,14 +737,14 @@ TEST_F(SymbolCollectorTest, Refs) {
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 =
@@ -872,18 +872,18 @@ TEST_F(SymbolCollectorTest, MacroRefInHeader) {
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) {
@@ -895,7 +895,7 @@ TEST_F(SymbolCollectorTest, MacroRefWithoutCollectingSymbol) {
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) {
@@ -966,9 +966,9 @@ TEST_F(SymbolCollectorTest, SpelledReferences) {
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))));
}
}
@@ -987,7 +987,7 @@ TEST_F(SymbolCollectorTest, NameReferences) {
// 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) {
@@ -1010,7 +1010,7 @@ TEST_F(SymbolCollectorTest, RefsOnMacros) {
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) {
@@ -1029,30 +1029,30 @@ TEST_F(SymbolCollectorTest, HeaderAsMainFile) {
runSymbolCollector("", Header.code());
EXPECT_THAT(Refs,
UnorderedElementsAre(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Header.ranges("Foo"))),
+ haveRanges(Header.ranges("Foo"))),
Pair(findSymbol(Symbols, "Func").ID,
- HaveRanges(Header.ranges("Func")))));
+ haveRanges(Header.ranges("Func")))));
// 2. Run the .h file as main file.
TestFileName = testPath("foo.h");
runSymbolCollector("", Header.code(),
/*ExtraArgs=*/{"-xobjective-c++-header"});
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("Foo"), QName("Func")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("Foo"), qName("Func")));
EXPECT_THAT(Refs,
UnorderedElementsAre(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Header.ranges("Foo"))),
+ haveRanges(Header.ranges("Foo"))),
Pair(findSymbol(Symbols, "Func").ID,
- HaveRanges(Header.ranges("Func")))));
+ haveRanges(Header.ranges("Func")))));
// 3. Run the .hh file as main file (without "-x c++-header").
TestFileName = testPath("foo.hh");
runSymbolCollector("", Header.code());
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("Foo"), QName("Func")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("Foo"), qName("Func")));
EXPECT_THAT(Refs,
UnorderedElementsAre(Pair(findSymbol(Symbols, "Foo").ID,
- HaveRanges(Header.ranges("Foo"))),
+ haveRanges(Header.ranges("Foo"))),
Pair(findSymbol(Symbols, "Func").ID,
- HaveRanges(Header.ranges("Func")))));
+ haveRanges(Header.ranges("Func")))));
}
TEST_F(SymbolCollectorTest, RefsInHeaders) {
@@ -1065,9 +1065,9 @@ TEST_F(SymbolCollectorTest, RefsInHeaders) {
)");
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) {
@@ -1176,18 +1176,18 @@ TEST_F(SymbolCollectorTest, CountReferences) {
EXPECT_THAT(
Symbols,
UnorderedElementsAreArray(
- {AllOf(QName("W"), RefCount(1)), AllOf(QName("X"), RefCount(1)),
- AllOf(QName("Y"), RefCount(0)), AllOf(QName("Z"), RefCount(0)),
- AllOf(QName("y"), RefCount(0)), AllOf(QName("z"), RefCount(0)),
- AllOf(QName("x"), RefCount(0)), AllOf(QName("w"), RefCount(0)),
- AllOf(QName("w2"), RefCount(0)), AllOf(QName("V"), RefCount(1)),
- AllOf(QName("v"), RefCount(0))}));
+ {AllOf(qName("W"), refCount(1)), AllOf(qName("X"), refCount(1)),
+ AllOf(qName("Y"), refCount(0)), AllOf(qName("Z"), refCount(0)),
+ AllOf(qName("y"), refCount(0)), AllOf(qName("z"), refCount(0)),
+ AllOf(qName("x"), refCount(0)), AllOf(qName("w"), refCount(0)),
+ AllOf(qName("w2"), refCount(0)), AllOf(qName("V"), refCount(1)),
+ AllOf(qName("v"), refCount(0))}));
}
TEST_F(SymbolCollectorTest, SymbolRelativeNoFallback) {
runSymbolCollector("class Foo {};", /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI))));
}
TEST_F(SymbolCollectorTest, SymbolRelativeWithFallback) {
@@ -1197,7 +1197,7 @@ TEST_F(SymbolCollectorTest, SymbolRelativeWithFallback) {
CollectorOpts.FallbackDir = testRoot();
runSymbolCollector("class Foo {};", /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI))));
}
TEST_F(SymbolCollectorTest, UnittestURIScheme) {
@@ -1206,7 +1206,7 @@ TEST_F(SymbolCollectorTest, UnittestURIScheme) {
TestFileName = testPath("x.cpp");
runSymbolCollector("class Foo {};", /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI("unittest:///x.h"))));
+ AllOf(qName("Foo"), declURI("unittest:///x.h"))));
}
TEST_F(SymbolCollectorTest, IncludeEnums) {
@@ -1229,13 +1229,13 @@ TEST_F(SymbolCollectorTest, IncludeEnums) {
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Red"), ForCodeCompletion(true)),
- AllOf(QName("Color"), ForCodeCompletion(true)),
- AllOf(QName("Green"), ForCodeCompletion(true)),
- AllOf(QName("Color2"), ForCodeCompletion(true)),
- AllOf(QName("Color2::Yellow"), ForCodeCompletion(false)),
- AllOf(QName("ns"), ForCodeCompletion(true)),
- AllOf(QName("ns::Black"), ForCodeCompletion(true))));
+ AllOf(qName("Red"), forCodeCompletion(true)),
+ AllOf(qName("Color"), forCodeCompletion(true)),
+ AllOf(qName("Green"), forCodeCompletion(true)),
+ AllOf(qName("Color2"), forCodeCompletion(true)),
+ AllOf(qName("Color2::Yellow"), forCodeCompletion(false)),
+ AllOf(qName("ns"), forCodeCompletion(true)),
+ AllOf(qName("ns::Black"), forCodeCompletion(true))));
}
TEST_F(SymbolCollectorTest, NamelessSymbols) {
@@ -1245,8 +1245,8 @@ TEST_F(SymbolCollectorTest, NamelessSymbols) {
} Foo;
)";
runSymbolCollector(Header, /*Main=*/"");
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("Foo"),
- QName("(anonymous struct)::a")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("Foo"),
+ qName("(anonymous struct)::a")));
}
TEST_F(SymbolCollectorTest, SymbolFormedFromRegisteredSchemeFromMacro) {
@@ -1266,10 +1266,10 @@ TEST_F(SymbolCollectorTest, SymbolFormedFromRegisteredSchemeFromMacro) {
runSymbolCollector(Header.code(), /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("abc_Test"), DeclRange(Header.range("expansion")),
- DeclURI(TestHeaderURI)),
- AllOf(QName("Test"), DeclRange(Header.range("spelling")),
- DeclURI(TestHeaderURI))));
+ AllOf(qName("abc_Test"), declRange(Header.range("expansion")),
+ declURI(TestHeaderURI)),
+ AllOf(qName("Test"), declRange(Header.range("spelling")),
+ declURI(TestHeaderURI))));
}
TEST_F(SymbolCollectorTest, SymbolFormedByCLI) {
@@ -1280,8 +1280,8 @@ TEST_F(SymbolCollectorTest, SymbolFormedByCLI) {
)");
runSymbolCollector(Header.code(), /*Main=*/"", /*ExtraArgs=*/{"-DNAME=name"});
EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(
- QName("name"), DeclRange(Header.range("expansion")),
- DeclURI(TestHeaderURI))));
+ qName("name"), declRange(Header.range("expansion")),
+ declURI(TestHeaderURI))));
}
TEST_F(SymbolCollectorTest, SymbolsInMainFile) {
@@ -1303,15 +1303,15 @@ TEST_F(SymbolCollectorTest, SymbolsInMainFile) {
)";
runSymbolCollector(/*Header=*/"", Main);
EXPECT_THAT(Symbols, UnorderedElementsAre(
- QName("Foo"), QName("f1"), QName("f2"), QName("ff"),
- QName("foo"), QName("foo::Bar"), QName("main_f")));
+ qName("Foo"), qName("f1"), qName("f2"), qName("ff"),
+ qName("foo"), qName("foo::Bar"), qName("main_f")));
}
TEST_F(SymbolCollectorTest, Documentation) {
const std::string Header = R"(
- // Doc Foo
+ // doc Foo
class Foo {
- // Doc f
+ // doc f
int f();
};
)";
@@ -1319,17 +1319,17 @@ TEST_F(SymbolCollectorTest, Documentation) {
runSymbolCollector(Header, /* Main */ "");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Foo"), Doc("Doc Foo"), ForCodeCompletion(true)),
- AllOf(QName("Foo::f"), Doc(""), ReturnType(""),
- ForCodeCompletion(false))));
+ AllOf(qName("Foo"), doc("doc Foo"), forCodeCompletion(true)),
+ AllOf(qName("Foo::f"), doc(""), returnType(""),
+ forCodeCompletion(false))));
CollectorOpts.StoreAllDocumentation = true;
runSymbolCollector(Header, /* Main */ "");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("Foo"), Doc("Doc Foo"), ForCodeCompletion(true)),
- AllOf(QName("Foo::f"), Doc("Doc f"), ReturnType(""),
- ForCodeCompletion(false))));
+ AllOf(qName("Foo"), doc("doc Foo"), forCodeCompletion(true)),
+ AllOf(qName("Foo::f"), doc("doc f"), returnType(""),
+ forCodeCompletion(false))));
}
TEST_F(SymbolCollectorTest, ClassMembers) {
@@ -1350,12 +1350,12 @@ TEST_F(SymbolCollectorTest, ClassMembers) {
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- QName("Foo"),
- AllOf(QName("Foo::f"), ReturnType(""), ForCodeCompletion(false)),
- AllOf(QName("Foo::g"), ReturnType(""), ForCodeCompletion(false)),
- AllOf(QName("Foo::sf"), ReturnType(""), ForCodeCompletion(false)),
- AllOf(QName("Foo::ssf"), ReturnType(""), ForCodeCompletion(false)),
- AllOf(QName("Foo::x"), ReturnType(""), ForCodeCompletion(false))));
+ qName("Foo"),
+ AllOf(qName("Foo::f"), returnType(""), forCodeCompletion(false)),
+ AllOf(qName("Foo::g"), returnType(""), forCodeCompletion(false)),
+ AllOf(qName("Foo::sf"), returnType(""), forCodeCompletion(false)),
+ AllOf(qName("Foo::ssf"), returnType(""), forCodeCompletion(false)),
+ AllOf(qName("Foo::x"), returnType(""), forCodeCompletion(false))));
}
TEST_F(SymbolCollectorTest, Scopes) {
@@ -1369,8 +1369,8 @@ TEST_F(SymbolCollectorTest, Scopes) {
)";
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
- UnorderedElementsAre(QName("na"), QName("na::nb"),
- QName("na::Foo"), QName("na::nb::Bar")));
+ UnorderedElementsAre(qName("na"), qName("na::nb"),
+ qName("na::Foo"), qName("na::nb::Bar")));
}
TEST_F(SymbolCollectorTest, ExternC) {
@@ -1381,8 +1381,8 @@ TEST_F(SymbolCollectorTest, ExternC) {
}
)";
runSymbolCollector(Header, /*Main=*/"");
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("na"), QName("Foo"),
- QName("na::Bar")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("na"), qName("Foo"),
+ qName("na::Bar")));
}
TEST_F(SymbolCollectorTest, SkipInlineNamespace) {
@@ -1401,8 +1401,8 @@ TEST_F(SymbolCollectorTest, SkipInlineNamespace) {
)";
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
- UnorderedElementsAre(QName("na"), QName("na::nb"),
- QName("na::Foo"), QName("na::Bar")));
+ UnorderedElementsAre(qName("na"), qName("na::nb"),
+ qName("na::Foo"), qName("na::Bar")));
}
TEST_F(SymbolCollectorTest, SymbolWithDocumentation) {
@@ -1416,11 +1416,11 @@ TEST_F(SymbolCollectorTest, SymbolWithDocumentation) {
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- QName("nx"), AllOf(QName("nx::ff"), Labeled("ff(int x, double y)"),
- ReturnType("int"), Doc("Foo comment."))));
+ qName("nx"), AllOf(qName("nx::ff"), labeled("ff(int x, double y)"),
+ returnType("int"), doc("Foo comment."))));
}
-TEST_F(SymbolCollectorTest, Snippet) {
+TEST_F(SymbolCollectorTest, snippet) {
const std::string Header = R"(
namespace nx {
void f() {}
@@ -1430,17 +1430,17 @@ TEST_F(SymbolCollectorTest, Snippet) {
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- QName("nx"),
- AllOf(QName("nx::f"), Labeled("f()"), Snippet("f()")),
- AllOf(QName("nx::ff"), Labeled("ff(int x, double y)"),
- Snippet("ff(${1:int x}, ${2:double y})"))));
+ qName("nx"),
+ AllOf(qName("nx::f"), labeled("f()"), snippet("f()")),
+ AllOf(qName("nx::ff"), labeled("ff(int x, double y)"),
+ snippet("ff(${1:int x}, ${2:double y})"))));
}
TEST_F(SymbolCollectorTest, IncludeHeaderSameAsFileURI) {
CollectorOpts.CollectIncludePath = true;
runSymbolCollector("#pragma once\nclass Foo {};", /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI))));
EXPECT_THAT(Symbols.begin()->IncludeHeaders,
UnorderedElementsAre(IncludeHeaderWithRef(TestHeaderURI, 1u)));
}
@@ -1465,12 +1465,12 @@ TEST_F(SymbolCollectorTest, CanonicalSTLHeader) {
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- QName("std"),
- AllOf(QName("std::string"), DeclURI(TestHeaderURI),
- IncludeHeader("<string>")),
+ qName("std"),
+ AllOf(qName("std::string"), declURI(TestHeaderURI),
+ includeHeader("<string>")),
// Parameter names are demangled.
- AllOf(Labeled("move(T &&value)"), IncludeHeader("<utility>")),
- AllOf(Labeled("move(I, I, O)"), IncludeHeader("<algorithm>"))));
+ AllOf(labeled("move(T &&value)"), includeHeader("<utility>")),
+ AllOf(labeled("move(I, I, O)"), includeHeader("<algorithm>"))));
}
TEST_F(SymbolCollectorTest, IWYUPragma) {
@@ -1484,8 +1484,8 @@ TEST_F(SymbolCollectorTest, IWYUPragma) {
)";
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI),
- IncludeHeader("\"the/good/header.h\""))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI),
+ includeHeader("\"the/good/header.h\""))));
}
TEST_F(SymbolCollectorTest, IWYUPragmaWithDoubleQuotes) {
@@ -1499,8 +1499,8 @@ TEST_F(SymbolCollectorTest, IWYUPragmaWithDoubleQuotes) {
)";
runSymbolCollector(Header, /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("Foo"), DeclURI(TestHeaderURI),
- IncludeHeader("\"the/good/header.h\""))));
+ AllOf(qName("Foo"), declURI(TestHeaderURI),
+ includeHeader("\"the/good/header.h\""))));
}
TEST_F(SymbolCollectorTest, SkipIncFileWhenCanonicalizeHeaders) {
@@ -1515,10 +1515,10 @@ TEST_F(SymbolCollectorTest, SkipIncFileWhenCanonicalizeHeaders) {
runSymbolCollector("#include \"test.inc\"\nclass Y {};", /*Main=*/"",
/*ExtraArgs=*/{"-I", testRoot()});
EXPECT_THAT(Symbols,
- UnorderedElementsAre(AllOf(QName("X"), DeclURI(IncURI),
- IncludeHeader("<canonical>")),
- AllOf(QName("Y"), DeclURI(TestHeaderURI),
- IncludeHeader("<canonical>"))));
+ UnorderedElementsAre(AllOf(qName("X"), declURI(IncURI),
+ includeHeader("<canonical>")),
+ AllOf(qName("Y"), declURI(TestHeaderURI),
+ includeHeader("<canonical>"))));
}
TEST_F(SymbolCollectorTest, MainFileIsHeaderWhenSkipIncFile) {
@@ -1539,8 +1539,8 @@ TEST_F(SymbolCollectorTest, MainFileIsHeaderWhenSkipIncFile) {
#endif
)cpp",
/*ExtraArgs=*/{"-I", testRoot()});
- EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(QName("X"), DeclURI(IncURI),
- IncludeHeader(TestFileURI))));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(qName("X"), declURI(IncURI),
+ includeHeader(TestFileURI))));
}
TEST_F(SymbolCollectorTest, IncFileInNonHeader) {
@@ -1555,8 +1555,8 @@ TEST_F(SymbolCollectorTest, IncFileInNonHeader) {
#include "test.inc"
)cpp",
/*ExtraArgs=*/{"-I", testRoot()});
- EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(QName("X"), DeclURI(IncURI),
- Not(IncludeHeader()))));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(qName("X"), declURI(IncURI),
+ Not(includeHeader()))));
}
// Features that depend on header-guards are fragile. Header guards are only
@@ -1575,17 +1575,17 @@ TEST_F(SymbolCollectorTest, HeaderGuardDetected) {
#endif // Header guard is recognized here.
)cpp",
"");
- EXPECT_THAT(Symbols, Not(Contains(QName("HEADER_GUARD_"))));
- EXPECT_THAT(Symbols, Each(IncludeHeader()));
+ EXPECT_THAT(Symbols, Not(Contains(qName("HEADER_GUARD_"))));
+ EXPECT_THAT(Symbols, Each(includeHeader()));
}
TEST_F(SymbolCollectorTest, NonModularHeader) {
auto TU = TestTU::withHeaderCode("int x();");
- EXPECT_THAT(TU.headerSymbols(), ElementsAre(IncludeHeader()));
+ EXPECT_THAT(TU.headerSymbols(), ElementsAre(includeHeader()));
// Files missing include guards aren't eligible for insertion.
TU.ImplicitHeaderGuard = false;
- EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(IncludeHeader())));
+ EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(includeHeader())));
// We recognize some patterns of trying to prevent insertion.
TU = TestTU::withHeaderCode(R"cpp(
@@ -1595,7 +1595,7 @@ TEST_F(SymbolCollectorTest, NonModularHeader) {
int x();
)cpp");
TU.ExtraArgs.push_back("-DSECRET"); // *we're* able to include it.
- EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(IncludeHeader())));
+ EXPECT_THAT(TU.headerSymbols(), ElementsAre(Not(includeHeader())));
}
TEST_F(SymbolCollectorTest, AvoidUsingFwdDeclsAsCanonicalDecls) {
@@ -1616,21 +1616,21 @@ TEST_F(SymbolCollectorTest, AvoidUsingFwdDeclsAsCanonicalDecls) {
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- AllOf(QName("C"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("cdecl")), IncludeHeader(TestHeaderURI),
- DefURI(TestHeaderURI), DefRange(Header.range("cdecl"))),
- AllOf(QName("S"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("sdecl")), IncludeHeader(TestHeaderURI),
- DefURI(TestHeaderURI), DefRange(Header.range("sdecl"))),
- AllOf(QName("U"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("udecl")), IncludeHeader(TestHeaderURI),
- DefURI(TestHeaderURI), DefRange(Header.range("udecl"))),
- AllOf(QName("U::x"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("xdecl")), DefURI(TestHeaderURI),
- DefRange(Header.range("xdecl"))),
- AllOf(QName("U::y"), DeclURI(TestHeaderURI),
- DeclRange(Header.range("ydecl")), DefURI(TestHeaderURI),
- DefRange(Header.range("ydecl")))));
+ AllOf(qName("C"), declURI(TestHeaderURI),
+ declRange(Header.range("cdecl")), includeHeader(TestHeaderURI),
+ defURI(TestHeaderURI), defRange(Header.range("cdecl"))),
+ AllOf(qName("S"), declURI(TestHeaderURI),
+ declRange(Header.range("sdecl")), includeHeader(TestHeaderURI),
+ defURI(TestHeaderURI), defRange(Header.range("sdecl"))),
+ AllOf(qName("U"), declURI(TestHeaderURI),
+ declRange(Header.range("udecl")), includeHeader(TestHeaderURI),
+ defURI(TestHeaderURI), defRange(Header.range("udecl"))),
+ AllOf(qName("U::x"), declURI(TestHeaderURI),
+ declRange(Header.range("xdecl")), defURI(TestHeaderURI),
+ defRange(Header.range("xdecl"))),
+ AllOf(qName("U::y"), declURI(TestHeaderURI),
+ declRange(Header.range("ydecl")), defURI(TestHeaderURI),
+ defRange(Header.range("ydecl")))));
}
TEST_F(SymbolCollectorTest, ClassForwardDeclarationIsCanonical) {
@@ -1638,8 +1638,8 @@ TEST_F(SymbolCollectorTest, ClassForwardDeclarationIsCanonical) {
runSymbolCollector(/*Header=*/"#pragma once\nclass X;",
/*Main=*/"class X {};");
EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(
- QName("X"), DeclURI(TestHeaderURI),
- IncludeHeader(TestHeaderURI), DefURI(TestFileURI))));
+ qName("X"), declURI(TestHeaderURI),
+ includeHeader(TestHeaderURI), defURI(TestFileURI))));
}
TEST_F(SymbolCollectorTest, UTF16Character) {
@@ -1647,7 +1647,7 @@ TEST_F(SymbolCollectorTest, UTF16Character) {
Annotations Header(/*Header=*/"class [[pörk]] {};");
runSymbolCollector(Header.code(), /*Main=*/"");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("pörk"), DeclRange(Header.range()))));
+ AllOf(qName("pörk"), declRange(Header.range()))));
}
TEST_F(SymbolCollectorTest, DoNotIndexSymbolsInFriendDecl) {
@@ -1668,11 +1668,11 @@ TEST_F(SymbolCollectorTest, DoNotIndexSymbolsInFriendDecl) {
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- QName("nx"), QName("nx::X"),
- AllOf(QName("nx::Y"), DeclRange(Header.range("y"))),
- AllOf(QName("nx::Z"), DeclRange(Header.range("z"))),
- AllOf(QName("nx::foo"), DeclRange(Header.range("foo"))),
- AllOf(QName("nx::bar"), DeclRange(Header.range("bar")))));
+ qName("nx"), qName("nx::X"),
+ AllOf(qName("nx::Y"), declRange(Header.range("y"))),
+ AllOf(qName("nx::Z"), declRange(Header.range("z"))),
+ AllOf(qName("nx::foo"), declRange(Header.range("foo"))),
+ AllOf(qName("nx::bar"), declRange(Header.range("bar")))));
}
TEST_F(SymbolCollectorTest, ReferencesInFriendDecl) {
@@ -1688,9 +1688,9 @@ TEST_F(SymbolCollectorTest, ReferencesInFriendDecl) {
)";
CollectorOpts.CountReferences = true;
runSymbolCollector(Header, Main);
- EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(QName("X"), RefCount(1)),
- AllOf(QName("Y"), RefCount(1)),
- AllOf(QName("C"), RefCount(0))));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(AllOf(qName("X"), refCount(1)),
+ AllOf(qName("Y"), refCount(1)),
+ AllOf(qName("C"), refCount(0))));
}
TEST_F(SymbolCollectorTest, Origin) {
@@ -1724,16 +1724,16 @@ TEST_F(SymbolCollectorTest, CollectMacros) {
EXPECT_THAT(
Symbols,
UnorderedElementsAre(
- QName("p"), QName("t"),
- AllOf(QName("X"), DeclURI(TestHeaderURI),
- IncludeHeader(TestHeaderURI)),
- AllOf(Labeled("MAC(x)"), RefCount(0),
+ qName("p"), qName("t"),
+ AllOf(qName("X"), declURI(TestHeaderURI),
+ includeHeader(TestHeaderURI)),
+ AllOf(labeled("MAC(x)"), refCount(0),
- DeclRange(Header.range("mac")), VisibleOutsideFile()),
- AllOf(Labeled("USED(y)"), RefCount(1),
- DeclRange(Header.range("used")), VisibleOutsideFile()),
- AllOf(Labeled("MAIN"), RefCount(0), DeclRange(Main.range("main")),
- Not(VisibleOutsideFile()))));
+ declRange(Header.range("mac")), visibleOutsideFile()),
+ AllOf(labeled("USED(y)"), refCount(1),
+ declRange(Header.range("used")), visibleOutsideFile()),
+ AllOf(labeled("MAIN"), refCount(0), declRange(Main.range("main")),
+ Not(visibleOutsideFile()))));
}
TEST_F(SymbolCollectorTest, DeprecatedSymbols) {
@@ -1743,11 +1743,11 @@ TEST_F(SymbolCollectorTest, DeprecatedSymbols) {
)";
runSymbolCollector(Header, /**/ "");
EXPECT_THAT(Symbols, UnorderedElementsAre(
- AllOf(QName("TestClangc"), Deprecated()),
- AllOf(QName("TestClangd"), Not(Deprecated()))));
+ AllOf(qName("TestClangc"), deprecated()),
+ AllOf(qName("TestClangd"), Not(deprecated()))));
}
-TEST_F(SymbolCollectorTest, ImplementationDetail) {
+TEST_F(SymbolCollectorTest, implementationDetail) {
const std::string Header = R"(
#define DECL_NAME(x, y) x##_##y##_Decl
#define DECL(x, y) class DECL_NAME(x, y) {};
@@ -1758,8 +1758,8 @@ TEST_F(SymbolCollectorTest, ImplementationDetail) {
runSymbolCollector(Header, /**/ "");
EXPECT_THAT(Symbols,
UnorderedElementsAre(
- AllOf(QName("X_Y_Decl"), ImplementationDetail()),
- AllOf(QName("Public"), Not(ImplementationDetail()))));
+ AllOf(qName("X_Y_Decl"), implementationDetail()),
+ AllOf(qName("Public"), Not(implementationDetail()))));
}
TEST_F(SymbolCollectorTest, UsingDecl) {
@@ -1769,7 +1769,7 @@ TEST_F(SymbolCollectorTest, UsingDecl) {
using ::foo;
})";
runSymbolCollector(Header, /**/ "");
- EXPECT_THAT(Symbols, Contains(QName("std::foo")));
+ EXPECT_THAT(Symbols, Contains(qName("std::foo")));
}
TEST_F(SymbolCollectorTest, CBuiltins) {
@@ -1778,7 +1778,7 @@ TEST_F(SymbolCollectorTest, CBuiltins) {
extern int printf(const char*, ...);
)";
runSymbolCollector(Header, /**/ "", {"-xc"});
- EXPECT_THAT(Symbols, Contains(QName("printf")));
+ EXPECT_THAT(Symbols, Contains(qName("printf")));
}
TEST_F(SymbolCollectorTest, InvalidSourceLoc) {
@@ -1786,7 +1786,7 @@ TEST_F(SymbolCollectorTest, InvalidSourceLoc) {
void operator delete(void*)
__attribute__((__externally_visible__));)";
runSymbolCollector(Header, /**/ "");
- EXPECT_THAT(Symbols, Contains(QName("operator delete")));
+ EXPECT_THAT(Symbols, Contains(qName("operator delete")));
}
TEST_F(SymbolCollectorTest, BadUTF8) {
@@ -1797,8 +1797,8 @@ TEST_F(SymbolCollectorTest, BadUTF8) {
CollectorOpts.RefFilter = RefKind::All;
CollectorOpts.RefsInHeaders = true;
runSymbolCollector(Header, "");
- EXPECT_THAT(Symbols, Contains(AllOf(QName("types"), Doc("\xef\xbf\xbd "))));
- EXPECT_THAT(Symbols, Contains(QName("PUNCT")));
+ EXPECT_THAT(Symbols, Contains(AllOf(qName("types"), doc("\xef\xbf\xbd "))));
+ EXPECT_THAT(Symbols, Contains(qName("PUNCT")));
// Reference is stored, although offset within line is not reliable.
EXPECT_THAT(Refs, Contains(Pair(findSymbol(Symbols, "PUNCT").ID, _)));
}
@@ -1808,7 +1808,7 @@ TEST_F(SymbolCollectorTest, MacrosInHeaders) {
TestFileName = testPath("test.h");
runSymbolCollector("", "#define X");
EXPECT_THAT(Symbols,
- UnorderedElementsAre(AllOf(QName("X"), ForCodeCompletion(true))));
+ UnorderedElementsAre(AllOf(qName("X"), forCodeCompletion(true))));
}
// Regression test for a crash-bug we used to have.
@@ -1832,7 +1832,7 @@ TEST_F(SymbolCollectorTest, UndefOfModuleMacro) {
TU.build();
// We mostly care about not crashing, but verify that we didn't insert garbage
// about X too.
- EXPECT_THAT(TU.headerSymbols(), Not(Contains(QName("X"))));
+ EXPECT_THAT(TU.headerSymbols(), Not(Contains(qName("X"))));
}
TEST_F(SymbolCollectorTest, NoCrashOnObjCMethodCStyleParam) {
@@ -1846,7 +1846,7 @@ TEST_F(SymbolCollectorTest, NoCrashOnObjCMethodCStyleParam) {
TU.build();
// We mostly care about not crashing.
EXPECT_THAT(TU.headerSymbols(),
- UnorderedElementsAre(QName("Foo"), QName("Foo::fun:")));
+ UnorderedElementsAre(qName("Foo"), qName("Foo::fun:")));
}
TEST_F(SymbolCollectorTest, Reserved) {
@@ -1857,8 +1857,8 @@ TEST_F(SymbolCollectorTest, Reserved) {
CollectorOpts.CollectReserved = true;
runSymbolCollector("", Header);
- EXPECT_THAT(Symbols, UnorderedElementsAre(QName("__foo"), QName("_X"),
- QName("_X::secret")));
+ EXPECT_THAT(Symbols, UnorderedElementsAre(qName("__foo"), qName("_X"),
+ qName("_X::secret")));
CollectorOpts.CollectReserved = false;
runSymbolCollector("", Header); //
diff --git a/clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp b/clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp
index 6c32502775bf..2693d0ee00d3 100644
--- a/clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp
+++ b/clang-tools-extra/clangd/unittests/SymbolInfoTests.cpp
@@ -26,10 +26,10 @@ namespace {
using ::testing::UnorderedElementsAreArray;
-auto CreateExpectedSymbolDetails = [](const std::string &name,
- const std::string &container,
+auto CreateExpectedSymbolDetails = [](const std::string &Name,
+ const std::string &Container,
const std::string &USR) {
- return SymbolDetails{name, container, USR, SymbolID(USR)};
+ return SymbolDetails{Name, Container, USR, SymbolID(USR)};
};
TEST(SymbolInfoTests, All) {
diff --git a/clang-tools-extra/clangd/unittests/TestIndex.cpp b/clang-tools-extra/clangd/unittests/TestIndex.cpp
index 62e4fd684cfd..9bec48cdc8eb 100644
--- a/clang-tools-extra/clangd/unittests/TestIndex.cpp
+++ b/clang-tools-extra/clangd/unittests/TestIndex.cpp
@@ -86,8 +86,8 @@ SymbolSlab generateSymbols(std::vector<std::string> QualifiedNames) {
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
index 09f90fd6e6b5..f71633661dc7 100644
--- a/clang-tools-extra/clangd/unittests/TypeHierarchyTests.cpp
+++ b/clang-tools-extra/clangd/unittests/TypeHierarchyTests.cpp
@@ -35,22 +35,22 @@ using ::testing::Matcher;
using ::testing::UnorderedElementsAre;
// GMock helpers for matching TypeHierarchyItem.
-MATCHER_P(WithName, N, "") { return arg.name == N; }
-MATCHER_P(WithKind, Kind, "") { return arg.kind == Kind; }
-MATCHER_P(SelectionRangeIs, R, "") { return arg.selectionRange == R; }
+MATCHER_P(withName, N, "") { return arg.name == N; }
+MATCHER_P(withKind, Kind, "") { return arg.kind == Kind; }
+MATCHER_P(selectionRangeIs, R, "") { return arg.selectionRange == R; }
template <class... ParentMatchers>
-::testing::Matcher<TypeHierarchyItem> Parents(ParentMatchers... ParentsM) {
+::testing::Matcher<TypeHierarchyItem> parents(ParentMatchers... ParentsM) {
return Field(&TypeHierarchyItem::parents,
HasValue(UnorderedElementsAre(ParentsM...)));
}
template <class... ChildMatchers>
-::testing::Matcher<TypeHierarchyItem> Children(ChildMatchers... ChildrenM) {
+::testing::Matcher<TypeHierarchyItem> children(ChildMatchers... ChildrenM) {
return Field(&TypeHierarchyItem::children,
HasValue(UnorderedElementsAre(ChildrenM...)));
}
// Note: "not resolved" is
diff erent from "resolved but empty"!
-MATCHER(ParentsNotResolved, "") { return !arg.parents; }
-MATCHER(ChildrenNotResolved, "") { return !arg.children; }
+MATCHER(parentsNotResolved, "") { return !arg.parents; }
+MATCHER(childrenNotResolved, "") { return !arg.children; }
TEST(FindRecordTypeAt, TypeOrVariable) {
Annotations Source(R"cpp(
@@ -206,7 +206,7 @@ struct Child : Parent {};
EXPECT_THAT(typeParents(Child), ElementsAre(Parent));
}
-MATCHER_P(ImplicitSpecOf, ClassTemplate, "") {
+MATCHER_P(implicitSpecOf, ClassTemplate, "") {
const ClassTemplateSpecializationDecl *CTS =
dyn_cast<ClassTemplateSpecializationDecl>(arg);
return CTS &&
@@ -255,7 +255,7 @@ struct Child2 : Parent<int> {};
const CXXRecordDecl *Child2 =
dyn_cast<CXXRecordDecl>(&findDecl(AST, "Child2"));
- EXPECT_THAT(typeParents(Child1), ElementsAre(ImplicitSpecOf(Parent)));
+ EXPECT_THAT(typeParents(Child1), ElementsAre(implicitSpecOf(Parent)));
EXPECT_THAT(typeParents(Child2), ElementsAre(ParentSpec));
}
@@ -371,16 +371,16 @@ int main() {
EXPECT_THAT(
*Result,
AllOf(
- WithName("Child"), WithKind(SymbolKind::Struct),
- Parents(AllOf(WithName("Parent1"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("Parent1Def")),
- Parents()),
- AllOf(WithName("Parent3"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("Parent3Def")),
- Parents(AllOf(
- WithName("Parent2"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("Parent2Def")),
- Parents()))))));
+ withName("Child"), withKind(SymbolKind::Struct),
+ parents(AllOf(withName("Parent1"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("Parent1Def")),
+ parents()),
+ AllOf(withName("Parent3"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("Parent3Def")),
+ parents(AllOf(
+ withName("Parent2"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("Parent2Def")),
+ parents()))))));
}
}
@@ -409,13 +409,13 @@ TEST(TypeHierarchy, RecursiveHierarchyUnbounded) {
ASSERT_TRUE(bool(Result));
EXPECT_THAT(
*Result,
- AllOf(WithName("S<0>"), WithKind(SymbolKind::Struct),
- Parents(
- AllOf(WithName("S"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("SDef")),
- Parents(AllOf(WithName("S"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("SDef")),
- Parents()))))));
+ AllOf(withName("S<0>"), withKind(SymbolKind::Struct),
+ parents(
+ AllOf(withName("S"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("SDef")),
+ parents(AllOf(withName("S"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("SDef")),
+ parents()))))));
}
TEST(TypeHierarchy, RecursiveHierarchyBounded) {
@@ -443,20 +443,20 @@ TEST(TypeHierarchy, RecursiveHierarchyBounded) {
ASSERT_TRUE(bool(Result));
EXPECT_THAT(
*Result,
- AllOf(WithName("S<2>"), WithKind(SymbolKind::Struct),
- Parents(AllOf(
- WithName("S<1>"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("SDef")),
- Parents(AllOf(WithName("S<0>"), WithKind(SymbolKind::Struct),
- Parents()))))));
+ AllOf(withName("S<2>"), withKind(SymbolKind::Struct),
+ parents(AllOf(
+ withName("S<1>"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("SDef")),
+ parents(AllOf(withName("S<0>"), withKind(SymbolKind::Struct),
+ parents()))))));
Result = getTypeHierarchy(AST, Source.point("SRefDependent"), 0,
TypeHierarchyDirection::Parents);
ASSERT_TRUE(bool(Result));
EXPECT_THAT(
*Result,
- AllOf(WithName("S"), WithKind(SymbolKind::Struct),
- Parents(AllOf(WithName("S"), WithKind(SymbolKind::Struct),
- SelectionRangeIs(Source.range("SDef")), Parents()))));
+ AllOf(withName("S"), withKind(SymbolKind::Struct),
+ parents(AllOf(withName("S"), withKind(SymbolKind::Struct),
+ selectionRangeIs(Source.range("SDef")), parents()))));
}
TEST(TypeHierarchy, DeriveFromImplicitSpec) {
@@ -480,11 +480,11 @@ TEST(TypeHierarchy, DeriveFromImplicitSpec) {
testPath(TU.Filename));
ASSERT_TRUE(bool(Result));
EXPECT_THAT(*Result,
- AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
- Children(AllOf(WithName("Child1"),
- WithKind(SymbolKind::Struct), Children()),
- AllOf(WithName("Child2"),
- WithKind(SymbolKind::Struct), Children()))));
+ AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+ children(AllOf(withName("Child1"),
+ withKind(SymbolKind::Struct), children()),
+ AllOf(withName("Child2"),
+ withKind(SymbolKind::Struct), children()))));
}
TEST(TypeHierarchy, DeriveFromPartialSpec) {
@@ -505,8 +505,8 @@ TEST(TypeHierarchy, DeriveFromPartialSpec) {
AST, Source.points()[0], 2, TypeHierarchyDirection::Children, Index.get(),
testPath(TU.Filename));
ASSERT_TRUE(bool(Result));
- EXPECT_THAT(*Result, AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
- Children()));
+ EXPECT_THAT(*Result, AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+ children()));
}
TEST(TypeHierarchy, DeriveFromTemplate) {
@@ -532,9 +532,9 @@ TEST(TypeHierarchy, DeriveFromTemplate) {
testPath(TU.Filename));
ASSERT_TRUE(bool(Result));
EXPECT_THAT(*Result,
- AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
- Children(AllOf(WithName("Child"),
- WithKind(SymbolKind::Struct), Children()))));
+ AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+ children(AllOf(withName("Child"),
+ withKind(SymbolKind::Struct), children()))));
}
TEST(TypeHierarchy, Preamble) {
@@ -558,10 +558,10 @@ struct [[Parent]] {
ASSERT_TRUE(Result);
EXPECT_THAT(
*Result,
- AllOf(WithName("Child"),
- Parents(AllOf(WithName("Parent"),
- SelectionRangeIs(HeaderInPreambleAnnotations.range()),
- Parents()))));
+ AllOf(withName("Child"),
+ parents(AllOf(withName("Parent"),
+ selectionRangeIs(HeaderInPreambleAnnotations.range()),
+ parents()))));
}
SymbolID findSymbolIDByName(SymbolIndex *Index, llvm::StringRef Name,
@@ -734,22 +734,22 @@ struct Child2b : Child1 {};
ASSERT_TRUE(bool(Result));
EXPECT_THAT(
*Result,
- AllOf(WithName("Parent"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(),
- Children(AllOf(WithName("Child1"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(), ChildrenNotResolved()))));
+ AllOf(withName("Parent"), withKind(SymbolKind::Struct),
+ parentsNotResolved(),
+ children(AllOf(withName("Child1"), withKind(SymbolKind::Struct),
+ parentsNotResolved(), childrenNotResolved()))));
resolveTypeHierarchy((*Result->children)[0], /*ResolveLevels=*/1,
TypeHierarchyDirection::Children, Index.get());
EXPECT_THAT(
(*Result->children)[0],
- AllOf(WithName("Child1"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(),
- Children(AllOf(WithName("Child2a"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(), ChildrenNotResolved()),
- AllOf(WithName("Child2b"), WithKind(SymbolKind::Struct),
- ParentsNotResolved(), ChildrenNotResolved()))));
+ AllOf(withName("Child1"), withKind(SymbolKind::Struct),
+ parentsNotResolved(),
+ children(AllOf(withName("Child2a"), withKind(SymbolKind::Struct),
+ parentsNotResolved(), childrenNotResolved()),
+ AllOf(withName("Child2b"), withKind(SymbolKind::Struct),
+ parentsNotResolved(), childrenNotResolved()))));
}
} // namespace
diff --git a/clang-tools-extra/clangd/unittests/URITests.cpp b/clang-tools-extra/clangd/unittests/URITests.cpp
index cd734cfe0837..99d59b65cbbc 100644
--- a/clang-tools-extra/clangd/unittests/URITests.cpp
+++ b/clang-tools-extra/clangd/unittests/URITests.cpp
@@ -23,9 +23,9 @@ namespace {
using ::testing::AllOf;
-MATCHER_P(Scheme, S, "") { return arg.scheme() == S; }
-MATCHER_P(Authority, A, "") { return arg.authority() == A; }
-MATCHER_P(Body, B, "") { return arg.body() == B; }
+MATCHER_P(scheme, S, "") { return arg.scheme() == S; }
+MATCHER_P(authority, A, "") { return arg.authority() == A; }
+MATCHER_P(body, B, "") { return arg.body() == B; }
std::string createOrDie(llvm::StringRef AbsolutePath,
llvm::StringRef Scheme = "file") {
@@ -43,10 +43,10 @@ URI parseOrDie(llvm::StringRef Uri) {
}
TEST(PercentEncodingTest, Encode) {
- EXPECT_EQ(URI("x", /*Authority=*/"", "a/b/c").toString(), "x:a/b/c");
- EXPECT_EQ(URI("x", /*Authority=*/"", "a!b;c~").toString(), "x:a%21b%3Bc~");
- EXPECT_EQ(URI("x", /*Authority=*/"", "a123b").toString(), "x:a123b");
- EXPECT_EQ(URI("x", /*Authority=*/"", "a:b;c").toString(), "x:a:b%3Bc");
+ EXPECT_EQ(URI("x", /*authority=*/"", "a/b/c").toString(), "x:a/b/c");
+ EXPECT_EQ(URI("x", /*authority=*/"", "a!b;c~").toString(), "x:a%21b%3Bc~");
+ EXPECT_EQ(URI("x", /*authority=*/"", "a123b").toString(), "x:a123b");
+ EXPECT_EQ(URI("x", /*authority=*/"", "a:b;c").toString(), "x:a:b%3Bc");
}
TEST(PercentEncodingTest, Decode) {
@@ -94,32 +94,32 @@ TEST(URITest, FailedCreate) {
TEST(URITest, Parse) {
EXPECT_THAT(parseOrDie("file://auth/x/y/z"),
- AllOf(Scheme("file"), Authority("auth"), Body("/x/y/z")));
+ AllOf(scheme("file"), authority("auth"), body("/x/y/z")));
EXPECT_THAT(parseOrDie("file://au%3dth/%28x%29/y/%5c%20z"),
- AllOf(Scheme("file"), Authority("au=th"), Body("/(x)/y/\\ z")));
+ AllOf(scheme("file"), authority("au=th"), body("/(x)/y/\\ z")));
EXPECT_THAT(parseOrDie("file:///%28x%29/y/%5c%20z"),
- AllOf(Scheme("file"), Authority(""), Body("/(x)/y/\\ z")));
+ AllOf(scheme("file"), authority(""), body("/(x)/y/\\ z")));
EXPECT_THAT(parseOrDie("file:///x/y/z"),
- AllOf(Scheme("file"), Authority(""), Body("/x/y/z")));
+ AllOf(scheme("file"), authority(""), body("/x/y/z")));
EXPECT_THAT(parseOrDie("file:"),
- AllOf(Scheme("file"), Authority(""), Body("")));
+ AllOf(scheme("file"), authority(""), body("")));
EXPECT_THAT(parseOrDie("file:///x/y/z%2"),
- AllOf(Scheme("file"), Authority(""), Body("/x/y/z%2")));
+ AllOf(scheme("file"), authority(""), body("/x/y/z%2")));
EXPECT_THAT(parseOrDie("http://llvm.org"),
- AllOf(Scheme("http"), Authority("llvm.org"), Body("")));
+ AllOf(scheme("http"), authority("llvm.org"), body("")));
EXPECT_THAT(parseOrDie("http://llvm.org/"),
- AllOf(Scheme("http"), Authority("llvm.org"), Body("/")));
+ AllOf(scheme("http"), authority("llvm.org"), body("/")));
EXPECT_THAT(parseOrDie("http://llvm.org/D"),
- AllOf(Scheme("http"), Authority("llvm.org"), Body("/D")));
+ AllOf(scheme("http"), authority("llvm.org"), body("/D")));
EXPECT_THAT(parseOrDie("http:/"),
- AllOf(Scheme("http"), Authority(""), Body("/")));
+ AllOf(scheme("http"), authority(""), body("/")));
EXPECT_THAT(parseOrDie("urn:isbn:0451450523"),
- AllOf(Scheme("urn"), Authority(""), Body("isbn:0451450523")));
+ AllOf(scheme("urn"), authority(""), body("isbn:0451450523")));
EXPECT_THAT(
parseOrDie("file:///c:/windows/system32/"),
- AllOf(Scheme("file"), Authority(""), Body("/c:/windows/system32/")));
+ AllOf(scheme("file"), authority(""), body("/c:/windows/system32/")));
}
TEST(URITest, ParseFailed) {
diff --git a/clang-tools-extra/clangd/unittests/XRefsTests.cpp b/clang-tools-extra/clangd/unittests/XRefsTests.cpp
index 89076835975a..2921eaa66b57 100644
--- a/clang-tools-extra/clangd/unittests/XRefsTests.cpp
+++ b/clang-tools-extra/clangd/unittests/XRefsTests.cpp
@@ -51,7 +51,7 @@ using ::testing::UnorderedPointwise;
MATCHER_P2(FileRange, File, Range, "") {
return Location{URIForFile::canonicalize(File, testRoot()), Range} == arg;
}
-MATCHER(DeclRange, "") {
+MATCHER(declRange, "") {
const LocatedSymbol &Sym = ::testing::get<0>(arg);
const Range &Range = ::testing::get<1>(arg);
return Sym.PreferredDeclaration.range == Range;
@@ -60,7 +60,7 @@ MATCHER(DeclRange, "") {
// 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();
@@ -134,7 +134,7 @@ TEST(HighlightsTest, All) {
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;
}
}
@@ -271,12 +271,12 @@ TEST(HighlightsTest, ControlFlow) {
auto TU = TestTU::withCode(T.code());
TU.ExtraArgs.push_back("-fexceptions"); // FIXME: stop testing on PS4.
auto AST = TU.build();
- EXPECT_THAT(findDocumentHighlights(AST, T.point()), HighlightsFrom(T))
+ EXPECT_THAT(findDocumentHighlights(AST, T.point()), highlightsFrom(T))
<< Test;
}
}
-MATCHER_P3(Sym, Name, Decl, DefOrNone, "") {
+MATCHER_P3(sym, Name, Decl, DefOrNone, "") {
llvm::Optional<Range> Def = DefOrNone;
if (Name != arg.Name) {
*result_listener << "Name is " << arg.Name;
@@ -304,11 +304,11 @@ MATCHER_P3(Sym, Name, Decl, DefOrNone, "") {
return true;
}
-MATCHER_P(Sym, Name, "") { return arg.Name == Name; }
+MATCHER_P(sym, Name, "") { return arg.Name == Name; }
-MATCHER_P(RangeIs, R, "") { return arg.Loc.range == R; }
-MATCHER_P(AttrsAre, A, "") { return arg.Attributes == A; }
-MATCHER_P(HasID, ID, "") { return arg.ID == ID; }
+MATCHER_P(rangeIs, R, "") { return arg.Loc.range == R; }
+MATCHER_P(attrsAre, A, "") { return arg.Attributes == A; }
+MATCHER_P(hasID, ID, "") { return arg.ID == ID; }
TEST(LocateSymbol, WithIndex) {
Annotations SymbolHeader(R"cpp(
@@ -340,7 +340,7 @@ TEST(LocateSymbol, WithIndex) {
}
)cpp");
EXPECT_THAT(LocateWithIndex(Test),
- ElementsAre(Sym("f1", Test.range(), SymbolCpp.range("f1"))));
+ ElementsAre(sym("f1", Test.range(), SymbolCpp.range("f1"))));
Test = Annotations(R"cpp(// definition in AST.
void [[f1]]() {}
@@ -349,14 +349,14 @@ TEST(LocateSymbol, WithIndex) {
}
)cpp");
EXPECT_THAT(LocateWithIndex(Test),
- ElementsAre(Sym("f1", SymbolHeader.range("f1"), Test.range())));
+ ElementsAre(sym("f1", SymbolHeader.range("f1"), Test.range())));
Test = Annotations(R"cpp(// forward declaration in AST.
class [[Foo]];
F^oo* create();
)cpp");
EXPECT_THAT(LocateWithIndex(Test),
- ElementsAre(Sym("Foo", Test.range(), SymbolHeader.range("foo"))));
+ ElementsAre(sym("Foo", Test.range(), SymbolHeader.range("foo"))));
Test = Annotations(R"cpp(// definition in AST.
class [[Forward]] {};
@@ -364,7 +364,7 @@ TEST(LocateSymbol, WithIndex) {
)cpp");
EXPECT_THAT(
LocateWithIndex(Test),
- ElementsAre(Sym("Forward", SymbolHeader.range("forward"), Test.range())));
+ ElementsAre(sym("Forward", SymbolHeader.range("forward"), Test.range())));
}
TEST(LocateSymbol, AnonymousStructFields) {
@@ -382,10 +382,10 @@ TEST(LocateSymbol, AnonymousStructFields) {
TestTU TU = TestTU::withCode(Code.code());
auto AST = TU.build();
EXPECT_THAT(locateSymbolAt(AST, Code.point("1"), TU.index().get()),
- UnorderedElementsAre(Sym("x", Code.range("1"), Code.range("1"))));
+ UnorderedElementsAre(sym("x", Code.range("1"), Code.range("1"))));
EXPECT_THAT(
locateSymbolAt(AST, Code.point("2"), TU.index().get()),
- UnorderedElementsAre(Sym("Foo", Code.range("2"), Code.range("2"))));
+ UnorderedElementsAre(sym("Foo", Code.range("2"), Code.range("2"))));
}
TEST(LocateSymbol, FindOverrides) {
@@ -400,8 +400,8 @@ TEST(LocateSymbol, FindOverrides) {
TestTU TU = TestTU::withCode(Code.code());
auto AST = TU.build();
EXPECT_THAT(locateSymbolAt(AST, Code.point(), TU.index().get()),
- UnorderedElementsAre(Sym("foo", Code.range("1"), llvm::None),
- Sym("foo", Code.range("2"), llvm::None)));
+ UnorderedElementsAre(sym("foo", Code.range("1"), llvm::None),
+ sym("foo", Code.range("2"), llvm::None)));
}
TEST(LocateSymbol, WithIndexPreferredLocation) {
@@ -428,12 +428,12 @@ TEST(LocateSymbol, WithIndexPreferredLocation) {
{
auto Locs = clangd::locateSymbolAt(AST, Test.point("p"), Index.get());
auto CodeGenLoc = SymbolHeader.range("p");
- EXPECT_THAT(Locs, ElementsAre(Sym("Proto", CodeGenLoc, CodeGenLoc)));
+ EXPECT_THAT(Locs, ElementsAre(sym("Proto", CodeGenLoc, CodeGenLoc)));
}
{
auto Locs = clangd::locateSymbolAt(AST, Test.point("f"), Index.get());
auto CodeGenLoc = SymbolHeader.range("f");
- EXPECT_THAT(Locs, ElementsAre(Sym("func", CodeGenLoc, CodeGenLoc)));
+ EXPECT_THAT(Locs, ElementsAre(sym("func", CodeGenLoc, CodeGenLoc)));
}
}
@@ -1000,12 +1000,12 @@ TEST(LocateSymbol, ValidSymbolID) {
auto AST = TU.build();
auto Index = TU.index();
EXPECT_THAT(locateSymbolAt(AST, T.point("add"), Index.get()),
- ElementsAre(AllOf(Sym("add"),
- HasID(getSymbolID(&findDecl(AST, "add"))))));
+ ElementsAre(AllOf(sym("add"),
+ hasID(getSymbolID(&findDecl(AST, "add"))))));
EXPECT_THAT(
locateSymbolAt(AST, T.point("MACRO"), Index.get()),
- ElementsAre(AllOf(Sym("MACRO"),
- HasID(findSymbol(TU.headerSymbols(), "MACRO").ID))));
+ ElementsAre(AllOf(sym("MACRO"),
+ hasID(findSymbol(TU.headerSymbols(), "MACRO").ID))));
}
TEST(LocateSymbol, AllMulti) {
@@ -1155,8 +1155,8 @@ TEST(LocateSymbol, TextualSmoke) {
auto Index = TU.index();
EXPECT_THAT(
locateSymbolAt(AST, T.point(), Index.get()),
- ElementsAre(AllOf(Sym("MyClass", T.range(), T.range()),
- HasID(getSymbolID(&findDecl(AST, "MyClass"))))));
+ ElementsAre(AllOf(sym("MyClass", T.range(), T.range()),
+ hasID(getSymbolID(&findDecl(AST, "MyClass"))))));
}
TEST(LocateSymbol, Textual) {
@@ -1263,33 +1263,33 @@ TEST(LocateSymbol, Ambiguous) {
TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
auto AST = TU.build();
// Ordered assertions are deliberate: we expect a predictable order.
- EXPECT_THAT(locateSymbolAt(AST, T.point("1")), ElementsAre(Sym("str")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("2")), ElementsAre(Sym("str")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("3")), ElementsAre(Sym("f")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("4")), ElementsAre(Sym("g")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("5")), ElementsAre(Sym("f")));
- EXPECT_THAT(locateSymbolAt(AST, T.point("6")), ElementsAre(Sym("str")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("1")), ElementsAre(sym("str")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("2")), ElementsAre(sym("str")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("3")), ElementsAre(sym("f")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("4")), ElementsAre(sym("g")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("5")), ElementsAre(sym("f")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("6")), ElementsAre(sym("str")));
// FIXME: Target the constructor as well.
- EXPECT_THAT(locateSymbolAt(AST, T.point("7")), ElementsAre(Sym("abc")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("7")), ElementsAre(sym("abc")));
// FIXME: Target the constructor as well.
- EXPECT_THAT(locateSymbolAt(AST, T.point("8")), ElementsAre(Sym("abcd")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("8")), ElementsAre(sym("abcd")));
// FIXME: Target the constructor as well.
- EXPECT_THAT(locateSymbolAt(AST, T.point("9")), ElementsAre(Sym("Foo")));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("9")), ElementsAre(sym("Foo")));
EXPECT_THAT(locateSymbolAt(AST, T.point("10")),
- ElementsAre(Sym("Foo", T.range("ConstructorLoc"), llvm::None)));
+ ElementsAre(sym("Foo", T.range("ConstructorLoc"), llvm::None)));
EXPECT_THAT(locateSymbolAt(AST, T.point("11")),
- ElementsAre(Sym("Foo", T.range("ConstructorLoc"), llvm::None)));
+ ElementsAre(sym("Foo", T.range("ConstructorLoc"), llvm::None)));
// These assertions are unordered because the order comes from
// CXXRecordDecl::lookupDependentName() which doesn't appear to provide
// an order guarantee.
EXPECT_THAT(locateSymbolAt(AST, T.point("12")),
UnorderedElementsAre(
- Sym("bar", T.range("NonstaticOverload1"), llvm::None),
- Sym("bar", T.range("NonstaticOverload2"), llvm::None)));
+ sym("bar", T.range("NonstaticOverload1"), llvm::None),
+ sym("bar", T.range("NonstaticOverload2"), llvm::None)));
EXPECT_THAT(
locateSymbolAt(AST, T.point("13")),
- UnorderedElementsAre(Sym("baz", T.range("StaticOverload1"), llvm::None),
- Sym("baz", T.range("StaticOverload2"), llvm::None)));
+ UnorderedElementsAre(sym("baz", T.range("StaticOverload1"), llvm::None),
+ sym("baz", T.range("StaticOverload2"), llvm::None)));
}
TEST(LocateSymbol, TextualDependent) {
@@ -1321,8 +1321,8 @@ TEST(LocateSymbol, TextualDependent) {
auto Results = locateSymbolAt(AST, Source.point(), Index.get());
EXPECT_THAT(Results,
UnorderedElementsAre(
- Sym("uniqueMethodName", Header.range("FooLoc"), llvm::None),
- Sym("uniqueMethodName", Header.range("BarLoc"), llvm::None)));
+ sym("uniqueMethodName", Header.range("FooLoc"), llvm::None),
+ sym("uniqueMethodName", Header.range("BarLoc"), llvm::None)));
}
TEST(LocateSymbol, Alias) {
@@ -1406,7 +1406,7 @@ TEST(LocateSymbol, Alias) {
auto T = Annotations(Case);
auto AST = TestTU::withCode(T.code()).build();
EXPECT_THAT(locateSymbolAt(AST, T.point()),
- UnorderedPointwise(DeclRange(), T.ranges()));
+ UnorderedPointwise(declRange(), T.ranges()));
}
}
@@ -1454,7 +1454,7 @@ int [[bar_not_preamble]];
auto Locations =
runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("p1"));
EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo", SourceAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo", SourceAnnotations.range(),
SourceAnnotations.range())));
// Go to a definition in header_in_preamble.h.
@@ -1462,14 +1462,14 @@ int [[bar_not_preamble]];
EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
EXPECT_THAT(
*Locations,
- ElementsAre(Sym("bar_preamble", HeaderInPreambleAnnotations.range(),
+ ElementsAre(sym("bar_preamble", HeaderInPreambleAnnotations.range(),
HeaderInPreambleAnnotations.range())));
// Go to a definition in header_not_in_preamble.h.
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("p3"));
EXPECT_TRUE(bool(Locations)) << "findDefinitions returned an error";
EXPECT_THAT(*Locations,
- ElementsAre(Sym("bar_not_preamble",
+ ElementsAre(sym("bar_not_preamble",
HeaderNotInPreambleAnnotations.range(),
HeaderNotInPreambleAnnotations.range())));
}
@@ -1504,24 +1504,24 @@ TEST(GoToInclude, All) {
// Test include in preamble.
auto Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point());
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
// Test include in preamble, last char.
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("2"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("3"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
// Test include outside of preamble.
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("6"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
// Test a few positions that do not result in Locations.
@@ -1531,12 +1531,12 @@ TEST(GoToInclude, All) {
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("5"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
Locations = runLocateSymbolAt(Server, FooCpp, SourceAnnotations.point("7"));
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
// Objective C #import directive.
@@ -1549,7 +1549,7 @@ TEST(GoToInclude, All) {
runAddDocument(Server, FooM, ObjC.code());
Locations = runLocateSymbolAt(Server, FooM, ObjC.point());
ASSERT_TRUE(bool(Locations)) << "locateSymbolAt returned an error";
- EXPECT_THAT(*Locations, ElementsAre(Sym("foo.h", HeaderAnnotations.range(),
+ EXPECT_THAT(*Locations, ElementsAre(sym("foo.h", HeaderAnnotations.range(),
HeaderAnnotations.range())));
}
@@ -1575,7 +1575,7 @@ TEST(LocateSymbol, WithPreamble) {
// LocateSymbol goes to a #include file: the result comes from the preamble.
EXPECT_THAT(
cantFail(runLocateSymbolAt(Server, FooCpp, FooWithHeader.point())),
- ElementsAre(Sym("foo.h", FooHeader.range(), FooHeader.range())));
+ ElementsAre(sym("foo.h", FooHeader.range(), FooHeader.range())));
// Only preamble is built, and no AST is built in this request.
Server.addDocument(FooCpp, FooWithoutHeader.code(), "null",
@@ -1584,7 +1584,7 @@ TEST(LocateSymbol, WithPreamble) {
// stale one.
EXPECT_THAT(
cantFail(runLocateSymbolAt(Server, FooCpp, FooWithoutHeader.point())),
- ElementsAre(Sym("foo", FooWithoutHeader.range(), llvm::None)));
+ ElementsAre(sym("foo", FooWithoutHeader.range(), llvm::None)));
// Reset test environment.
runAddDocument(Server, FooCpp, FooWithHeader.code());
@@ -1594,7 +1594,7 @@ TEST(LocateSymbol, WithPreamble) {
// Use the AST being built in above request.
EXPECT_THAT(
cantFail(runLocateSymbolAt(Server, FooCpp, FooWithoutHeader.point())),
- ElementsAre(Sym("foo", FooWithoutHeader.range(), llvm::None)));
+ ElementsAre(sym("foo", FooWithoutHeader.range(), llvm::None)));
}
TEST(LocateSymbol, NearbyTokenSmoke) {
@@ -1605,7 +1605,7 @@ TEST(LocateSymbol, NearbyTokenSmoke) {
auto AST = TestTU::withCode(T.code()).build();
// We don't pass an index, so can't hit index-based fallback.
EXPECT_THAT(locateSymbolAt(AST, T.point()),
- ElementsAre(Sym("err", T.range(), T.range())));
+ ElementsAre(sym("err", T.range(), T.range())));
}
TEST(LocateSymbol, NearbyIdentifier) {
@@ -1754,7 +1754,7 @@ TEST(FindImplementations, Inheritance) {
for (StringRef Label : {"0", "1", "2", "3", "4", "5", "6", "7"}) {
for (const auto &Point : Code.points(Label)) {
EXPECT_THAT(findImplementations(AST, Point, Index.get()),
- UnorderedPointwise(DeclRange(), Code.ranges(Label)))
+ UnorderedPointwise(declRange(), Code.ranges(Label)))
<< Code.code() << " at " << Point << " for Label " << Label;
}
}
@@ -1778,8 +1778,8 @@ TEST(FindImplementations, CaptureDefintion) {
auto AST = TU.build();
EXPECT_THAT(
findImplementations(AST, Code.point(), TU.index().get()),
- UnorderedElementsAre(Sym("Foo", Code.range("Decl"), Code.range("Def")),
- Sym("Foo", Code.range("Child2"), llvm::None)))
+ UnorderedElementsAre(sym("Foo", Code.range("Decl"), Code.range("Def")),
+ sym("Foo", Code.range("Child2"), llvm::None)))
<< Test;
}
@@ -1828,7 +1828,7 @@ TEST(FindType, All) {
ASSERT_GT(A.points().size(), 0u) << Case;
for (auto Pos : A.points())
EXPECT_THAT(findType(AST, Pos),
- ElementsAre(Sym("Target", HeaderA.range(), HeaderA.range())))
+ ElementsAre(sym("Target", HeaderA.range(), HeaderA.range())))
<< Case;
}
@@ -1841,7 +1841,7 @@ TEST(FindType, All) {
ParsedAST AST = TU.build();
EXPECT_THAT(findType(AST, A.point()),
- Not(Contains(Sym("Target", HeaderA.range(), HeaderA.range()))))
+ Not(Contains(sym("Target", HeaderA.range(), HeaderA.range()))))
<< Case;
}
}
@@ -1852,23 +1852,23 @@ void checkFindRefs(llvm::StringRef Test, bool UseIndex = false) {
auto AST = TU.build();
std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
for (const auto &R : T.ranges())
- ExpectedLocations.push_back(AllOf(RangeIs(R), AttrsAre(0u)));
+ ExpectedLocations.push_back(AllOf(rangeIs(R), attrsAre(0u)));
// $def is actually shorthand for both definition and declaration.
// If we have cases that are definition-only, we should change this.
for (const auto &R : T.ranges("def"))
ExpectedLocations.push_back(
- AllOf(RangeIs(R), AttrsAre(ReferencesResult::Definition |
+ AllOf(rangeIs(R), attrsAre(ReferencesResult::Definition |
ReferencesResult::Declaration)));
for (const auto &R : T.ranges("decl"))
ExpectedLocations.push_back(
- AllOf(RangeIs(R), AttrsAre(ReferencesResult::Declaration)));
+ AllOf(rangeIs(R), attrsAre(ReferencesResult::Declaration)));
for (const auto &R : T.ranges("overridedecl"))
ExpectedLocations.push_back(AllOf(
- RangeIs(R),
- AttrsAre(ReferencesResult::Declaration | ReferencesResult::Override)));
+ rangeIs(R),
+ attrsAre(ReferencesResult::Declaration | ReferencesResult::Override)));
for (const auto &R : T.ranges("overridedef"))
ExpectedLocations.push_back(
- AllOf(RangeIs(R), AttrsAre(ReferencesResult::Declaration |
+ AllOf(rangeIs(R), attrsAre(ReferencesResult::Declaration |
ReferencesResult::Definition |
ReferencesResult::Override)));
for (const auto &P : T.points()) {
@@ -2126,7 +2126,7 @@ TEST(FindReferences, MainFileReferencesOnly) {
std::vector<Matcher<ReferencesResult::Reference>> ExpectedLocations;
for (const auto &R : Code.ranges())
- ExpectedLocations.push_back(RangeIs(R));
+ ExpectedLocations.push_back(rangeIs(R));
EXPECT_THAT(findReferences(AST, Code.point(), 0).References,
ElementsAreArray(ExpectedLocations))
<< Test;
@@ -2195,7 +2195,7 @@ TEST(FindReferences, NeedsIndexForSymbols) {
// References in main file are returned without index.
EXPECT_THAT(
findReferences(AST, Main.point(), 0, /*Index=*/nullptr).References,
- ElementsAre(RangeIs(Main.range())));
+ ElementsAre(rangeIs(Main.range())));
Annotations IndexedMain(R"cpp(
int [[foo]]() { return 42; }
)cpp");
@@ -2207,9 +2207,9 @@ TEST(FindReferences, NeedsIndexForSymbols) {
IndexedTU.HeaderCode = Header;
EXPECT_THAT(
findReferences(AST, Main.point(), 0, IndexedTU.index().get()).References,
- ElementsAre(RangeIs(Main.range()),
- AllOf(RangeIs(IndexedMain.range()),
- AttrsAre(ReferencesResult::Declaration |
+ ElementsAre(rangeIs(Main.range()),
+ AllOf(rangeIs(IndexedMain.range()),
+ attrsAre(ReferencesResult::Declaration |
ReferencesResult::Definition))));
auto LimitRefs =
findReferences(AST, Main.point(), /*Limit*/ 1, IndexedTU.index().get());
@@ -2219,7 +2219,7 @@ TEST(FindReferences, NeedsIndexForSymbols) {
// Avoid indexed results for the main file. Use AST for the mainfile.
TU.Code = ("\n\n" + Main.code()).str();
EXPECT_THAT(findReferences(AST, Main.point(), 0, TU.index().get()).References,
- ElementsAre(RangeIs(Main.range())));
+ ElementsAre(rangeIs(Main.range())));
}
TEST(FindReferences, NeedsIndexForMacro) {
@@ -2237,7 +2237,7 @@ TEST(FindReferences, NeedsIndexForMacro) {
// References in main file are returned without index.
EXPECT_THAT(
findReferences(AST, Main.point(), 0, /*Index=*/nullptr).References,
- ElementsAre(RangeIs(Main.range())));
+ ElementsAre(rangeIs(Main.range())));
Annotations IndexedMain(R"cpp(
int indexed_main() {
@@ -2252,7 +2252,7 @@ TEST(FindReferences, NeedsIndexForMacro) {
IndexedTU.HeaderCode = Header;
EXPECT_THAT(
findReferences(AST, Main.point(), 0, IndexedTU.index().get()).References,
- ElementsAre(RangeIs(Main.range()), RangeIs(IndexedMain.range())));
+ ElementsAre(rangeIs(Main.range()), rangeIs(IndexedMain.range())));
auto LimitRefs =
findReferences(AST, Main.point(), /*Limit*/ 1, IndexedTU.index().get());
EXPECT_EQ(1u, LimitRefs.References.size());
diff --git a/clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp b/clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp
index 87002d3cfa86..600ce63ee2b1 100644
--- a/clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp
+++ b/clang-tools-extra/clangd/unittests/support/ThreadingTests.cpp
@@ -29,7 +29,7 @@ TEST_F(ThreadingTest, TaskRunner) {
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 @@ TEST_F(ThreadingTest, TaskRunner) {
// 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 @@ TEST_F(ThreadingTest, TaskRunner) {
{
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
index 0fda92a6aeff..f7603cedc2bd 100644
--- a/clang-tools-extra/clangd/unittests/support/TraceTests.cpp
+++ b/clang-tools-extra/clangd/unittests/support/TraceTests.cpp
@@ -28,7 +28,7 @@ using testing::ElementsAre;
using testing::SizeIs;
using testing::StartsWith;
-MATCHER_P(StringNode, Val, "") {
+MATCHER_P(stringNode, Val, "") {
if (arg->getType() != llvm::yaml::Node::NK_Scalar) {
*result_listener << "is a " << arg->getVerbatimTag();
return false;
@@ -39,7 +39,7 @@ MATCHER_P(StringNode, Val, "") {
// 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) {
@@ -109,24 +109,24 @@ TEST(TraceTest, SmokeTest) {
// (The order doesn't matter, but the YAML parser is awkward to use otherwise)
auto Prop = Root->begin();
ASSERT_NE(Prop, Root->end()) << "Expected displayTimeUnit property";
- ASSERT_THAT(Prop->getKey(), StringNode("displayTimeUnit"));
- EXPECT_THAT(Prop->getValue(), StringNode("ns"));
+ ASSERT_THAT(Prop->getKey(), stringNode("displayTimeUnit"));
+ EXPECT_THAT(Prop->getValue(), stringNode("ns"));
ASSERT_NE(++Prop, Root->end()) << "Expected traceEvents property";
- EXPECT_THAT(Prop->getKey(), StringNode("traceEvents"));
+ EXPECT_THAT(Prop->getKey(), stringNode("traceEvents"));
auto *Events =
llvm::dyn_cast_or_null<llvm::yaml::SequenceNode>(Prop->getValue());
ASSERT_NE(Events, nullptr) << "traceEvents should be an array";
auto Event = Events->begin();
ASSERT_NE(Event, Events->end()) << "Expected process name";
- EXPECT_TRUE(VerifyObject(*Event, {{"ph", "M"}, {"name", "process_name"}}));
+ EXPECT_TRUE(verifyObject(*Event, {{"ph", "M"}, {"name", "process_name"}}));
if (ThreadsHaveNames) {
ASSERT_NE(++Event, Events->end()) << "Expected thread name";
- EXPECT_TRUE(VerifyObject(*Event, {{"ph", "M"}, {"name", "thread_name"}}));
+ EXPECT_TRUE(verifyObject(*Event, {{"ph", "M"}, {"name", "thread_name"}}));
}
ASSERT_NE(++Event, Events->end()) << "Expected log message";
- EXPECT_TRUE(VerifyObject(*Event, {{"ph", "i"}, {"name", "Log"}}));
+ EXPECT_TRUE(verifyObject(*Event, {{"ph", "i"}, {"name", "Log"}}));
ASSERT_NE(++Event, Events->end()) << "Expected span end";
- EXPECT_TRUE(VerifyObject(*Event, {{"ph", "X"}, {"name", "A"}}));
+ EXPECT_TRUE(verifyObject(*Event, {{"ph", "X"}, {"name", "A"}}));
ASSERT_EQ(++Event, Events->end());
ASSERT_EQ(++Prop, Root->end());
}
More information about the cfe-commits
mailing list