clang/unittests/Tooling/LexicallyOrderedRecursiveASTVisitorTest.cpp

   1 //===- unittest/Tooling/LexicallyOrderedRecursiveASTVisitorTest.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 #include "clang/AST/LexicallyOrderedRecursiveASTVisitor.h"
  11 #include <stack>
  12
  13 using namespace clang;
  14
  15 namespace {
  16
  17 class DummyMatchVisitor;
  18
  19 class LexicallyOrderedDeclVisitor
  20     : public LexicallyOrderedRecursiveASTVisitor<LexicallyOrderedDeclVisitor> {
  21 public:
  22   LexicallyOrderedDeclVisitor(DummyMatchVisitor &Matcher,
  23                               const SourceManager &SM, bool EmitDeclIndices,
  24                               bool EmitStmtIndices)
  25       : LexicallyOrderedRecursiveASTVisitor(SM), Matcher(Matcher),
  26         EmitDeclIndices(EmitDeclIndices), EmitStmtIndices(EmitStmtIndices) {}
  27
  28   bool TraverseDecl(Decl *D) {
  29     TraversalStack.push_back(D);
  30     LexicallyOrderedRecursiveASTVisitor::TraverseDecl(D);
  31     TraversalStack.pop_back();
  32     return true;
  33   }
  34
  35   bool TraverseStmt(Stmt *S);
  36
  37   bool VisitNamedDecl(const NamedDecl *D);
  38   bool VisitDeclRefExpr(const DeclRefExpr *D);
  39
  40 private:
  41   DummyMatchVisitor &Matcher;
  42   bool EmitDeclIndices, EmitStmtIndices;
  43   unsigned Index = 0;
  44   llvm::SmallVector<Decl *, 8> TraversalStack;
  45 };
  46
  47 class DummyMatchVisitor : public ExpectedLocationVisitor<DummyMatchVisitor> {
  48   bool EmitDeclIndices, EmitStmtIndices;
  49
  50 public:
  51   DummyMatchVisitor(bool EmitDeclIndices = false, bool EmitStmtIndices = false)
  52       : EmitDeclIndices(EmitDeclIndices), EmitStmtIndices(EmitStmtIndices) {}
  53   bool VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
  54     const ASTContext &Context = TU->getASTContext();
  55     const SourceManager &SM = Context.getSourceManager();
  56     LexicallyOrderedDeclVisitor SubVisitor(*this, SM, EmitDeclIndices,
  57                                            EmitStmtIndices);
  58     SubVisitor.TraverseDecl(TU);
  59     return false;
  60   }
  61
  62   template <class T> void match(StringRef Path, const T *D) {
  63     Match(Path, D->getBeginLoc());
  64   }
  65 };
  66
  67 bool LexicallyOrderedDeclVisitor::TraverseStmt(Stmt *S) {
  68   Matcher.match("overridden TraverseStmt", S);
  69   return LexicallyOrderedRecursiveASTVisitor::TraverseStmt(S);
  70 }
  71
  72 bool LexicallyOrderedDeclVisitor::VisitNamedDecl(const NamedDecl *D) {
  73   std::string Path;
  74   llvm::raw_string_ostream OS(Path);
  75   assert(TraversalStack.back() == D);
  76   for (const Decl *D : TraversalStack) {
  77     if (isa<TranslationUnitDecl>(D)) {
  78       OS << "/";
  79       continue;
  80     }
  81     if (const auto *ND = dyn_cast<NamedDecl>(D))
  82       OS << ND->getNameAsString();
  83     else
  84       OS << "???";
  85     if (isa<DeclContext>(D) || isa<TemplateDecl>(D))
  86       OS << "/";
  87   }
  88   if (EmitDeclIndices)
  89     OS << "@" << Index++;
  90   Matcher.match(OS.str(), D);
  91   return true;
  92 }
  93
  94 bool LexicallyOrderedDeclVisitor::VisitDeclRefExpr(const DeclRefExpr *D) {
  95   std::string Name = D->getFoundDecl()->getNameAsString();
  96   llvm::raw_string_ostream OS(Name);
  97   if (EmitStmtIndices)
  98     OS << "@" << Index++;
  99   Matcher.match(OS.str(), D);
 100   return true;
 101 }
 102
 103 TEST(LexicallyOrderedRecursiveASTVisitor, VisitDeclsInImplementation) {
 104   StringRef Source = R"(
 105 @interface I
 106 @end
 107 @implementation I
 108
 109 int nestedFunction() { }
 110
 111 - (void) method{ }
 112
 113 int anotherNestedFunction(int x) {
 114   return x;
 115 }
 116
 117 int innerVariable = 0;
 118
 119 @end
 120
 121 int outerVariable = 0;
 122
 123 @implementation I(Cat)
 124
 125 void catF() { }
 126
 127 @end
 128
 129 void outerFunction() { }
 130 )";
 131   DummyMatchVisitor Visitor;
 132   Visitor.DisallowMatch("/nestedFunction/", 6, 1);
 133   Visitor.ExpectMatch("/I/nestedFunction/", 6, 1);
 134   Visitor.ExpectMatch("/I/method/", 8, 1);
 135   Visitor.DisallowMatch("/anotherNestedFunction/", 10, 1);
 136   Visitor.ExpectMatch("/I/anotherNestedFunction/", 10, 1);
 137   Visitor.DisallowMatch("/innerVariable", 14, 1);
 138   Visitor.ExpectMatch("/I/innerVariable", 14, 1);
 139   Visitor.ExpectMatch("/outerVariable", 18, 1);
 140   Visitor.DisallowMatch("/catF/", 22, 1);
 141   Visitor.ExpectMatch("/Cat/catF/", 22, 1);
 142   Visitor.ExpectMatch("/outerFunction/", 26, 1);
 143   EXPECT_TRUE(Visitor.runOver(Source, DummyMatchVisitor::Lang_OBJC));
 144 }
 145
 146 TEST(LexicallyOrderedRecursiveASTVisitor, VisitMacroDeclsInImplementation) {
 147   StringRef Source = R"(
 148 @interface I
 149 @end
 150
 151 void outerFunction() { }
 152
 153 #define MACRO_F(x) void nestedFunction##x() { }
 154
 155 @implementation I
 156
 157 MACRO_F(1)
 158
 159 @end
 160
 161 MACRO_F(2)
 162 )";
 163   DummyMatchVisitor Visitor;
 164   Visitor.ExpectMatch("/outerFunction/", 5, 1);
 165   Visitor.ExpectMatch("/I/nestedFunction1/", 7, 20);
 166   Visitor.ExpectMatch("/nestedFunction2/", 7, 20);
 167   EXPECT_TRUE(Visitor.runOver(Source, DummyMatchVisitor::Lang_OBJC));
 168 }
 169
 170 TEST(LexicallyOrderedRecursiveASTVisitor, VisitTemplateDecl) {
 171   StringRef Source = R"(
 172 template <class T> T f();
 173 template <class U, class = void> class Class {};
 174 )";
 175   DummyMatchVisitor Visitor(/*EmitIndices=*/true);
 176   Visitor.ExpectMatch("/f/T@1", 2, 11);
 177   Visitor.ExpectMatch("/f/f/@2", 2, 20);
 178   Visitor.ExpectMatch("/Class/U@4", 3, 11);
 179   Visitor.ExpectMatch("/Class/@5", 3, 20);
 180   Visitor.ExpectMatch("/Class/Class/@6", 3, 34);
 181   EXPECT_TRUE(Visitor.runOver(Source));
 182 }
 183
 184 TEST(LexicallyOrderedRecursiveASTVisitor, VisitCXXOperatorCallExpr) {
 185   StringRef Source = R"(
 186 struct S {
 187   S &operator+(S&);
 188   S *operator->();
 189   S &operator++();
 190   S operator++(int);
 191   void operator()(int, int);
 192   void operator[](int);
 193   void f();
 194 };
 195 S a, b, c;
 196
 197 void test() {
 198   a = b + c;
 199   a->f();
 200   a(1, 2);
 201   b[0];
 202   ++a;
 203   b++;
 204 }
 205 )";
 206   DummyMatchVisitor Visitor(/*EmitDeclIndices=*/false,
 207                             /*EmitStmtIndices=*/true);
 208   // There are two overloaded operators that start at this point
 209   // This makes sure they are both traversed using the overridden
 210   // TraverseStmt, as the traversal is implemented by us for
 211   // CXXOperatorCallExpr.
 212   Visitor.ExpectMatch("overridden TraverseStmt", 14, 3, 2);
 213   Visitor.ExpectMatch("a@0", 14, 3);
 214   Visitor.ExpectMatch("operator=@1", 14, 5);
 215   Visitor.ExpectMatch("b@2", 14, 7);
 216   Visitor.ExpectMatch("operator+@3", 14, 9);
 217   Visitor.ExpectMatch("c@4", 14, 11);
 218   Visitor.ExpectMatch("operator->@6", 15, 4);
 219   Visitor.ExpectMatch("operator()@8", 16, 4);
 220   Visitor.ExpectMatch("operator[]@10", 17, 4);
 221   Visitor.ExpectMatch("operator++@11", 18, 3);
 222   Visitor.ExpectMatch("operator++@14", 19, 4);
 223   EXPECT_TRUE(Visitor.runOver(Source));
 224 }
 225
 226 } // end anonymous namespace