1 //===--- LexicallyOrderedRecursiveASTVisitor.h - ----------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the LexicallyOrderedRecursiveASTVisitor interface, which
11 // recursively traverses the entire AST in a lexical order.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CLANG_AST_LEXICALLY_ORDERED_RECURSIVEASTVISITOR_H
16 #define LLVM_CLANG_AST_LEXICALLY_ORDERED_RECURSIVEASTVISITOR_H
18 #include "clang/AST/RecursiveASTVisitor.h"
19 #include "clang/Basic/LLVM.h"
20 #include "clang/Basic/SourceManager.h"
21 #include "llvm/Support/SaveAndRestore.h"
25 /// A RecursiveASTVisitor subclass that guarantees that AST traversal is
26 /// performed in a lexical order (i.e. the order in which declarations are
27 /// written in the source).
29 /// RecursiveASTVisitor doesn't guarantee lexical ordering because there are
30 /// some declarations, like Objective-C @implementation declarations
31 /// that might be represented in the AST differently to how they were written
33 /// In particular, Objective-C @implementation declarations may contain
34 /// non-Objective-C declarations, like functions:
36 /// @implementation MyClass
38 /// - (void) method { }
39 /// void normalFunction() { }
43 /// Clang's AST stores these declarations outside of the @implementation
44 /// declaration, so the example above would be represented using the following
46 /// |-ObjCImplementationDecl ... MyClass
47 /// | `-ObjCMethodDecl ... method
49 /// `-FunctionDecl ... normalFunction
52 /// This class ensures that these declarations are traversed before the
53 /// corresponding TraverseDecl for the @implementation returns. This ensures
54 /// that the lexical parent relationship between these declarations and the
55 /// @implementation is preserved while traversing the AST. Note that the
56 /// current implementation doesn't mix these declarations with the declarations
57 /// contained in the @implementation, so the traversal of all of the
58 /// declarations in the @implementation still doesn't follow the lexical order.
59 template <typename Derived>
60 class LexicallyOrderedRecursiveASTVisitor
61 : public RecursiveASTVisitor<Derived> {
62 using BaseType = RecursiveASTVisitor<Derived>;
65 LexicallyOrderedRecursiveASTVisitor(const SourceManager &SM) : SM(SM) {}
67 bool TraverseObjCImplementationDecl(ObjCImplementationDecl *D) {
68 // Objective-C @implementation declarations should not trigger early exit
69 // until the additional decls are traversed as their children are not
71 bool Result = BaseType::TraverseObjCImplementationDecl(D);
72 return TraverseAdditionalLexicallyNestedDeclarations() ? Result : false;
75 bool TraverseObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
76 bool Result = BaseType::TraverseObjCCategoryImplDecl(D);
77 return TraverseAdditionalLexicallyNestedDeclarations() ? Result : false;
80 bool TraverseDeclContextHelper(DeclContext *DC) {
84 for (auto I = DC->decls_begin(), E = DC->decls_end(); I != E;) {
86 if (BaseType::canIgnoreChildDeclWhileTraversingDeclContext(Child)) {
90 if (!isa<ObjCImplementationDecl>(Child) &&
91 !isa<ObjCCategoryImplDecl>(Child)) {
92 if (!BaseType::getDerived().TraverseDecl(Child))
97 // Gather declarations that follow the Objective-C implementation
98 // declarations but are lexically contained in the implementation.
99 LexicallyNestedDeclarations.clear();
100 for (++I; I != E; ++I) {
102 if (!SM.isBeforeInTranslationUnit(Sibling->getLocStart(),
105 if (!BaseType::canIgnoreChildDeclWhileTraversingDeclContext(Sibling))
106 LexicallyNestedDeclarations.push_back(Sibling);
108 if (!BaseType::getDerived().TraverseDecl(Child))
114 Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); }
116 SmallVector<Stmt *, 8> getStmtChildren(CXXOperatorCallExpr *CE) {
117 SmallVector<Stmt *, 8> Children(CE->children());
119 // Switch the operator and the first operand for all infix and postfix
121 switch (CE->getOperator()) {
129 // These are postfix unless there is exactly one argument.
130 Swap = Children.size() != 2;
133 Swap = CE->isInfixBinaryOp();
136 if (Swap && Children.size() > 1)
137 std::swap(Children[0], Children[1]);
142 bool TraverseAdditionalLexicallyNestedDeclarations() {
143 // FIXME: Ideally the gathered declarations and the declarations in the
144 // @implementation should be mixed and sorted to get a true lexical order,
145 // but right now we only care about getting the correct lexical parent, so
146 // we can traverse the gathered nested declarations after the declarations
147 // in the decl context.
148 assert(!BaseType::getDerived().shouldTraversePostOrder() &&
149 "post-order traversal is not supported for lexically ordered "
150 "recursive ast visitor");
151 for (Decl *D : LexicallyNestedDeclarations) {
152 if (!BaseType::getDerived().TraverseDecl(D))
158 const SourceManager &SM;
159 llvm::SmallVector<Decl *, 8> LexicallyNestedDeclarations;
162 } // end namespace clang
164 #endif // LLVM_CLANG_AST_LEXICALLY_ORDERED_RECURSIVEASTVISITOR_H