contrib/llvm/tools/clang/include/clang/AST/ASTUnresolvedSet.h

   1 //===- ASTUnresolvedSet.h - Unresolved sets of declarations -----*- 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 provides an UnresolvedSet-like class, whose contents are
  10 //  allocated using the allocator associated with an ASTContext.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
  15 #define LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
  16
  17 #include "clang/AST/ASTVector.h"
  18 #include "clang/AST/DeclAccessPair.h"
  19 #include "clang/AST/UnresolvedSet.h"
  20 #include "clang/Basic/Specifiers.h"
  21 #include <cassert>
  22 #include <cstdint>
  23
  24 namespace clang {
  25
  26 class NamedDecl;
  27
  28 /// An UnresolvedSet-like class which uses the ASTContext's allocator.
  29 class ASTUnresolvedSet {
  30   friend class LazyASTUnresolvedSet;
  31
  32   struct DeclsTy : ASTVector<DeclAccessPair> {
  33     DeclsTy() = default;
  34     DeclsTy(ASTContext &C, unsigned N) : ASTVector<DeclAccessPair>(C, N) {}
  35
  36     bool isLazy() const { return getTag(); }
  37     void setLazy(bool Lazy) { setTag(Lazy); }
  38   };
  39
  40   DeclsTy Decls;
  41
  42 public:
  43   ASTUnresolvedSet() = default;
  44   ASTUnresolvedSet(ASTContext &C, unsigned N) : Decls(C, N) {}
  45
  46   using iterator = UnresolvedSetIterator;
  47   using const_iterator = UnresolvedSetIterator;
  48
  49   iterator begin() { return iterator(Decls.begin()); }
  50   iterator end() { return iterator(Decls.end()); }
  51
  52   const_iterator begin() const { return const_iterator(Decls.begin()); }
  53   const_iterator end() const { return const_iterator(Decls.end()); }
  54
  55   void addDecl(ASTContext &C, NamedDecl *D, AccessSpecifier AS) {
  56     Decls.push_back(DeclAccessPair::make(D, AS), C);
  57   }
  58
  59   /// Replaces the given declaration with the new one, once.
  60   ///
  61   /// \return true if the set changed
  62   bool replace(const NamedDecl *Old, NamedDecl *New, AccessSpecifier AS) {
  63     for (DeclsTy::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
  64       if (I->getDecl() == Old) {
  65         I->set(New, AS);
  66         return true;
  67       }
  68     }
  69     return false;
  70   }
  71
  72   void erase(unsigned I) { Decls[I] = Decls.pop_back_val(); }
  73
  74   void clear() { Decls.clear(); }
  75
  76   bool empty() const { return Decls.empty(); }
  77   unsigned size() const { return Decls.size(); }
  78
  79   void reserve(ASTContext &C, unsigned N) {
  80     Decls.reserve(C, N);
  81   }
  82
  83   void append(ASTContext &C, iterator I, iterator E) {
  84     Decls.append(C, I.I, E.I);
  85   }
  86
  87   DeclAccessPair &operator[](unsigned I) { return Decls[I]; }
  88   const DeclAccessPair &operator[](unsigned I) const { return Decls[I]; }
  89 };
  90
  91 /// An UnresolvedSet-like class that might not have been loaded from the
  92 /// external AST source yet.
  93 class LazyASTUnresolvedSet {
  94   mutable ASTUnresolvedSet Impl;
  95
  96   void getFromExternalSource(ASTContext &C) const;
  97
  98 public:
  99   ASTUnresolvedSet &get(ASTContext &C) const {
 100     if (Impl.Decls.isLazy())
 101       getFromExternalSource(C);
 102     return Impl;
 103   }
 104
 105   void reserve(ASTContext &C, unsigned N) { Impl.reserve(C, N); }
 106
 107   void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS) {
 108     assert(Impl.empty() || Impl.Decls.isLazy());
 109     Impl.Decls.setLazy(true);
 110     Impl.addDecl(C, reinterpret_cast<NamedDecl *>(ID << 2), AS);
 111   }
 112 };
 113
 114 } // namespace clang
 115
 116 #endif // LLVM_CLANG_AST_ASTUNRESOLVEDSET_H