ASTUnresolvedSet.h source code [clang_source_code/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
117

Clang Project