[clang] Adds a RecursiveASTEnterExitVisitor data type

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -1273,8 +1273,11 @@ DEF_TRAVERSE_TYPELOC(RValueReferenceType,
 DEF_TRAVERSE_TYPELOC(MemberPointerType, {
   if (NestedNameSpecifierLoc QL = TL.getQualifierLoc())
     TRY_TO(TraverseNestedNameSpecifierLoc(QL));
+//  if (auto *TSI = TL.getClassTInfo())
+//    TRY_TO(TraverseTypeLoc(TSI->getTypeLoc()));
   else
     TRY_TO(TraverseNestedNameSpecifier(TL.getTypePtr()->getQualifier()));
+//    TRY_TO(TraverseType(QualType(TL.getTypePtr()->getClass(), 0)));
   TRY_TO(TraverseTypeLoc(TL.getPointeeLoc()));
 })
 

clang/include/clang/AST/StmtOpenACC.h

@@ -81,6 +81,7 @@ class OpenACCAssociatedStmtConstruct : public OpenACCConstructStmt {
   friend class ASTStmtWriter;
   friend class ASTStmtReader;
   template <typename Derived> friend class RecursiveASTVisitor;
+  template <typename Derived> friend class RecursiveASTEnterExitVisitor;
   Stmt *AssociatedStmt = nullptr;
 
 protected:

clang/unittests/Tooling/CMakeLists.txt

@@ -49,6 +49,40 @@ add_clang_unittest(ToolingTests
   RecursiveASTVisitorTestDeclVisitor.cpp
   RecursiveASTVisitorTestPostOrderVisitor.cpp
   RecursiveASTVisitorTestTypeLocVisitor.cpp
+  RecursiveASTEnterExitVisitorTests/Attr.cpp
+  RecursiveASTEnterExitVisitorTests/BitfieldInitializer.cpp
+  RecursiveASTEnterExitVisitorTests/CallbacksLeaf.cpp
+  RecursiveASTEnterExitVisitorTests/CallbacksUnaryOperator.cpp
+  RecursiveASTEnterExitVisitorTests/CallbacksBinaryOperator.cpp
+  RecursiveASTEnterExitVisitorTests/CallbacksCompoundAssignOperator.cpp
+  RecursiveASTEnterExitVisitorTests/CallbacksCallExpr.cpp
+  RecursiveASTEnterExitVisitorTests/Class.cpp
+  RecursiveASTEnterExitVisitorTests/Concept.cpp
+  RecursiveASTEnterExitVisitorTests/ConstructExpr.cpp
+  RecursiveASTEnterExitVisitorTests/CXXBoolLiteralExpr.cpp
+  RecursiveASTEnterExitVisitorTests/CXXMemberCall.cpp
+  RecursiveASTEnterExitVisitorTests/CXXMethodDecl.cpp
+  RecursiveASTEnterExitVisitorTests/CXXOperatorCallExprTraverser.cpp
+  RecursiveASTEnterExitVisitorTests/DeclRefExpr.cpp
+  RecursiveASTEnterExitVisitorTests/DeductionGuide.cpp
+  RecursiveASTEnterExitVisitorTests/ImplicitCtor.cpp
+  RecursiveASTEnterExitVisitorTests/ImplicitCtorInitializer.cpp
+  RecursiveASTEnterExitVisitorTests/InitListExprPostOrder.cpp
+  RecursiveASTEnterExitVisitorTests/InitListExprPostOrderNoQueue.cpp
+  RecursiveASTEnterExitVisitorTests/InitListExprPreOrder.cpp
+  RecursiveASTEnterExitVisitorTests/InitListExprPreOrderNoQueue.cpp
+  RecursiveASTEnterExitVisitorTests/IntegerLiteral.cpp
+  RecursiveASTEnterExitVisitorTests/LambdaDefaultCapture.cpp
+  RecursiveASTEnterExitVisitorTests/LambdaExpr.cpp
+  RecursiveASTEnterExitVisitorTests/LambdaTemplateParams.cpp
+  RecursiveASTEnterExitVisitorTests/MemberPointerTypeLoc.cpp
+  RecursiveASTEnterExitVisitorTests/NestedNameSpecifiers.cpp
+  RecursiveASTEnterExitVisitorTests/ParenExpr.cpp
+  RecursiveASTEnterExitVisitorTests/TemplateArgumentLocTraverser.cpp
+  RecursiveASTEnterExitVisitorTests/TraversalScope.cpp
+  RecursiveASTEnterExitVisitorTestDeclVisitor.cpp
+  RecursiveASTEnterExitVisitorTestPostOrderVisitor.cpp
+  RecursiveASTEnterExitVisitorTestTypeLocVisitor.cpp
   RefactoringActionRulesTest.cpp
   RefactoringCallbacksTest.cpp
   RefactoringTest.cpp

clang/unittests/Tooling/RecursiveASTEnterExitVisitorTestDeclVisitor.cpp

@@ -0,0 +1,138 @@
+//===- unittest/Tooling/RecursiveASTEnterExitVisitorTestDeclVisitor.cpp ------------===//
+//
+// 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 "TestVisitor.h"
+#include "clang/AST/RecursiveASTEnterExitVisitor.h"
+
+using namespace clang;
+
+namespace {
+
+class VarDeclVisitor : public ExpectedLocationVisitor {
+public:
+  bool VisitVarDecl(VarDecl *Variable) override {
+    Match(Variable->getNameAsString(), Variable->getBeginLoc());
+    return true;
+  }
+};
+
+TEST(RecursiveASTEnterExitVisitor, VisitsCXXForRangeStmtLoopVariable) {
+  VarDeclVisitor Visitor;
+  Visitor.ExpectMatch("i", 2, 17);
+  EXPECT_TRUE(Visitor.runOver(
+    "int x[5];\n"
+    "void f() { for (int i : x) {} }",
+    VarDeclVisitor::Lang_CXX11));
+}
+
+class ParmVarDeclVisitorForImplicitCode : public ExpectedLocationVisitor {
+public:
+  ParmVarDeclVisitorForImplicitCode() { ShouldVisitImplicitCode = true; }
+
+  bool VisitParmVarDecl(ParmVarDecl *ParamVar) override {
+    Match(ParamVar->getNameAsString(), ParamVar->getBeginLoc());
+    return true;
+  }
+};
+
+// Test RAV visits parameter variable declaration of the implicit
+// copy assignment operator and implicit copy constructor.
+TEST(RecursiveASTEnterExitVisitor, VisitsParmVarDeclForImplicitCode) {
+  ParmVarDeclVisitorForImplicitCode Visitor;
+  // Match parameter variable name of implicit copy assignment operator and
+  // implicit copy constructor.
+  // This parameter name does not have a valid IdentifierInfo, and shares
+  // same SourceLocation with its class declaration, so we match an empty name
+  // with the class' source location.
+  Visitor.ExpectMatch("", 1, 7);
+  Visitor.ExpectMatch("", 3, 7);
+  EXPECT_TRUE(Visitor.runOver(
+    "class X {};\n"
+    "void foo(X a, X b) {a = b;}\n"
+    "class Y {};\n"
+    "void bar(Y a) {Y b = a;}"));
+}
+
+class NamedDeclVisitor : public ExpectedLocationVisitor {
+public:
+  bool VisitNamedDecl(NamedDecl *Decl) override {
+    std::string NameWithTemplateArgs;
+    llvm::raw_string_ostream OS(NameWithTemplateArgs);
+    Decl->getNameForDiagnostic(OS,
+                               Decl->getASTContext().getPrintingPolicy(),
+                               true);
+    Match(NameWithTemplateArgs, Decl->getLocation());
+    return true;
+  }
+};
+
+TEST(RecursiveASTEnterExitVisitor, VisitsPartialTemplateSpecialization) {
+  // From cfe-commits/Week-of-Mon-20100830/033998.html
+  // Contrary to the approach suggested in that email, we visit all
+  // specializations when we visit the primary template.  Visiting them when we
+  // visit the associated specialization is problematic for specializations of
+  // template members of class templates.
+  NamedDeclVisitor Visitor;
+  Visitor.ExpectMatch("A<bool>", 1, 26);
+  Visitor.ExpectMatch("A<char *>", 2, 26);
+  EXPECT_TRUE(Visitor.runOver(
+    "template <class T> class A {};\n"
+    "template <class T> class A<T*> {};\n"
+    "A<bool> ab;\n"
+    "A<char*> acp;\n"));
+}
+
+TEST(RecursiveASTEnterExitVisitor, VisitsUndefinedClassTemplateSpecialization) {
+  NamedDeclVisitor Visitor;
+  Visitor.ExpectMatch("A<int>", 1, 29);
+  EXPECT_TRUE(Visitor.runOver(
+    "template<typename T> struct A;\n"
+    "A<int> *p;\n"));
+}
+
+TEST(RecursiveASTEnterExitVisitor, VisitsNestedUndefinedClassTemplateSpecialization) {
+  NamedDeclVisitor Visitor;
+  Visitor.ExpectMatch("A<int>::B<char>", 2, 31);
+  EXPECT_TRUE(Visitor.runOver(
+    "template<typename T> struct A {\n"
+    "  template<typename U> struct B;\n"
+    "};\n"
+    "A<int>::B<char> *p;\n"));
+}
+
+TEST(RecursiveASTEnterExitVisitor, VisitsUndefinedFunctionTemplateSpecialization) {
+  NamedDeclVisitor Visitor;
+  Visitor.ExpectMatch("A<int>", 1, 26);
+  EXPECT_TRUE(Visitor.runOver(
+    "template<typename T> int A();\n"
+    "int k = A<int>();\n"));
+}
+
+TEST(RecursiveASTEnterExitVisitor, VisitsNestedUndefinedFunctionTemplateSpecialization) {
+  NamedDeclVisitor Visitor;
+  Visitor.ExpectMatch("A<int>::B<char>", 2, 35);
+  EXPECT_TRUE(Visitor.runOver(
+    "template<typename T> struct A {\n"
+    "  template<typename U> static int B();\n"
+    "};\n"
+    "int k = A<int>::B<char>();\n"));
+}
+
+TEST(RecursiveASTEnterExitVisitor, NoRecursionInSelfFriend) {
+  // From cfe-commits/Week-of-Mon-20100830/033977.html
+  NamedDeclVisitor Visitor;
+  Visitor.ExpectMatch("vector_iterator<int>", 2, 7);
+  EXPECT_TRUE(Visitor.runOver(
+    "template<typename Container>\n"
+    "class vector_iterator {\n"
+    "    template <typename C> friend class vector_iterator;\n"
+    "};\n"
+    "vector_iterator<int> it_int;\n"));
+}
+
+} // end anonymous namespace

clang/unittests/Tooling/RecursiveASTEnterExitVisitorTestPostOrderVisitor.cpp

@@ -0,0 +1,114 @@
+//===- unittests/Tooling/RecursiveASTEnterExitVisitorPostOrderASTVisitor.cpp -------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains tests for the post-order traversing functionality
+// of RecursiveASTEnterExitVisitor.
+//
+//===----------------------------------------------------------------------===//
+
+#include "CRTPTestVisitor.h"
+#include "clang/AST/RecursiveASTEnterExitVisitor.h"
+
+using namespace clang;
+
+namespace {
+class RecordingVisitor : public CRTPTestVisitor<RecordingVisitor> {
+  bool VisitPostOrder;
+
+public:
+  explicit RecordingVisitor(bool VisitPostOrder)
+      : VisitPostOrder(VisitPostOrder) {}
+
+  // List of visited nodes during traversal.
+  std::vector<std::string> VisitedNodes;
+
+  bool shouldTraversePostOrder() const { return VisitPostOrder; }
+
+  bool VisitUnaryOperator(UnaryOperator *Op) {
+    VisitedNodes.push_back(std::string(Op->getOpcodeStr(Op->getOpcode())));
+    return true;
+  }
+
+  bool VisitBinaryOperator(BinaryOperator *Op) {
+    VisitedNodes.push_back(std::string(Op->getOpcodeStr()));
+    return true;
+  }
+
+  bool VisitIntegerLiteral(IntegerLiteral *Lit) {
+    VisitedNodes.push_back(toString(Lit->getValue(), 10, false));
+    return true;
+  }
+
+  bool VisitVarDecl(VarDecl *D) {
+    VisitedNodes.push_back(D->getNameAsString());
+    return true;
+  }
+
+  bool VisitCXXMethodDecl(CXXMethodDecl *D) {
+    VisitedNodes.push_back(D->getQualifiedNameAsString());
+    return true;
+  }
+
+  bool VisitReturnStmt(ReturnStmt *S) {
+    VisitedNodes.push_back("return");
+    return true;
+  }
+
+  bool VisitCXXRecordDecl(CXXRecordDecl *D) {
+    if (!D->isImplicit())
+      VisitedNodes.push_back(D->getQualifiedNameAsString());
+    return true;
+  }
+
+  bool VisitTemplateTypeParmType(TemplateTypeParmType *T) {
+    VisitedNodes.push_back(T->getDecl()->getQualifiedNameAsString());
+    return true;
+  }
+};
+} // namespace
+
+TEST(RecursiveASTEnterExitVisitor, PostOrderTraversal) {
+  // We traverse the translation unit and store all visited nodes.
+  RecordingVisitor Visitor(true);
+  Visitor.runOver("class A {\n"
+                  "  class B {\n"
+                  "    int foo() {\n"
+                  "      while(4) { int i = 9; int j = -5; }\n"
+                  "      return (1 + 3) + 2; }\n"
+                  "  };\n"
+                  "};\n");
+
+  std::vector<std::string> expected = {"4", "9",      "i",         "5",    "-",
+                                       "j", "1",      "3",         "+",    "2",
+                                       "+", "return", "A::B::foo", "A::B", "A"};
+  // Compare the list of actually visited nodes with the expected list of
+  // visited nodes.
+  ASSERT_EQ(expected.size(), Visitor.VisitedNodes.size());
+  for (std::size_t I = 0; I < expected.size(); I++) {
+    ASSERT_EQ(expected[I], Visitor.VisitedNodes[I]);
+  }
+}
+
+TEST(RecursiveASTEnterExitVisitor, NoPostOrderTraversal) {
+  // We traverse the translation unit and store all visited nodes.
+  RecordingVisitor Visitor(false);
+  Visitor.runOver("class A {\n"
+                  "  class B {\n"
+                  "    int foo() { return 1 + 2; }\n"
+                  "  };\n"
+                  "};\n");
+
+  std::vector<std::string> expected = {"A", "A::B", "A::B::foo", "return",
+                                       "+", "1",    "2"};
+  // Compare the list of actually visited nodes with the expected list of
+  // visited nodes.
+  ASSERT_EQ(expected.size(), Visitor.VisitedNodes.size());
+  for (std::size_t I = 0; I < expected.size(); I++) {
+    ASSERT_EQ(expected[I], Visitor.VisitedNodes[I]);
+  }
+}