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

258 lines
8.5 KiB
C++

//===-- CallHierarchyTests.cpp ---------------------------*- C++ -*-------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "Annotations.h"
#include "Compiler.h"
#include "Matchers.h"
#include "ParsedAST.h"
#include "SyncAPI.h"
#include "TestFS.h"
#include "TestTU.h"
#include "TestWorkspace.h"
#include "XRefs.h"
#include "index/FileIndex.h"
#include "index/SymbolCollector.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/Index/IndexingAction.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/ScopedPrinter.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
namespace clang {
namespace clangd {
namespace {
using ::testing::AllOf;
using ::testing::ElementsAre;
using ::testing::Field;
using ::testing::IsEmpty;
using ::testing::Matcher;
using ::testing::UnorderedElementsAre;
// Helpers for matching call hierarchy data structures.
MATCHER_P(WithName, N, "") { return arg.name == N; }
MATCHER_P(WithSelectionRange, R, "") { return arg.selectionRange == R; }
template <class ItemMatcher>
::testing::Matcher<CallHierarchyIncomingCall> From(ItemMatcher M) {
return Field(&CallHierarchyIncomingCall::from, M);
}
template <class... RangeMatchers>
::testing::Matcher<CallHierarchyIncomingCall> FromRanges(RangeMatchers... M) {
return Field(&CallHierarchyIncomingCall::fromRanges,
UnorderedElementsAre(M...));
}
TEST(CallHierarchy, IncomingOneFile) {
Annotations Source(R"cpp(
void call^ee(int);
void caller1() {
$Callee[[callee]](42);
}
void caller2() {
$Caller1A[[caller1]]();
$Caller1B[[caller1]]();
}
void caller3() {
$Caller1C[[caller1]]();
$Caller2[[caller2]]();
}
)cpp");
TestTU TU = TestTU::withCode(Source.code());
auto AST = TU.build();
auto Index = TU.index();
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(WithName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
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"),
Source.range("Caller1B"))),
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")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
}
TEST(CallHierarchy, MainFileOnlyRef) {
// In addition to testing that we store refs to main-file only symbols,
// this tests that anonymous namespaces do not interfere with the
// symbol re-identification process in callHierarchyItemToSymbo().
Annotations Source(R"cpp(
void call^ee(int);
namespace {
void caller1() {
$Callee[[callee]](42);
}
}
void caller2() {
$Caller1[[caller1]]();
}
)cpp");
TestTU TU = TestTU::withCode(Source.code());
auto AST = TU.build();
auto Index = TU.index();
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(WithName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
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")))));
}
TEST(CallHierarchy, IncomingQualified) {
Annotations Source(R"cpp(
namespace ns {
struct Waldo {
void find();
};
void Waldo::find() {}
void caller1(Waldo &W) {
W.$Caller1[[f^ind]]();
}
void caller2(Waldo &W) {
W.$Caller2[[find]]();
}
}
)cpp");
TestTU TU = TestTU::withCode(Source.code());
auto AST = TU.build();
auto Index = TU.index();
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Source.point(), testPath(TU.Filename));
ASSERT_THAT(Items, ElementsAre(WithName("Waldo::find")));
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")))));
}
TEST(CallHierarchy, IncomingMultiFile) {
// The test uses a .hh suffix for header files to get clang
// to parse them in C++ mode. .h files are parsed in C mode
// by default, which causes problems because e.g. symbol
// USRs are different in C mode (do not include function signatures).
Annotations CalleeH(R"cpp(
void calle^e(int);
)cpp");
Annotations CalleeC(R"cpp(
#include "callee.hh"
void calle^e(int) {}
)cpp");
Annotations Caller1H(R"cpp(
void caller1();
)cpp");
Annotations Caller1C(R"cpp(
#include "callee.hh"
#include "caller1.hh"
void caller1() {
[[calle^e]](42);
}
)cpp");
Annotations Caller2H(R"cpp(
void caller2();
)cpp");
Annotations Caller2C(R"cpp(
#include "caller1.hh"
#include "caller2.hh"
void caller2() {
$A[[caller1]]();
$B[[caller1]]();
}
)cpp");
Annotations Caller3C(R"cpp(
#include "caller1.hh"
#include "caller2.hh"
void caller3() {
$Caller1[[caller1]]();
$Caller2[[caller2]]();
}
)cpp");
TestWorkspace Workspace;
Workspace.addSource("callee.hh", CalleeH.code());
Workspace.addSource("caller1.hh", Caller1H.code());
Workspace.addSource("caller2.hh", Caller2H.code());
Workspace.addMainFile("callee.cc", CalleeC.code());
Workspace.addMainFile("caller1.cc", Caller1C.code());
Workspace.addMainFile("caller2.cc", Caller2C.code());
Workspace.addMainFile("caller3.cc", Caller3C.code());
auto Index = Workspace.index();
auto CheckCallHierarchy = [&](ParsedAST &AST, Position Pos, PathRef TUPath) {
std::vector<CallHierarchyItem> Items =
prepareCallHierarchy(AST, Pos, TUPath);
ASSERT_THAT(Items, ElementsAre(WithName("callee")));
auto IncomingLevel1 = incomingCalls(Items[0], Index.get());
ASSERT_THAT(IncomingLevel1,
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")))));
auto IncomingLevel3 = incomingCalls(IncomingLevel2[0].from, Index.get());
ASSERT_THAT(IncomingLevel3,
ElementsAre(AllOf(From(WithName("caller3")),
FromRanges(Caller3C.range("Caller2")))));
auto IncomingLevel4 = incomingCalls(IncomingLevel3[0].from, Index.get());
EXPECT_THAT(IncomingLevel4, IsEmpty());
};
// Check that invoking from a call site works.
auto AST = Workspace.openFile("caller1.cc");
ASSERT_TRUE(bool(AST));
CheckCallHierarchy(*AST, Caller1C.point(), testPath("caller1.cc"));
// Check that invoking from the declaration site works.
AST = Workspace.openFile("callee.hh");
ASSERT_TRUE(bool(AST));
CheckCallHierarchy(*AST, CalleeH.point(), testPath("callee.hh"));
// Check that invoking from the definition site works.
AST = Workspace.openFile("callee.cc");
ASSERT_TRUE(bool(AST));
CheckCallHierarchy(*AST, CalleeC.point(), testPath("callee.cc"));
}
} // namespace
} // namespace clangd
} // namespace clang