summaryrefslogtreecommitdiffstats
path: root/unittests/Index/IndexTests.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'unittests/Index/IndexTests.cpp')
-rw-r--r--unittests/Index/IndexTests.cpp190
1 files changed, 181 insertions, 9 deletions
diff --git a/unittests/Index/IndexTests.cpp b/unittests/Index/IndexTests.cpp
index 2d4463d833..bbd5db3d39 100644
--- a/unittests/Index/IndexTests.cpp
+++ b/unittests/Index/IndexTests.cpp
@@ -1,14 +1,16 @@
//===--- IndexTests.cpp - Test indexing actions -----------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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 "clang/AST/ASTConsumer.h"
+#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
+#include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/SourceManager.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendAction.h"
#include "clang/Index/IndexDataConsumer.h"
@@ -24,40 +26,86 @@
namespace clang {
namespace index {
+namespace {
+struct Position {
+ size_t Line = 0;
+ size_t Column = 0;
+
+ Position(size_t Line = 0, size_t Column = 0) : Line(Line), Column(Column) {}
+
+ static Position fromSourceLocation(SourceLocation Loc,
+ const SourceManager &SM) {
+ FileID FID;
+ unsigned Offset;
+ std::tie(FID, Offset) = SM.getDecomposedSpellingLoc(Loc);
+ Position P;
+ P.Line = SM.getLineNumber(FID, Offset);
+ P.Column = SM.getColumnNumber(FID, Offset);
+ return P;
+ }
+};
+
+bool operator==(const Position &LHS, const Position &RHS) {
+ return std::tie(LHS.Line, LHS.Column) == std::tie(RHS.Line, RHS.Column);
+}
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Position &Pos) {
+ return OS << Pos.Line << ':' << Pos.Column;
+}
struct TestSymbol {
std::string QName;
+ Position WrittenPos;
+ Position DeclPos;
+ SymbolInfo SymInfo;
+ SymbolRoleSet Roles;
// FIXME: add more information.
};
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const TestSymbol &S) {
- return OS << S.QName;
+ return OS << S.QName << '[' << S.WrittenPos << ']' << '@' << S.DeclPos << '('
+ << static_cast<unsigned>(S.SymInfo.Kind) << ')';
}
-namespace {
class Indexer : public IndexDataConsumer {
public:
+ void initialize(ASTContext &Ctx) override {
+ AST = &Ctx;
+ IndexDataConsumer::initialize(Ctx);
+ }
+
bool handleDeclOccurence(const Decl *D, SymbolRoleSet Roles,
- ArrayRef<SymbolRelation>, SourceLocation,
+ ArrayRef<SymbolRelation>, SourceLocation Loc,
ASTNodeInfo) override {
const auto *ND = llvm::dyn_cast<NamedDecl>(D);
if (!ND)
return true;
TestSymbol S;
+ S.SymInfo = getSymbolInfo(D);
S.QName = ND->getQualifiedNameAsString();
+ S.WrittenPos = Position::fromSourceLocation(Loc, AST->getSourceManager());
+ S.DeclPos =
+ Position::fromSourceLocation(D->getLocation(), AST->getSourceManager());
+ S.Roles = Roles;
Symbols.push_back(std::move(S));
return true;
}
- bool handleMacroOccurence(const IdentifierInfo *Name, const MacroInfo *,
- SymbolRoleSet, SourceLocation) override {
+ bool handleMacroOccurence(const IdentifierInfo *Name, const MacroInfo *MI,
+ SymbolRoleSet Roles, SourceLocation Loc) override {
TestSymbol S;
+ S.SymInfo = getSymbolInfoForMacro(*MI);
S.QName = Name->getName();
+ S.WrittenPos = Position::fromSourceLocation(Loc, AST->getSourceManager());
+ S.DeclPos = Position::fromSourceLocation(MI->getDefinitionLoc(),
+ AST->getSourceManager());
+ S.Roles = Roles;
Symbols.push_back(std::move(S));
return true;
}
std::vector<TestSymbol> Symbols;
+ const ASTContext *AST = nullptr;
};
class IndexAction : public ASTFrontendAction {
@@ -94,11 +142,16 @@ private:
IndexingOptions Opts;
};
+using testing::AllOf;
using testing::Contains;
using testing::Not;
using testing::UnorderedElementsAre;
MATCHER_P(QName, Name, "") { return arg.QName == Name; }
+MATCHER_P(WrittenAt, Pos, "") { return arg.WrittenPos == Pos; }
+MATCHER_P(DeclAt, Pos, "") { return arg.DeclPos == Pos; }
+MATCHER_P(Kind, SymKind, "") { return arg.SymInfo.Kind == SymKind; }
+MATCHER_P(HasRole, Role, "") { return arg.Roles & static_cast<unsigned>(Role); }
TEST(IndexTest, Simple) {
auto Index = std::make_shared<Indexer>();
@@ -120,6 +173,125 @@ TEST(IndexTest, IndexPreprocessorMacros) {
EXPECT_THAT(Index->Symbols, UnorderedElementsAre());
}
+TEST(IndexTest, IndexParametersInDecls) {
+ std::string Code = "void foo(int bar);";
+ auto Index = std::make_shared<Indexer>();
+ IndexingOptions Opts;
+ Opts.IndexFunctionLocals = true;
+ Opts.IndexParametersInDeclarations = true;
+ tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+ EXPECT_THAT(Index->Symbols, Contains(QName("bar")));
+
+ Opts.IndexParametersInDeclarations = false;
+ Index->Symbols.clear();
+ tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+ EXPECT_THAT(Index->Symbols, Not(Contains(QName("bar"))));
+}
+
+TEST(IndexTest, IndexExplicitTemplateInstantiation) {
+ std::string Code = R"cpp(
+ template <typename T>
+ struct Foo { void bar() {} };
+ template <>
+ struct Foo<int> { void bar() {} };
+ void foo() {
+ Foo<char> abc;
+ Foo<int> b;
+ }
+ )cpp";
+ auto Index = std::make_shared<Indexer>();
+ IndexingOptions Opts;
+ tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+ EXPECT_THAT(Index->Symbols,
+ AllOf(Contains(AllOf(QName("Foo"), WrittenAt(Position(8, 7)),
+ DeclAt(Position(5, 12)))),
+ Contains(AllOf(QName("Foo"), WrittenAt(Position(7, 7)),
+ DeclAt(Position(3, 12))))));
+}
+
+TEST(IndexTest, IndexTemplateInstantiationPartial) {
+ std::string Code = R"cpp(
+ template <typename T1, typename T2>
+ struct Foo { void bar() {} };
+ template <typename T>
+ struct Foo<T, int> { void bar() {} };
+ void foo() {
+ Foo<char, char> abc;
+ Foo<int, int> b;
+ }
+ )cpp";
+ auto Index = std::make_shared<Indexer>();
+ IndexingOptions Opts;
+ tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+ EXPECT_THAT(Index->Symbols,
+ Contains(AllOf(QName("Foo"), WrittenAt(Position(8, 7)),
+ DeclAt(Position(5, 12)))));
+}
+
+TEST(IndexTest, IndexTypeParmDecls) {
+ std::string Code = R"cpp(
+ template <typename T, int I, template<typename> class C, typename NoRef>
+ struct Foo {
+ T t = I;
+ C<int> x;
+ };
+ )cpp";
+ auto Index = std::make_shared<Indexer>();
+ IndexingOptions Opts;
+ tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+ EXPECT_THAT(Index->Symbols, AllOf(Not(Contains(QName("Foo::T"))),
+ Not(Contains(QName("Foo::I"))),
+ Not(Contains(QName("Foo::C"))),
+ Not(Contains(QName("Foo::NoRef")))));
+
+ Opts.IndexTemplateParameters = true;
+ Index->Symbols.clear();
+ tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+ EXPECT_THAT(Index->Symbols,
+ AllOf(Contains(QName("Foo::T")), Contains(QName("Foo::I")),
+ Contains(QName("Foo::C")), Contains(QName("Foo::NoRef"))));
+}
+
+TEST(IndexTest, UsingDecls) {
+ std::string Code = R"cpp(
+ void foo(int bar);
+ namespace std {
+ using ::foo;
+ }
+ )cpp";
+ auto Index = std::make_shared<Indexer>();
+ IndexingOptions Opts;
+ tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+ EXPECT_THAT(Index->Symbols,
+ Contains(AllOf(QName("std::foo"), Kind(SymbolKind::Using))));
+}
+
+TEST(IndexTest, Constructors) {
+ std::string Code = R"cpp(
+ struct Foo {
+ Foo(int);
+ ~Foo();
+ };
+ )cpp";
+ auto Index = std::make_shared<Indexer>();
+ IndexingOptions Opts;
+ tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+ EXPECT_THAT(
+ Index->Symbols,
+ UnorderedElementsAre(
+ AllOf(QName("Foo"), Kind(SymbolKind::Struct),
+ WrittenAt(Position(2, 12))),
+ AllOf(QName("Foo::Foo"), Kind(SymbolKind::Constructor),
+ WrittenAt(Position(3, 7))),
+ AllOf(QName("Foo"), Kind(SymbolKind::Struct),
+ HasRole(SymbolRole::NameReference), WrittenAt(Position(3, 7))),
+ AllOf(QName("Foo::~Foo"), Kind(SymbolKind::Destructor),
+ WrittenAt(Position(4, 7))),
+ AllOf(QName("Foo"), Kind(SymbolKind::Struct),
+ HasRole(SymbolRole::NameReference),
+ WrittenAt(Position(4, 8)))));
+}
+
} // namespace
} // namespace index
} // namespace clang
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-21 02:32:47 +0000