clang/unittests/AST/ASTContextParentMapTest.cpp

   1 //===- unittest/AST/ASTContextParentMapTest.cpp - AST parent map test -----===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Tests for the getParents(...) methods of ASTContext.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/AST/ASTContext.h"
  14 #include "MatchVerifier.h"
  15 #include "clang/ASTMatchers/ASTMatchFinder.h"
  16 #include "clang/ASTMatchers/ASTMatchers.h"
  17 #include "clang/Tooling/Tooling.h"
  18 #include "gtest/gtest.h"
  19 #include "gmock/gmock.h"
  20
  21 using testing::ElementsAre;
  22
  23 namespace clang {
  24 namespace ast_matchers {
  25
  26 TEST(GetParents, ReturnsParentForDecl) {
  27   MatchVerifier<Decl> Verifier;
  28   EXPECT_TRUE(
  29       Verifier.match("class C { void f(); };",
  30                      cxxMethodDecl(hasParent(recordDecl(hasName("C"))))));
  31 }
  32
  33 TEST(GetParents, ReturnsParentForStmt) {
  34   MatchVerifier<Stmt> Verifier;
  35   EXPECT_TRUE(Verifier.match("class C { void f() { if (true) {} } };",
  36                              ifStmt(hasParent(compoundStmt()))));
  37 }
  38
  39 TEST(GetParents, ReturnsParentForTypeLoc) {
  40   MatchVerifier<TypeLoc> Verifier;
  41   EXPECT_TRUE(
  42       Verifier.match("namespace a { class b {}; } void f(a::b) {}",
  43                      typeLoc(hasParent(typeLoc(hasParent(functionDecl()))))));
  44 }
  45
  46 TEST(GetParents, ReturnsParentForNestedNameSpecifierLoc) {
  47   MatchVerifier<NestedNameSpecifierLoc> Verifier;
  48   EXPECT_TRUE(Verifier.match("namespace a { class b {}; } void f(a::b) {}",
  49                              nestedNameSpecifierLoc(hasParent(typeLoc()))));
  50 }
  51
  52 TEST(GetParents, ReturnsParentInsideTemplateInstantiations) {
  53   MatchVerifier<Decl> DeclVerifier;
  54   EXPECT_TRUE(DeclVerifier.match(
  55       "template<typename T> struct C { void f() {} };"
  56       "void g() { C<int> c; c.f(); }",
  57       cxxMethodDecl(hasName("f"),
  58                  hasParent(cxxRecordDecl(isTemplateInstantiation())))));
  59   EXPECT_TRUE(DeclVerifier.match(
  60       "template<typename T> struct C { void f() {} };"
  61       "void g() { C<int> c; c.f(); }",
  62       cxxMethodDecl(hasName("f"),
  63                  hasParent(cxxRecordDecl(unless(isTemplateInstantiation()))))));
  64   EXPECT_FALSE(DeclVerifier.match(
  65       "template<typename T> struct C { void f() {} };"
  66       "void g() { C<int> c; c.f(); }",
  67       cxxMethodDecl(
  68           hasName("f"),
  69           allOf(hasParent(cxxRecordDecl(unless(isTemplateInstantiation()))),
  70                 hasParent(cxxRecordDecl(isTemplateInstantiation()))))));
  71 }
  72
  73 TEST(GetParents, ReturnsMultipleParentsInTemplateInstantiations) {
  74   MatchVerifier<Stmt> TemplateVerifier;
  75   EXPECT_TRUE(TemplateVerifier.match(
  76       "template<typename T> struct C { void f() {} };"
  77       "void g() { C<int> c; c.f(); }",
  78       compoundStmt(allOf(
  79           hasAncestor(cxxRecordDecl(isTemplateInstantiation())),
  80           hasAncestor(cxxRecordDecl(unless(isTemplateInstantiation())))))));
  81 }
  82
  83 TEST(GetParents, RespectsTraversalScope) {
  84   auto AST = tooling::buildASTFromCode(
  85       "struct foo { int bar; }; struct baz{};", "foo.cpp",
  86       std::make_shared<PCHContainerOperations>());
  87   auto &Ctx = AST->getASTContext();
  88   auto &TU = *Ctx.getTranslationUnitDecl();
  89   auto &Foo = *TU.lookup(&Ctx.Idents.get("foo")).front();
  90   auto &Bar = *cast<DeclContext>(Foo).lookup(&Ctx.Idents.get("bar")).front();
  91   auto &Baz = *TU.lookup(&Ctx.Idents.get("baz")).front();
  92
  93   // Initially, scope is the whole TU.
  94   EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo)));
  95   EXPECT_THAT(Ctx.getParents(Foo), ElementsAre(DynTypedNode::create(TU)));
  96   EXPECT_THAT(Ctx.getParents(Baz), ElementsAre(DynTypedNode::create(TU)));
  97
  98   // Restrict the scope, now some parents are gone.
  99   Ctx.setTraversalScope({&Foo});
 100   EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo)));
 101   EXPECT_THAT(Ctx.getParents(Foo), ElementsAre(DynTypedNode::create(TU)));
 102   EXPECT_THAT(Ctx.getParents(Baz), ElementsAre());
 103
 104   // Reset the scope, we get back the original results.
 105   Ctx.setTraversalScope({&TU});
 106   EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo)));
 107   EXPECT_THAT(Ctx.getParents(Foo), ElementsAre(DynTypedNode::create(TU)));
 108   EXPECT_THAT(Ctx.getParents(Baz), ElementsAre(DynTypedNode::create(TU)));
 109 }
 110
 111 TEST(GetParents, ImplicitLambdaNodes) {
 112   MatchVerifier<Decl> LambdaVerifier;
 113   EXPECT_TRUE(LambdaVerifier.match(
 114       "auto x = []{int y;};",
 115       varDecl(hasName("y"), hasAncestor(functionDecl(
 116                                 hasOverloadedOperatorName("()"),
 117                                 hasParent(cxxRecordDecl(
 118                                     isImplicit(), hasParent(lambdaExpr())))))),
 119       Lang_CXX11));
 120 }
 121
 122 TEST(GetParents, FriendTypeLoc) {
 123   auto AST = tooling::buildASTFromCode("struct A { friend struct Fr; };"
 124                                        "struct B { friend struct Fr; };"
 125                                        "struct Fr;");
 126   auto &Ctx = AST->getASTContext();
 127   auto &TU = *Ctx.getTranslationUnitDecl();
 128   auto &A = *TU.lookup(&Ctx.Idents.get("A")).front();
 129   auto &B = *TU.lookup(&Ctx.Idents.get("B")).front();
 130   auto &FrA = *cast<FriendDecl>(*++(cast<CXXRecordDecl>(A).decls_begin()));
 131   auto &FrB = *cast<FriendDecl>(*++(cast<CXXRecordDecl>(B).decls_begin()));
 132   TypeLoc FrALoc = FrA.getFriendType()->getTypeLoc();
 133   TypeLoc FrBLoc = FrB.getFriendType()->getTypeLoc();
 134   TagDecl *FrATagDecl =
 135       FrALoc.getTypePtr()->getAs<ElaboratedType>()->getOwnedTagDecl();
 136   TagDecl *FrBTagDecl =
 137       FrBLoc.getTypePtr()->getAs<ElaboratedType>()->getOwnedTagDecl();
 138
 139   EXPECT_THAT(Ctx.getParents(A), ElementsAre(DynTypedNode::create(TU)));
 140   EXPECT_THAT(Ctx.getParents(B), ElementsAre(DynTypedNode::create(TU)));
 141   EXPECT_THAT(Ctx.getParents(FrA), ElementsAre(DynTypedNode::create(A)));
 142   EXPECT_THAT(Ctx.getParents(FrB), ElementsAre(DynTypedNode::create(B)));
 143   EXPECT_THAT(Ctx.getParents(FrALoc), ElementsAre(DynTypedNode::create(FrA)));
 144   EXPECT_THAT(Ctx.getParents(FrBLoc), ElementsAre(DynTypedNode::create(FrB)));
 145   EXPECT_TRUE(FrATagDecl);
 146   EXPECT_FALSE(FrBTagDecl);
 147   EXPECT_THAT(Ctx.getParents(*FrATagDecl),
 148               ElementsAre(DynTypedNode::create(FrA)));
 149 }
 150
 151 } // end namespace ast_matchers
 152 } // end namespace clang