Scope.h source code [clang_source_code/include/clang/Sema/Scope.h]

1	//===- Scope.h - Scope interface --------------------------------- 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 defines the Scope interface.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#ifndef LLVM_CLANG_SEMA_SCOPE_H
14	#define LLVM_CLANG_SEMA_SCOPE_H
15
16	#include "clang/AST/Decl.h"
17	#include "clang/Basic/Diagnostic.h"
18	#include "llvm/ADT/PointerIntPair.h"
19	#include "llvm/ADT/SmallPtrSet.h"
20	#include "llvm/ADT/SmallVector.h"
21	#include "llvm/ADT/iterator_range.h"
22	#include <cassert>
23
24	namespace llvm {
25
26	class raw_ostream;
27
28	} // namespace llvm
29
30	namespace clang {
31
32	class Decl;
33	class DeclContext;
34	class UsingDirectiveDecl;
35	class VarDecl;
36
37	/// Scope - A scope is a transient data structure that is used while parsing the
38	/// program. It assists with resolving identifiers to the appropriate
39	/// declaration.
40	class Scope {
41	public:
42	/// ScopeFlags - These are bitfields that are or'd together when creating a
43	/// scope, which defines the sorts of things the scope contains.
44	enum ScopeFlags {
45	/// This indicates that the scope corresponds to a function, which
46	/// means that labels are set here.
47	FnScope = 0x01,
48
49	/// This is a while, do, switch, for, etc that can have break
50	/// statements embedded into it.
51	BreakScope = 0x02,
52
53	/// This is a while, do, for, which can have continue statements
54	/// embedded into it.
55	ContinueScope = 0x04,
56
57	/// This is a scope that can contain a declaration. Some scopes
58	/// just contain loop constructs but don't contain decls.
59	DeclScope = 0x08,
60
61	/// The controlling scope in a if/switch/while/for statement.
62	ControlScope = 0x10,
63
64	/// The scope of a struct/union/class definition.
65	ClassScope = 0x20,
66
67	/// This is a scope that corresponds to a block/closure object.
68	/// Blocks serve as top-level scopes for some objects like labels, they
69	/// also prevent things like break and continue. BlockScopes always have
70	/// the FnScope and DeclScope flags set as well.
71	BlockScope = 0x40,
72
73	/// This is a scope that corresponds to the
74	/// template parameters of a C++ template. Template parameter
75	/// scope starts at the 'template' keyword and ends when the
76	/// template declaration ends.
77	TemplateParamScope = 0x80,
78
79	/// This is a scope that corresponds to the
80	/// parameters within a function prototype.
81	FunctionPrototypeScope = 0x100,
82
83	/// This is a scope that corresponds to the parameters within
84	/// a function prototype for a function declaration (as opposed to any
85	/// other kind of function declarator). Always has FunctionPrototypeScope
86	/// set as well.
87	FunctionDeclarationScope = 0x200,
88
89	/// This is a scope that corresponds to the Objective-C
90	/// \@catch statement.
91	AtCatchScope = 0x400,
92
93	/// This scope corresponds to an Objective-C method body.
94	/// It always has FnScope and DeclScope set as well.
95	ObjCMethodScope = 0x800,
96
97	/// This is a scope that corresponds to a switch statement.
98	SwitchScope = 0x1000,
99
100	/// This is the scope of a C++ try statement.
101	TryScope = 0x2000,
102
103	/// This is the scope for a function-level C++ try or catch scope.
104	FnTryCatchScope = 0x4000,
105
106	/// This is the scope of OpenMP executable directive.
107	OpenMPDirectiveScope = 0x8000,
108
109	/// This is the scope of some OpenMP loop directive.
110	OpenMPLoopDirectiveScope = 0x10000,
111
112	/// This is the scope of some OpenMP simd directive.
113	/// For example, it is used for 'omp simd', 'omp for simd'.
114	/// This flag is propagated to children scopes.
115	OpenMPSimdDirectiveScope = 0x20000,
116
117	/// This scope corresponds to an enum.
118	EnumScope = 0x40000,
119
120	/// This scope corresponds to an SEH try.
121	SEHTryScope = 0x80000,
122
123	/// This scope corresponds to an SEH except.
124	SEHExceptScope = 0x100000,
125
126	/// We are currently in the filter expression of an SEH except block.
127	SEHFilterScope = 0x200000,
128
129	/// This is a compound statement scope.
130	CompoundStmtScope = 0x400000,
131
132	/// We are between inheritance colon and the real class/struct definition scope.
133	ClassInheritanceScope = 0x800000,
134
135	/// This is the scope of a C++ catch statement.
136	CatchScope = 0x1000000,
137	};
138
139	private:
140	/// The parent scope for this scope. This is null for the translation-unit
141	/// scope.
142	Scope *AnyParent;
143
144	/// Flags - This contains a set of ScopeFlags, which indicates how the scope
145	/// interrelates with other control flow statements.
146	unsigned Flags;
147
148	/// Depth - This is the depth of this scope. The translation-unit scope has
149	/// depth 0.
150	unsigned short Depth;
151
152	/// Declarations with static linkage are mangled with the number of
153	/// scopes seen as a component.
154	unsigned short MSLastManglingNumber;
155
156	unsigned short MSCurManglingNumber;
157
158	/// PrototypeDepth - This is the number of function prototype scopes
159	/// enclosing this scope, including this scope.
160	unsigned short PrototypeDepth;
161
162	/// PrototypeIndex - This is the number of parameters currently
163	/// declared in this scope.
164	unsigned short PrototypeIndex;
165
166	/// FnParent - If this scope has a parent scope that is a function body, this
167	/// pointer is non-null and points to it. This is used for label processing.
168	Scope *FnParent;
169	Scope *MSLastManglingParent;
170
171	/// BreakParent/ContinueParent - This is a direct link to the innermost
172	/// BreakScope/ContinueScope which contains the contents of this scope
173	/// for control flow purposes (and might be this scope itself), or null
174	/// if there is no such scope.
175	Scope BreakParent, ContinueParent;
176
177	/// BlockParent - This is a direct link to the immediately containing
178	/// BlockScope if this scope is not one, or null if there is none.
179	Scope *BlockParent;
180
181	/// TemplateParamParent - This is a direct link to the
182	/// immediately containing template parameter scope. In the
183	/// case of nested templates, template parameter scopes can have
184	/// other template parameter scopes as parents.
185	Scope *TemplateParamParent;
186
187	/// DeclsInScope - This keeps track of all declarations in this scope. When
188	/// the declaration is added to the scope, it is set as the current
189	/// declaration for the identifier in the IdentifierTable. When the scope is
190	/// popped, these declarations are removed from the IdentifierTable's notion
191	/// of current declaration. It is up to the current Action implementation to
192	/// implement these semantics.
193	using DeclSetTy = llvm::SmallPtrSet<Decl *, 32>;
194	DeclSetTy DeclsInScope;
195
196	/// The DeclContext with which this scope is associated. For
197	/// example, the entity of a class scope is the class itself, the
198	/// entity of a function scope is a function, etc.
199	DeclContext *Entity;
200
201	using UsingDirectivesTy = SmallVector<UsingDirectiveDecl *, 2>;
202	UsingDirectivesTy UsingDirectives;
203
204	/// Used to determine if errors occurred in this scope.
205	DiagnosticErrorTrap ErrorTrap;
206
207	/// A lattice consisting of undefined, a single NRVO candidate variable in
208	/// this scope, or over-defined. The bit is true when over-defined.
209	llvm::PointerIntPair<VarDecl *, 1, bool> NRVO;
210
211	void setFlags(Scope *Parent, unsigned F);
212
213	public:
214	Scope(Scope *Parent, unsigned ScopeFlags, DiagnosticsEngine &Diag)
215	: ErrorTrap(Diag) {
216	Init(Parent, ScopeFlags);
217	}
218
219	/// getFlags - Return the flags for this scope.
220	unsigned getFlags() const { return Flags; }
221
222	void setFlags(unsigned F) { setFlags(getParent(), F); }
223
224	/// isBlockScope - Return true if this scope correspond to a closure.
225	bool isBlockScope() const { return Flags & BlockScope; }
226
227	/// getParent - Return the scope that this is nested in.
228	const Scope *getParent() const { return AnyParent; }
229	Scope *getParent() { return AnyParent; }
230
231	/// getFnParent - Return the closest scope that is a function body.
232	const Scope *getFnParent() const { return FnParent; }
233	Scope *getFnParent() { return FnParent; }
234
235	const Scope *getMSLastManglingParent() const {
236	return MSLastManglingParent;
237	}
238	Scope *getMSLastManglingParent() { return MSLastManglingParent; }
239
240	/// getContinueParent - Return the closest scope that a continue statement
241	/// would be affected by.
242	Scope *getContinueParent() {
243	return ContinueParent;
244	}
245
246	const Scope *getContinueParent() const {
247	return const_cast<Scope*>(this)->getContinueParent();
248	}
249
250	/// getBreakParent - Return the closest scope that a break statement
251	/// would be affected by.
252	Scope *getBreakParent() {
253	return BreakParent;
254	}
255	const Scope *getBreakParent() const {
256	return const_cast<Scope*>(this)->getBreakParent();
257	}
258
259	Scope *getBlockParent() { return BlockParent; }
260	const Scope *getBlockParent() const { return BlockParent; }
261
262	Scope *getTemplateParamParent() { return TemplateParamParent; }
263	const Scope *getTemplateParamParent() const { return TemplateParamParent; }
264
265	/// Returns the depth of this scope. The translation-unit has scope depth 0.
266	unsigned getDepth() const { return Depth; }
267
268	/// Returns the number of function prototype scopes in this scope
269	/// chain.
270	unsigned getFunctionPrototypeDepth() const {
271	return PrototypeDepth;
272	}
273
274	/// Return the number of parameters declared in this function
275	/// prototype, increasing it by one for the next call.
276	unsigned getNextFunctionPrototypeIndex() {
277	assert(isFunctionPrototypeScope());
278	return PrototypeIndex++;
279	}
280
281	using decl_range = llvm::iterator_range<DeclSetTy::iterator>;
282
283	decl_range decls() const {
284	return decl_range(DeclsInScope.begin(), DeclsInScope.end());
285	}
286
287	bool decl_empty() const { return DeclsInScope.empty(); }
288
289	void AddDecl(Decl *D) {
290	DeclsInScope.insert(D);
291	}
292
293	void RemoveDecl(Decl *D) {
294	DeclsInScope.erase(D);
295	}
296
297	void incrementMSManglingNumber() {
298	if (Scope *MSLMP = getMSLastManglingParent()) {
299	MSLMP->MSLastManglingNumber += 1;
300	MSCurManglingNumber += 1;
301	}
302	}
303
304	void decrementMSManglingNumber() {
305	if (Scope *MSLMP = getMSLastManglingParent()) {
306	MSLMP->MSLastManglingNumber -= 1;
307	MSCurManglingNumber -= 1;
308	}
309	}
310
311	unsigned getMSLastManglingNumber() const {
312	if (const Scope *MSLMP = getMSLastManglingParent())
313	return MSLMP->MSLastManglingNumber;
314	return 1;
315	}
316
317	unsigned getMSCurManglingNumber() const {
318	return MSCurManglingNumber;
319	}
320
321	/// isDeclScope - Return true if this is the scope that the specified decl is
322	/// declared in.
323	bool isDeclScope(Decl *D) {
324	return DeclsInScope.count(D) != 0;
325	}
326
327	DeclContext *getEntity() const { return Entity; }
328	void setEntity(DeclContext *E) { Entity = E; }
329
330	bool hasErrorOccurred() const { return ErrorTrap.hasErrorOccurred(); }
331
332	bool hasUnrecoverableErrorOccurred() const {
333	return ErrorTrap.hasUnrecoverableErrorOccurred();
334	}
335
336	/// isFunctionScope() - Return true if this scope is a function scope.
337	bool isFunctionScope() const { return (getFlags() & Scope::FnScope); }
338
339	/// isClassScope - Return true if this scope is a class/struct/union scope.
340	bool isClassScope() const {
341	return (getFlags() & Scope::ClassScope);
342	}
343
344	/// isInCXXInlineMethodScope - Return true if this scope is a C++ inline
345	/// method scope or is inside one.
346	bool isInCXXInlineMethodScope() const {
347	if (const Scope *FnS = getFnParent()) {
348	(0) . __assert_fail ("FnS->getParent() && \"TUScope not created?\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Sema/Scope.h", 348, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(FnS->getParent() && "TUScope not created?");
349	return FnS->getParent()->isClassScope();
350	}
351	return false;
352	}
353
354	/// isInObjcMethodScope - Return true if this scope is, or is contained in, an
355	/// Objective-C method body. Note that this method is not constant time.
356	bool isInObjcMethodScope() const {
357	for (const Scope *S = this; S; S = S->getParent()) {
358	// If this scope is an objc method scope, then we succeed.
359	if (S->getFlags() & ObjCMethodScope)
360	return true;
361	}
362	return false;
363	}
364
365	/// isInObjcMethodOuterScope - Return true if this scope is an
366	/// Objective-C method outer most body.
367	bool isInObjcMethodOuterScope() const {
368	if (const Scope *S = this) {
369	// If this scope is an objc method scope, then we succeed.
370	if (S->getFlags() & ObjCMethodScope)
371	return true;
372	}
373	return false;
374	}
375
376	/// isTemplateParamScope - Return true if this scope is a C++
377	/// template parameter scope.
378	bool isTemplateParamScope() const {
379	return getFlags() & Scope::TemplateParamScope;
380	}
381
382	/// isFunctionPrototypeScope - Return true if this scope is a
383	/// function prototype scope.
384	bool isFunctionPrototypeScope() const {
385	return getFlags() & Scope::FunctionPrototypeScope;
386	}
387
388	/// isAtCatchScope - Return true if this scope is \@catch.
389	bool isAtCatchScope() const {
390	return getFlags() & Scope::AtCatchScope;
391	}
392
393	/// isSwitchScope - Return true if this scope is a switch scope.
394	bool isSwitchScope() const {
395	for (const Scope *S = this; S; S = S->getParent()) {
396	if (S->getFlags() & Scope::SwitchScope)
397	return true;
398	else if (S->getFlags() & (Scope::FnScope \| Scope::ClassScope \|
399	Scope::BlockScope \| Scope::TemplateParamScope \|
400	Scope::FunctionPrototypeScope \|
401	Scope::AtCatchScope \| Scope::ObjCMethodScope))
402	return false;
403	}
404	return false;
405	}
406
407	/// Determines whether this scope is the OpenMP directive scope
408	bool isOpenMPDirectiveScope() const {
409	return (getFlags() & Scope::OpenMPDirectiveScope);
410	}
411
412	/// Determine whether this scope is some OpenMP loop directive scope
413	/// (for example, 'omp for', 'omp simd').
414	bool isOpenMPLoopDirectiveScope() const {
415	if (getFlags() & Scope::OpenMPLoopDirectiveScope) {
416	(0) . __assert_fail ("isOpenMPDirectiveScope() && \"OpenMP loop directive scope is not a directive scope\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Sema/Scope.h", 417, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">assert(isOpenMPDirectiveScope() &&
417	(0) . __assert_fail ("isOpenMPDirectiveScope() && \"OpenMP loop directive scope is not a directive scope\"", "/home/seafit/code_projects/clang_source/clang/include/clang/Sema/Scope.h", 417, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true"> "OpenMP loop directive scope is not a directive scope");
418	return true;
419	}
420	return false;
421	}
422
423	/// Determine whether this scope is (or is nested into) some OpenMP
424	/// loop simd directive scope (for example, 'omp simd', 'omp for simd').
425	bool isOpenMPSimdDirectiveScope() const {
426	return getFlags() & Scope::OpenMPSimdDirectiveScope;
427	}
428
429	/// Determine whether this scope is a loop having OpenMP loop
430	/// directive attached.
431	bool isOpenMPLoopScope() const {
432	const Scope *P = getParent();
433	return P && P->isOpenMPLoopDirectiveScope();
434	}
435
436	/// Determine whether this scope is a C++ 'try' block.
437	bool isTryScope() const { return getFlags() & Scope::TryScope; }
438
439	/// Determine whether this scope is a SEH '__try' block.
440	bool isSEHTryScope() const { return getFlags() & Scope::SEHTryScope; }
441
442	/// Determine whether this scope is a SEH '__except' block.
443	bool isSEHExceptScope() const { return getFlags() & Scope::SEHExceptScope; }
444
445	/// Determine whether this scope is a compound statement scope.
446	bool isCompoundStmtScope() const {
447	return getFlags() & Scope::CompoundStmtScope;
448	}
449
450	/// Returns if rhs has a higher scope depth than this.
451	///
452	/// The caller is responsible for calling this only if one of the two scopes
453	/// is an ancestor of the other.
454	bool Contains(const Scope& rhs) const { return Depth < rhs.Depth; }
455
456	/// containedInPrototypeScope - Return true if this or a parent scope
457	/// is a FunctionPrototypeScope.
458	bool containedInPrototypeScope() const;
459
460	void PushUsingDirective(UsingDirectiveDecl *UDir) {
461	UsingDirectives.push_back(UDir);
462	}
463
464	using using_directives_range =
465	llvm::iterator_range<UsingDirectivesTy::iterator>;
466
467	using_directives_range using_directives() {
468	return using_directives_range(UsingDirectives.begin(),
469	UsingDirectives.end());
470	}
471
472	void addNRVOCandidate(VarDecl *VD) {
473	if (NRVO.getInt())
474	return;
475	if (NRVO.getPointer() == nullptr) {
476	NRVO.setPointer(VD);
477	return;
478	}
479	if (NRVO.getPointer() != VD)
480	setNoNRVO();
481	}
482
483	void setNoNRVO() {
484	NRVO.setInt(true);
485	NRVO.setPointer(nullptr);
486	}
487
488	void mergeNRVOIntoParent();
489
490	/// Init - This is used by the parser to implement scope caching.
491	void Init(Scope *parent, unsigned flags);
492
493	/// Sets up the specified scope flags and adjusts the scope state
494	/// variables accordingly.
495	void AddFlags(unsigned Flags);
496
497	void dumpImpl(raw_ostream &OS) const;
498	void dump() const;
499	};
500
501	} // namespace clang
502
503	#endif // LLVM_CLANG_SEMA_SCOPE_H
504