Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 1 | //===- ParentMapContext.h - Map of parents using DynTypedNode -------*- 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 | // Similar to ParentMap.h, but generalizes to non-Stmt nodes, which can have |
||
| 10 | // multiple parents. |
||
| 11 | // |
||
| 12 | //===----------------------------------------------------------------------===// |
||
| 13 | |||
| 14 | #ifndef LLVM_CLANG_AST_PARENTMAPCONTEXT_H |
||
| 15 | #define LLVM_CLANG_AST_PARENTMAPCONTEXT_H |
||
| 16 | |||
| 17 | #include "clang/AST/ASTContext.h" |
||
| 18 | #include "clang/AST/ASTTypeTraits.h" |
||
| 19 | |||
| 20 | namespace clang { |
||
| 21 | class DynTypedNodeList; |
||
| 22 | |||
| 23 | class ParentMapContext { |
||
| 24 | public: |
||
| 25 | ParentMapContext(ASTContext &Ctx); |
||
| 26 | |||
| 27 | ~ParentMapContext(); |
||
| 28 | |||
| 29 | /// Returns the parents of the given node (within the traversal scope). |
||
| 30 | /// |
||
| 31 | /// Note that this will lazily compute the parents of all nodes |
||
| 32 | /// and store them for later retrieval. Thus, the first call is O(n) |
||
| 33 | /// in the number of AST nodes. |
||
| 34 | /// |
||
| 35 | /// Caveats and FIXMEs: |
||
| 36 | /// Calculating the parent map over all AST nodes will need to load the |
||
| 37 | /// full AST. This can be undesirable in the case where the full AST is |
||
| 38 | /// expensive to create (for example, when using precompiled header |
||
| 39 | /// preambles). Thus, there are good opportunities for optimization here. |
||
| 40 | /// One idea is to walk the given node downwards, looking for references |
||
| 41 | /// to declaration contexts - once a declaration context is found, compute |
||
| 42 | /// the parent map for the declaration context; if that can satisfy the |
||
| 43 | /// request, loading the whole AST can be avoided. Note that this is made |
||
| 44 | /// more complex by statements in templates having multiple parents - those |
||
| 45 | /// problems can be solved by building closure over the templated parts of |
||
| 46 | /// the AST, which also avoids touching large parts of the AST. |
||
| 47 | /// Additionally, we will want to add an interface to already give a hint |
||
| 48 | /// where to search for the parents, for example when looking at a statement |
||
| 49 | /// inside a certain function. |
||
| 50 | /// |
||
| 51 | /// 'NodeT' can be one of Decl, Stmt, Type, TypeLoc, |
||
| 52 | /// NestedNameSpecifier or NestedNameSpecifierLoc. |
||
| 53 | template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node); |
||
| 54 | |||
| 55 | DynTypedNodeList getParents(const DynTypedNode &Node); |
||
| 56 | |||
| 57 | /// Clear parent maps. |
||
| 58 | void clear(); |
||
| 59 | |||
| 60 | TraversalKind getTraversalKind() const { return Traversal; } |
||
| 61 | void setTraversalKind(TraversalKind TK) { Traversal = TK; } |
||
| 62 | |||
| 63 | const Expr *traverseIgnored(const Expr *E) const; |
||
| 64 | Expr *traverseIgnored(Expr *E) const; |
||
| 65 | DynTypedNode traverseIgnored(const DynTypedNode &N) const; |
||
| 66 | |||
| 67 | class ParentMap; |
||
| 68 | |||
| 69 | private: |
||
| 70 | ASTContext &ASTCtx; |
||
| 71 | TraversalKind Traversal = TK_AsIs; |
||
| 72 | std::unique_ptr<ParentMap> Parents; |
||
| 73 | }; |
||
| 74 | |||
| 75 | class TraversalKindScope { |
||
| 76 | ParentMapContext &Ctx; |
||
| 77 | TraversalKind TK = TK_AsIs; |
||
| 78 | |||
| 79 | public: |
||
| 80 | TraversalKindScope(ASTContext &ASTCtx, std::optional<TraversalKind> ScopeTK) |
||
| 81 | : Ctx(ASTCtx.getParentMapContext()) { |
||
| 82 | TK = Ctx.getTraversalKind(); |
||
| 83 | if (ScopeTK) |
||
| 84 | Ctx.setTraversalKind(*ScopeTK); |
||
| 85 | } |
||
| 86 | |||
| 87 | ~TraversalKindScope() { Ctx.setTraversalKind(TK); } |
||
| 88 | }; |
||
| 89 | |||
| 90 | /// Container for either a single DynTypedNode or for an ArrayRef to |
||
| 91 | /// DynTypedNode. For use with ParentMap. |
||
| 92 | class DynTypedNodeList { |
||
| 93 | union { |
||
| 94 | DynTypedNode SingleNode; |
||
| 95 | ArrayRef<DynTypedNode> Nodes; |
||
| 96 | }; |
||
| 97 | bool IsSingleNode; |
||
| 98 | |||
| 99 | public: |
||
| 100 | DynTypedNodeList(const DynTypedNode &N) : IsSingleNode(true) { |
||
| 101 | new (&SingleNode) DynTypedNode(N); |
||
| 102 | } |
||
| 103 | |||
| 104 | DynTypedNodeList(ArrayRef<DynTypedNode> A) : IsSingleNode(false) { |
||
| 105 | new (&Nodes) ArrayRef<DynTypedNode>(A); |
||
| 106 | } |
||
| 107 | |||
| 108 | const DynTypedNode *begin() const { |
||
| 109 | return !IsSingleNode ? Nodes.begin() : &SingleNode; |
||
| 110 | } |
||
| 111 | |||
| 112 | const DynTypedNode *end() const { |
||
| 113 | return !IsSingleNode ? Nodes.end() : &SingleNode + 1; |
||
| 114 | } |
||
| 115 | |||
| 116 | size_t size() const { return end() - begin(); } |
||
| 117 | bool empty() const { return begin() == end(); } |
||
| 118 | |||
| 119 | const DynTypedNode &operator[](size_t N) const { |
||
| 120 | assert(N < size() && "Out of bounds!"); |
||
| 121 | return *(begin() + N); |
||
| 122 | } |
||
| 123 | }; |
||
| 124 | |||
| 125 | template <typename NodeT> |
||
| 126 | inline DynTypedNodeList ParentMapContext::getParents(const NodeT &Node) { |
||
| 127 | return getParents(DynTypedNode::create(Node)); |
||
| 128 | } |
||
| 129 | |||
| 130 | template <typename NodeT> |
||
| 131 | inline DynTypedNodeList ASTContext::getParents(const NodeT &Node) { |
||
| 132 | return getParentMapContext().getParents(Node); |
||
| 133 | } |
||
| 134 | |||
| 135 | template <> |
||
| 136 | inline DynTypedNodeList ASTContext::getParents(const DynTypedNode &Node) { |
||
| 137 | return getParentMapContext().getParents(Node); |
||
| 138 | } |
||
| 139 | |||
| 140 | } // namespace clang |
||
| 141 | |||
| 142 | #endif |