Coverage Report

Created: 2020-09-15 12:33

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/AST/LexicallyOrderedRecursiveASTVisitor.h
Line
Count
Source (jump to first uncovered line)
1
//===--- LexicallyOrderedRecursiveASTVisitor.h - ----------------*- C++ -*-===//
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
//  This file defines the LexicallyOrderedRecursiveASTVisitor interface, which
10
//  recursively traverses the entire AST in a lexical order.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_CLANG_AST_LEXICALLY_ORDERED_RECURSIVEASTVISITOR_H
15
#define LLVM_CLANG_AST_LEXICALLY_ORDERED_RECURSIVEASTVISITOR_H
16
17
#include "clang/AST/RecursiveASTVisitor.h"
18
#include "clang/Basic/LLVM.h"
19
#include "clang/Basic/SourceManager.h"
20
#include "llvm/Support/SaveAndRestore.h"
21
22
namespace clang {
23
24
/// A RecursiveASTVisitor subclass that guarantees that AST traversal is
25
/// performed in a lexical order (i.e. the order in which declarations are
26
/// written in the source).
27
///
28
/// RecursiveASTVisitor doesn't guarantee lexical ordering because there are
29
/// some declarations, like Objective-C @implementation declarations
30
/// that might be represented in the AST differently to how they were written
31
/// in the source.
32
/// In particular, Objective-C @implementation declarations may contain
33
/// non-Objective-C declarations, like functions:
34
///
35
///   @implementation MyClass
36
///
37
///   - (void) method { }
38
///   void normalFunction() { }
39
///
40
///   @end
41
///
42
/// Clang's AST stores these declarations outside of the @implementation
43
/// declaration, so the example above would be represented using the following
44
/// AST:
45
///   |-ObjCImplementationDecl ... MyClass
46
///   | `-ObjCMethodDecl ... method
47
///   |    ...
48
///   `-FunctionDecl ... normalFunction
49
///       ...
50
///
51
/// This class ensures that these declarations are traversed before the
52
/// corresponding TraverseDecl for the @implementation returns. This ensures
53
/// that the lexical parent relationship between these declarations and the
54
/// @implementation is preserved while traversing the AST. Note that the
55
/// current implementation doesn't mix these declarations with the declarations
56
/// contained in the @implementation, so the traversal of all of the
57
/// declarations in the @implementation still doesn't follow the lexical order.
58
template <typename Derived>
59
class LexicallyOrderedRecursiveASTVisitor
60
    : public RecursiveASTVisitor<Derived> {
61
  using BaseType = RecursiveASTVisitor<Derived>;
62
63
public:
64
87
  LexicallyOrderedRecursiveASTVisitor(const SourceManager &SM) : SM(SM) {}
65
66
13
  bool TraverseObjCImplementationDecl(ObjCImplementationDecl *D) {
67
    // Objective-C @implementation declarations should not trigger early exit
68
    // until the additional decls are traversed as their children are not
69
    // lexically ordered.
70
13
    bool Result = BaseType::TraverseObjCImplementationDecl(D);
71
12
    return TraverseAdditionalLexicallyNestedDeclarations() ? Result : 
false1
;
72
13
  }
73
74
3
  bool TraverseObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
75
3
    bool Result = BaseType::TraverseObjCCategoryImplDecl(D);
76
3
    return TraverseAdditionalLexicallyNestedDeclarations() ? Result : 
false0
;
77
3
  }
78
79
637
  bool TraverseDeclContextHelper(DeclContext *DC) {
80
637
    if (!DC)
81
446
      return true;
82
191
83
1.17k
    
for (auto I = DC->decls_begin(), E = DC->decls_end(); 191
I != E;) {
84
1.08k
      Decl *Child = *I;
85
1.08k
      if (BaseType::canIgnoreChildDeclWhileTraversingDeclContext(Child)) {
86
0
        ++I;
87
0
        continue;
88
0
      }
89
1.08k
      if (!isa<ObjCImplementationDecl>(Child) &&
90
1.07k
          !isa<ObjCCategoryImplDecl>(Child)) {
91
1.07k
        if (!BaseType::getDerived().TraverseDecl(Child))
92
91
          return false;
93
981
        ++I;
94
981
        continue;
95
981
      }
96
      // Gather declarations that follow the Objective-C implementation
97
      // declarations but are lexically contained in the implementation.
98
16
      LexicallyNestedDeclarations.clear();
99
28
      for (++I; I != E; 
++I12
) {
100
19
        Decl *Sibling = *I;
101
19
        if (!SM.isBeforeInTranslationUnit(Sibling->getBeginLoc(),
102
19
                                          Child->getEndLoc()))
103
7
          break;
104
12
        if (!BaseType::canIgnoreChildDeclWhileTraversingDeclContext(Sibling))
105
12
          LexicallyNestedDeclarations.push_back(Sibling);
106
12
      }
107
16
      if (!BaseType::getDerived().TraverseDecl(Child))
108
11
        return false;
109
16
    }
110
89
    return true;
111
191
  }
112
113
2.06k
  Stmt::child_range getStmtChildren(Stmt *S) { return S->children(); }
114
115
0
  SmallVector<Stmt *, 8> getStmtChildren(CXXOperatorCallExpr *CE) {
116
0
    SmallVector<Stmt *, 8> Children(CE->children());
117
0
    bool Swap;
118
    // Switch the operator and the first operand for all infix and postfix
119
    // operations.
120
0
    switch (CE->getOperator()) {
121
0
    case OO_Arrow:
122
0
    case OO_Call:
123
0
    case OO_Subscript:
124
0
      Swap = true;
125
0
      break;
126
0
    case OO_PlusPlus:
127
0
    case OO_MinusMinus:
128
      // These are postfix unless there is exactly one argument.
129
0
      Swap = Children.size() != 2;
130
0
      break;
131
0
    default:
132
0
      Swap = CE->isInfixBinaryOp();
133
0
      break;
134
0
    }
135
0
    if (Swap && Children.size() > 1)
136
0
      std::swap(Children[0], Children[1]);
137
0
    return Children;
138
0
  }
139
140
private:
141
16
  bool TraverseAdditionalLexicallyNestedDeclarations() {
142
    // FIXME: Ideally the gathered declarations and the declarations in the
143
    // @implementation should be mixed and sorted to get a true lexical order,
144
    // but right now we only care about getting the correct lexical parent, so
145
    // we can traverse the gathered nested declarations after the declarations
146
    // in the decl context.
147
16
    assert(!BaseType::getDerived().shouldTraversePostOrder() &&
148
16
           "post-order traversal is not supported for lexically ordered "
149
16
           "recursive ast visitor");
150
12
    for (Decl *D : LexicallyNestedDeclarations) {
151
12
      if (!BaseType::getDerived().TraverseDecl(D))
152
1
        return false;
153
12
    }
154
15
    return true;
155
16
  }
156
157
  const SourceManager &SM;
158
  llvm::SmallVector<Decl *, 8> LexicallyNestedDeclarations;
159
};
160
161
} // end namespace clang
162
163
#endif // LLVM_CLANG_AST_LEXICALLY_ORDERED_RECURSIVEASTVISITOR_H