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