clang/unittests/Tooling/RecursiveASTVisitorTestDeclVisitor.cpp

   1 //===- unittest/Tooling/RecursiveASTVisitorTestDeclVisitor.cpp ------------===//
   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 #include "TestVisitor.h"
  10
  11 using namespace clang;
  12
  13 namespace {
  14
  15 class VarDeclVisitor : public ExpectedLocationVisitor<VarDeclVisitor> {
  16 public:
  17  bool VisitVarDecl(VarDecl *Variable) {
  18    Match(Variable->getNameAsString(), Variable->getBeginLoc());
  19    return true;
  20  }
  21 };
  22
  23 TEST(RecursiveASTVisitor, VisitsCXXForRangeStmtLoopVariable) {
  24   VarDeclVisitor Visitor;
  25   Visitor.ExpectMatch("i", 2, 17);
  26   EXPECT_TRUE(Visitor.runOver(
  27     "int x[5];\n"
  28     "void f() { for (int i : x) {} }",
  29     VarDeclVisitor::Lang_CXX11));
  30 }
  31
  32 class ParmVarDeclVisitorForImplicitCode :
  33   public ExpectedLocationVisitor<ParmVarDeclVisitorForImplicitCode> {
  34 public:
  35   bool shouldVisitImplicitCode() const { return true; }
  36
  37   bool VisitParmVarDecl(ParmVarDecl *ParamVar) {
  38     Match(ParamVar->getNameAsString(), ParamVar->getBeginLoc());
  39     return true;
  40   }
  41 };
  42
  43 // Test RAV visits parameter variable declaration of the implicit
  44 // copy assignment operator and implicit copy constructor.
  45 TEST(RecursiveASTVisitor, VisitsParmVarDeclForImplicitCode) {
  46   ParmVarDeclVisitorForImplicitCode Visitor;
  47   // Match parameter variable name of implicit copy assignment operator and
  48   // implicit copy constructor.
  49   // This parameter name does not have a valid IdentifierInfo, and shares
  50   // same SourceLocation with its class declaration, so we match an empty name
  51   // with the class' source location.
  52   Visitor.ExpectMatch("", 1, 7);
  53   Visitor.ExpectMatch("", 3, 7);
  54   EXPECT_TRUE(Visitor.runOver(
  55     "class X {};\n"
  56     "void foo(X a, X b) {a = b;}\n"
  57     "class Y {};\n"
  58     "void bar(Y a) {Y b = a;}"));
  59 }
  60
  61 class NamedDeclVisitor
  62   : public ExpectedLocationVisitor<NamedDeclVisitor> {
  63 public:
  64   bool VisitNamedDecl(NamedDecl *Decl) {
  65     std::string NameWithTemplateArgs;
  66     llvm::raw_string_ostream OS(NameWithTemplateArgs);
  67     Decl->getNameForDiagnostic(OS,
  68                                Decl->getASTContext().getPrintingPolicy(),
  69                                true);
  70     Match(OS.str(), Decl->getLocation());
  71     return true;
  72   }
  73 };
  74
  75 TEST(RecursiveASTVisitor, VisitsPartialTemplateSpecialization) {
  76   // From cfe-commits/Week-of-Mon-20100830/033998.html
  77   // Contrary to the approach suggested in that email, we visit all
  78   // specializations when we visit the primary template.  Visiting them when we
  79   // visit the associated specialization is problematic for specializations of
  80   // template members of class templates.
  81   NamedDeclVisitor Visitor;
  82   Visitor.ExpectMatch("A<bool>", 1, 26);
  83   Visitor.ExpectMatch("A<char *>", 2, 26);
  84   EXPECT_TRUE(Visitor.runOver(
  85     "template <class T> class A {};\n"
  86     "template <class T> class A<T*> {};\n"
  87     "A<bool> ab;\n"
  88     "A<char*> acp;\n"));
  89 }
  90
  91 TEST(RecursiveASTVisitor, VisitsUndefinedClassTemplateSpecialization) {
  92   NamedDeclVisitor Visitor;
  93   Visitor.ExpectMatch("A<int>", 1, 29);
  94   EXPECT_TRUE(Visitor.runOver(
  95     "template<typename T> struct A;\n"
  96     "A<int> *p;\n"));
  97 }
  98
  99 TEST(RecursiveASTVisitor, VisitsNestedUndefinedClassTemplateSpecialization) {
 100   NamedDeclVisitor Visitor;
 101   Visitor.ExpectMatch("A<int>::B<char>", 2, 31);
 102   EXPECT_TRUE(Visitor.runOver(
 103     "template<typename T> struct A {\n"
 104     "  template<typename U> struct B;\n"
 105     "};\n"
 106     "A<int>::B<char> *p;\n"));
 107 }
 108
 109 TEST(RecursiveASTVisitor, VisitsUndefinedFunctionTemplateSpecialization) {
 110   NamedDeclVisitor Visitor;
 111   Visitor.ExpectMatch("A<int>", 1, 26);
 112   EXPECT_TRUE(Visitor.runOver(
 113     "template<typename T> int A();\n"
 114     "int k = A<int>();\n"));
 115 }
 116
 117 TEST(RecursiveASTVisitor, VisitsNestedUndefinedFunctionTemplateSpecialization) {
 118   NamedDeclVisitor Visitor;
 119   Visitor.ExpectMatch("A<int>::B<char>", 2, 35);
 120   EXPECT_TRUE(Visitor.runOver(
 121     "template<typename T> struct A {\n"
 122     "  template<typename U> static int B();\n"
 123     "};\n"
 124     "int k = A<int>::B<char>();\n"));
 125 }
 126
 127 TEST(RecursiveASTVisitor, NoRecursionInSelfFriend) {
 128   // From cfe-commits/Week-of-Mon-20100830/033977.html
 129   NamedDeclVisitor Visitor;
 130   Visitor.ExpectMatch("vector_iterator<int>", 2, 7);
 131   EXPECT_TRUE(Visitor.runOver(
 132     "template<typename Container>\n"
 133     "class vector_iterator {\n"
 134     "    template <typename C> friend class vector_iterator;\n"
 135     "};\n"
 136     "vector_iterator<int> it_int;\n"));
 137 }
 138
 139 } // end anonymous namespace