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 24namespace clang { 25 26class NamedDecl; 27 28/// An UnresolvedSet-like class which uses the ASTContext's allocator. 29class 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 42public: 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) { 73 if (I == Decls.size() - 1) 74 Decls.pop_back(); 75 else 76 Decls[I] = Decls.pop_back_val(); 77 } 78 79 void clear() { Decls.clear(); } 80 81 bool empty() const { return Decls.empty(); } 82 unsigned size() const { return Decls.size(); } 83 84 void reserve(ASTContext &C, unsigned N) { 85 Decls.reserve(C, N); 86 } 87 88 void append(ASTContext &C, iterator I, iterator E) { 89 Decls.append(C, I.I, E.I); 90 } 91 92 DeclAccessPair &operator[](unsigned I) { return Decls[I]; } 93 const DeclAccessPair &operator[](unsigned I) const { return Decls[I]; } 94}; 95 96/// An UnresolvedSet-like class that might not have been loaded from the 97/// external AST source yet. 98class LazyASTUnresolvedSet { 99 mutable ASTUnresolvedSet Impl; 100 101 void getFromExternalSource(ASTContext &C) const; 102 103public: 104 ASTUnresolvedSet &get(ASTContext &C) const { 105 if (Impl.Decls.isLazy()) 106 getFromExternalSource(C); 107 return Impl; 108 } 109 110 void reserve(ASTContext &C, unsigned N) { Impl.reserve(C, N); } 111 112 void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS) { 113 assert(Impl.empty() || Impl.Decls.isLazy()); 114 Impl.Decls.setLazy(true); 115 Impl.addDecl(C, reinterpret_cast<NamedDecl *>(ID << 2), AS); 116 } 117}; 118 119} // namespace clang 120 121#endif // LLVM_CLANG_AST_ASTUNRESOLVEDSET_H 122