1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
| //===- unittest/AST/ASTContextParentMapTest.cpp - AST parent map test -----===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Tests for the getParents(...) methods of ASTContext.
//
//===----------------------------------------------------------------------===//
#include "clang/AST/ASTContext.h"
#include "MatchVerifier.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Tooling/Tooling.h"
#include "gtest/gtest.h"
#include "gmock/gmock.h"
using testing::ElementsAre;
namespace clang {
namespace ast_matchers {
TEST(GetParents, ReturnsParentForDecl) {
MatchVerifier<Decl> Verifier;
EXPECT_TRUE(
Verifier.match("class C { void f(); };",
cxxMethodDecl(hasParent(recordDecl(hasName("C"))))));
}
TEST(GetParents, ReturnsParentForStmt) {
MatchVerifier<Stmt> Verifier;
EXPECT_TRUE(Verifier.match("class C { void f() { if (true) {} } };",
ifStmt(hasParent(compoundStmt()))));
}
TEST(GetParents, ReturnsParentForTypeLoc) {
MatchVerifier<TypeLoc> Verifier;
EXPECT_TRUE(
Verifier.match("namespace a { class b {}; } void f(a::b) {}",
typeLoc(hasParent(typeLoc(hasParent(functionDecl()))))));
}
TEST(GetParents, ReturnsParentForNestedNameSpecifierLoc) {
MatchVerifier<NestedNameSpecifierLoc> Verifier;
EXPECT_TRUE(Verifier.match("namespace a { class b {}; } void f(a::b) {}",
nestedNameSpecifierLoc(hasParent(typeLoc()))));
}
TEST(GetParents, ReturnsParentInsideTemplateInstantiations) {
MatchVerifier<Decl> DeclVerifier;
EXPECT_TRUE(DeclVerifier.match(
"template<typename T> struct C { void f() {} };"
"void g() { C<int> c; c.f(); }",
cxxMethodDecl(hasName("f"),
hasParent(cxxRecordDecl(isTemplateInstantiation())))));
EXPECT_TRUE(DeclVerifier.match(
"template<typename T> struct C { void f() {} };"
"void g() { C<int> c; c.f(); }",
cxxMethodDecl(hasName("f"),
hasParent(cxxRecordDecl(unless(isTemplateInstantiation()))))));
EXPECT_FALSE(DeclVerifier.match(
"template<typename T> struct C { void f() {} };"
"void g() { C<int> c; c.f(); }",
cxxMethodDecl(
hasName("f"),
allOf(hasParent(cxxRecordDecl(unless(isTemplateInstantiation()))),
hasParent(cxxRecordDecl(isTemplateInstantiation()))))));
}
TEST(GetParents, ReturnsMultipleParentsInTemplateInstantiations) {
MatchVerifier<Stmt> TemplateVerifier;
EXPECT_TRUE(TemplateVerifier.match(
"template<typename T> struct C { void f() {} };"
"void g() { C<int> c; c.f(); }",
compoundStmt(allOf(
hasAncestor(cxxRecordDecl(isTemplateInstantiation())),
hasAncestor(cxxRecordDecl(unless(isTemplateInstantiation())))))));
}
TEST(GetParents, RespectsTraversalScope) {
auto AST =
tooling::buildASTFromCode("struct foo { int bar; };", "foo.cpp",
std::make_shared<PCHContainerOperations>());
auto &Ctx = AST->getASTContext();
auto &TU = *Ctx.getTranslationUnitDecl();
auto &Foo = *TU.lookup(&Ctx.Idents.get("foo")).front();
auto &Bar = *cast<DeclContext>(Foo).lookup(&Ctx.Idents.get("bar")).front();
using ast_type_traits::DynTypedNode;
// Initially, scope is the whole TU.
EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo)));
EXPECT_THAT(Ctx.getParents(Foo), ElementsAre(DynTypedNode::create(TU)));
// Restrict the scope, now some parents are gone.
Ctx.setTraversalScope({&Foo});
EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo)));
EXPECT_THAT(Ctx.getParents(Foo), ElementsAre());
// Reset the scope, we get back the original results.
Ctx.setTraversalScope({&TU});
EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo)));
EXPECT_THAT(Ctx.getParents(Foo), ElementsAre(DynTypedNode::create(TU)));
}
TEST(GetParents, ImplicitLambdaNodes) {
MatchVerifier<Decl> LambdaVerifier;
EXPECT_TRUE(LambdaVerifier.match(
"auto x = []{int y;};",
varDecl(hasName("y"), hasAncestor(functionDecl(
hasOverloadedOperatorName("()"),
hasParent(cxxRecordDecl(
isImplicit(), hasParent(lambdaExpr())))))),
Lang_CXX11));
}
} // end namespace ast_matchers
} // end namespace clang
|