clang 17.0.0git
ASTUnresolvedSet.h
Go to the documentation of this file.
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"
21#include <cassert>
22#include <cstdint>
23
24namespace clang {
25
26class NamedDecl;
27
28/// An UnresolvedSet-like class which uses the ASTContext's allocator.
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
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
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
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.
99 mutable ASTUnresolvedSet Impl;
100
101 void getFromExternalSource(ASTContext &C) const;
102
103public:
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
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
Defines various enumerations that describe declaration and type specifiers.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:182
An UnresolvedSet-like class which uses the ASTContext's allocator.
void append(ASTContext &C, iterator I, iterator E)
const DeclAccessPair & operator[](unsigned I) const
bool replace(const NamedDecl *Old, NamedDecl *New, AccessSpecifier AS)
Replaces the given declaration with the new one, once.
UnresolvedSetIterator iterator
UnresolvedSetIterator const_iterator
const_iterator end() const
ASTUnresolvedSet(ASTContext &C, unsigned N)
void reserve(ASTContext &C, unsigned N)
const_iterator begin() const
void addDecl(ASTContext &C, NamedDecl *D, AccessSpecifier AS)
void erase(unsigned I)
DeclAccessPair & operator[](unsigned I)
A POD class for pairing a NamedDecl* with an access specifier.
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
An UnresolvedSet-like class that might not have been loaded from the external AST source yet.
void reserve(ASTContext &C, unsigned N)
void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS)
ASTUnresolvedSet & get(ASTContext &C) const
This represents a decl that may have a name.
Definition: Decl.h:247
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:35
@ C
Languages that the frontend can parse and compile.
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:111
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...