ParentMapContext.h

Go to the documentation of this file.

//===- ParentMapContext.h - Map of parents using DynTypedNode ---*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Similar to ParentMap.h, but generalizes to non-Stmt nodes, which can have
// multiple parents.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_AST_PARENTMAPCONTEXT_H
#define LLVM_CLANG_AST_PARENTMAPCONTEXT_H
 
#include "clang/AST/ASTContext.h"
#include "clang/AST/ASTTypeTraits.h"
 
namespace clang {
class DynTypedNodeList;
 
class ParentMapContext {
public:
  ParentMapContext(ASTContext &Ctx);
 
  ~ParentMapContext();
 
  /// Returns the parents of the given node (within the traversal scope).
  ///
  /// Note that this will lazily compute the parents of all nodes
  /// and store them for later retrieval. Thus, the first call is O(n)
  /// in the number of AST nodes.
  ///
  /// Caveats and FIXMEs:
  /// Calculating the parent map over all AST nodes will need to load the
  /// full AST. This can be undesirable in the case where the full AST is
  /// expensive to create (for example, when using precompiled header
  /// preambles). Thus, there are good opportunities for optimization here.
  /// One idea is to walk the given node downwards, looking for references
  /// to declaration contexts - once a declaration context is found, compute
  /// the parent map for the declaration context; if that can satisfy the
  /// request, loading the whole AST can be avoided. Note that this is made
  /// more complex by statements in templates having multiple parents - those
  /// problems can be solved by building closure over the templated parts of
  /// the AST, which also avoids touching large parts of the AST.
  /// Additionally, we will want to add an interface to already give a hint
  /// where to search for the parents, for example when looking at a statement
  /// inside a certain function.
  ///
  /// 'NodeT' can be one of Decl, Stmt, Type, TypeLoc,
  /// NestedNameSpecifier or NestedNameSpecifierLoc.
  template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node);
 
  DynTypedNodeList getParents(const DynTypedNode &Node);
 
  /// Clear parent maps.
  void clear();
 
  TraversalKind getTraversalKind() const { return Traversal; }
  void setTraversalKind(TraversalKind TK) { Traversal = TK; }
 
  const Expr *traverseIgnored(const Expr *E) const;
  Expr *traverseIgnored(Expr *E) const;
  DynTypedNode traverseIgnored(const DynTypedNode &N) const {
    // Fast path: Nothing is ignored in the default traversal mode TK_AsIs.
    if (Traversal == TK_AsIs)
      return N;
    if (const auto *E = N.get<Expr>())
      return DynTypedNode::create(*traverseIgnored(E));
    return N;
  }
 
  class ParentMap;
 
private:
  ASTContext &ASTCtx;
  TraversalKind Traversal = TK_AsIs;
  std::unique_ptr<ParentMap> Parents;
};
 
class TraversalKindScope {
  ParentMapContext &Ctx;
  TraversalKind TK = TK_AsIs;
 
public:
  TraversalKindScope(ASTContext &ASTCtx, std::optional<TraversalKind> ScopeTK)
      : Ctx(ASTCtx.getParentMapContext()) {
    TK = Ctx.getTraversalKind();
    if (ScopeTK)
      Ctx.setTraversalKind(*ScopeTK);
  }
 
  ~TraversalKindScope() { Ctx.setTraversalKind(TK); }
};
 
/// Container for either a single DynTypedNode or for an ArrayRef to
/// DynTypedNode. For use with ParentMap.
class DynTypedNodeList {
  union {
    DynTypedNode SingleNode;
    ArrayRef<DynTypedNode> Nodes;
  };
  bool IsSingleNode;
 
public:
  DynTypedNodeList(const DynTypedNode &N) : IsSingleNode(true) {
    new (&SingleNode) DynTypedNode(N);
  }
 
  DynTypedNodeList(ArrayRef<DynTypedNode> A) : IsSingleNode(false) {
    new (&Nodes) ArrayRef<DynTypedNode>(A);
  }
 
  const DynTypedNode *begin() const {
    return !IsSingleNode ? Nodes.begin() : &SingleNode;
  }
 
  const DynTypedNode *end() const {
    return !IsSingleNode ? Nodes.end() : &SingleNode + 1;
  }
 
  size_t size() const { return end() - begin(); }
  bool empty() const { return begin() == end(); }
 
  const DynTypedNode &operator[](size_t N) const {
    assert(N < size() && "Out of bounds!");
    return *(begin() + N);
  }
};
 
template <typename NodeT>
inline DynTypedNodeList ParentMapContext::getParents(const NodeT &Node) {
  return getParents(DynTypedNode::create(Node));
}
 
template <typename NodeT>
inline DynTypedNodeList ASTContext::getParents(const NodeT &Node) {
  return getParentMapContext().getParents(Node);
}
 
template <>
inline DynTypedNodeList ASTContext::getParents(const DynTypedNode &Node) {
  return getParentMapContext().getParents(Node);
}
 
} // namespace clang
 
#endif