clang 19.0.0git
Scope.h
Go to the documentation of this file.
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"
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#include <optional>
24
25namespace llvm {
26
27class raw_ostream;
28
29} // namespace llvm
30
31namespace clang {
32
33class Decl;
34class DeclContext;
35class UsingDirectiveDecl;
36class VarDecl;
37
38/// Scope - A scope is a transient data structure that is used while parsing the
39/// program. It assists with resolving identifiers to the appropriate
40/// declaration.
41class Scope {
42public:
43 /// ScopeFlags - These are bitfields that are or'd together when creating a
44 /// scope, which defines the sorts of things the scope contains.
46 // A bitfield value representing no scopes.
48
49 /// This indicates that the scope corresponds to a function, which
50 /// means that labels are set here.
51 FnScope = 0x01,
52
53 /// This is a while, do, switch, for, etc that can have break
54 /// statements embedded into it.
55 BreakScope = 0x02,
56
57 /// This is a while, do, for, which can have continue statements
58 /// embedded into it.
60
61 /// This is a scope that can contain a declaration. Some scopes
62 /// just contain loop constructs but don't contain decls.
63 DeclScope = 0x08,
64
65 /// The controlling scope in a if/switch/while/for statement.
67
68 /// The scope of a struct/union/class definition.
69 ClassScope = 0x20,
70
71 /// This is a scope that corresponds to a block/closure object.
72 /// Blocks serve as top-level scopes for some objects like labels, they
73 /// also prevent things like break and continue. BlockScopes always have
74 /// the FnScope and DeclScope flags set as well.
75 BlockScope = 0x40,
76
77 /// This is a scope that corresponds to the
78 /// template parameters of a C++ template. Template parameter
79 /// scope starts at the 'template' keyword and ends when the
80 /// template declaration ends.
82
83 /// This is a scope that corresponds to the
84 /// parameters within a function prototype.
86
87 /// This is a scope that corresponds to the parameters within
88 /// a function prototype for a function declaration (as opposed to any
89 /// other kind of function declarator). Always has FunctionPrototypeScope
90 /// set as well.
92
93 /// This is a scope that corresponds to the Objective-C
94 /// \@catch statement.
95 AtCatchScope = 0x400,
96
97 /// This scope corresponds to an Objective-C method body.
98 /// It always has FnScope and DeclScope set as well.
100
101 /// This is a scope that corresponds to a switch statement.
102 SwitchScope = 0x1000,
103
104 /// This is the scope of a C++ try statement.
105 TryScope = 0x2000,
106
107 /// This is the scope for a function-level C++ try or catch scope.
109
110 /// This is the scope of OpenMP executable directive.
112
113 /// This is the scope of some OpenMP loop directive.
115
116 /// This is the scope of some OpenMP simd directive.
117 /// For example, it is used for 'omp simd', 'omp for simd'.
118 /// This flag is propagated to children scopes.
120
121 /// This scope corresponds to an enum.
122 EnumScope = 0x40000,
123
124 /// This scope corresponds to an SEH try.
125 SEHTryScope = 0x80000,
126
127 /// This scope corresponds to an SEH except.
128 SEHExceptScope = 0x100000,
129
130 /// We are currently in the filter expression of an SEH except block.
131 SEHFilterScope = 0x200000,
132
133 /// This is a compound statement scope.
135
136 /// We are between inheritance colon and the real class/struct definition
137 /// scope.
139
140 /// This is the scope of a C++ catch statement.
141 CatchScope = 0x1000000,
142
143 /// This is a scope in which a condition variable is currently being
144 /// parsed. If such a scope is a ContinueScope, it's invalid to jump to the
145 /// continue block from here.
146 ConditionVarScope = 0x2000000,
147
148 /// This is a scope of some OpenMP directive with
149 /// order clause which specifies concurrent
151 /// This is the scope for a lambda, after the lambda introducer.
152 /// Lambdas need two FunctionPrototypeScope scopes (because there is a
153 /// template scope in between), the outer scope does not increase the
154 /// depth of recursion.
155 LambdaScope = 0x8000000,
156 /// This is the scope of an OpenACC Compute Construct, which restricts
157 /// jumping into/out of it.
159 };
160
161private:
162 /// The parent scope for this scope. This is null for the translation-unit
163 /// scope.
164 Scope *AnyParent;
165
166 /// Flags - This contains a set of ScopeFlags, which indicates how the scope
167 /// interrelates with other control flow statements.
168 unsigned Flags;
169
170 /// Depth - This is the depth of this scope. The translation-unit scope has
171 /// depth 0.
172 unsigned short Depth;
173
174 /// Declarations with static linkage are mangled with the number of
175 /// scopes seen as a component.
176 unsigned short MSLastManglingNumber;
177
178 unsigned short MSCurManglingNumber;
179
180 /// PrototypeDepth - This is the number of function prototype scopes
181 /// enclosing this scope, including this scope.
182 unsigned short PrototypeDepth;
183
184 /// PrototypeIndex - This is the number of parameters currently
185 /// declared in this scope.
186 unsigned short PrototypeIndex;
187
188 /// FnParent - If this scope has a parent scope that is a function body, this
189 /// pointer is non-null and points to it. This is used for label processing.
190 Scope *FnParent;
191 Scope *MSLastManglingParent;
192
193 /// BreakParent/ContinueParent - This is a direct link to the innermost
194 /// BreakScope/ContinueScope which contains the contents of this scope
195 /// for control flow purposes (and might be this scope itself), or null
196 /// if there is no such scope.
197 Scope *BreakParent, *ContinueParent;
198
199 /// BlockParent - This is a direct link to the immediately containing
200 /// BlockScope if this scope is not one, or null if there is none.
201 Scope *BlockParent;
202
203 /// TemplateParamParent - This is a direct link to the
204 /// immediately containing template parameter scope. In the
205 /// case of nested templates, template parameter scopes can have
206 /// other template parameter scopes as parents.
207 Scope *TemplateParamParent;
208
209 /// DeclScopeParent - This is a direct link to the immediately containing
210 /// DeclScope, i.e. scope which can contain declarations.
211 Scope *DeclParent;
212
213 /// DeclsInScope - This keeps track of all declarations in this scope. When
214 /// the declaration is added to the scope, it is set as the current
215 /// declaration for the identifier in the IdentifierTable. When the scope is
216 /// popped, these declarations are removed from the IdentifierTable's notion
217 /// of current declaration. It is up to the current Action implementation to
218 /// implement these semantics.
219 using DeclSetTy = llvm::SmallPtrSet<Decl *, 32>;
220 DeclSetTy DeclsInScope;
221
222 /// The DeclContext with which this scope is associated. For
223 /// example, the entity of a class scope is the class itself, the
224 /// entity of a function scope is a function, etc.
225 DeclContext *Entity;
226
227 using UsingDirectivesTy = SmallVector<UsingDirectiveDecl *, 2>;
228 UsingDirectivesTy UsingDirectives;
229
230 /// Used to determine if errors occurred in this scope.
231 DiagnosticErrorTrap ErrorTrap;
232
233 /// A single NRVO candidate variable in this scope.
234 /// There are three possible values:
235 /// 1) pointer to VarDecl that denotes NRVO candidate itself.
236 /// 2) nullptr value means that NRVO is not allowed in this scope
237 /// (e.g. return a function parameter).
238 /// 3) std::nullopt value means that there is no NRVO candidate in this scope
239 /// (i.e. there are no return statements in this scope).
240 std::optional<VarDecl *> NRVO;
241
242 /// Represents return slots for NRVO candidates in the current scope.
243 /// If a variable is present in this set, it means that a return slot is
244 /// available for this variable in the current scope.
246
247 void setFlags(Scope *Parent, unsigned F);
248
249public:
251 : ErrorTrap(Diag) {
253 }
254
255 /// getFlags - Return the flags for this scope.
256 unsigned getFlags() const { return Flags; }
257
258 void setFlags(unsigned F) { setFlags(getParent(), F); }
259
260 /// isBlockScope - Return true if this scope correspond to a closure.
261 bool isBlockScope() const { return Flags & BlockScope; }
262
263 /// getParent - Return the scope that this is nested in.
264 const Scope *getParent() const { return AnyParent; }
265 Scope *getParent() { return AnyParent; }
266
267 /// getFnParent - Return the closest scope that is a function body.
268 const Scope *getFnParent() const { return FnParent; }
269 Scope *getFnParent() { return FnParent; }
270
272 return MSLastManglingParent;
273 }
274 Scope *getMSLastManglingParent() { return MSLastManglingParent; }
275
276 /// getContinueParent - Return the closest scope that a continue statement
277 /// would be affected by.
279 return ContinueParent;
280 }
281
282 const Scope *getContinueParent() const {
283 return const_cast<Scope*>(this)->getContinueParent();
284 }
285
286 // Set whether we're in the scope of a condition variable, where 'continue'
287 // is disallowed despite being a continue scope.
288 void setIsConditionVarScope(bool InConditionVarScope) {
289 Flags = (Flags & ~ConditionVarScope) |
290 (InConditionVarScope ? ConditionVarScope : 0);
291 }
292
293 bool isConditionVarScope() const {
294 return Flags & ConditionVarScope;
295 }
296
297 /// getBreakParent - Return the closest scope that a break statement
298 /// would be affected by.
300 return BreakParent;
301 }
302 const Scope *getBreakParent() const {
303 return const_cast<Scope*>(this)->getBreakParent();
304 }
305
306 Scope *getBlockParent() { return BlockParent; }
307 const Scope *getBlockParent() const { return BlockParent; }
308
309 Scope *getTemplateParamParent() { return TemplateParamParent; }
310 const Scope *getTemplateParamParent() const { return TemplateParamParent; }
311
312 Scope *getDeclParent() { return DeclParent; }
313 const Scope *getDeclParent() const { return DeclParent; }
314
315 /// Returns the depth of this scope. The translation-unit has scope depth 0.
316 unsigned getDepth() const { return Depth; }
317
318 /// Returns the number of function prototype scopes in this scope
319 /// chain.
320 unsigned getFunctionPrototypeDepth() const {
321 return PrototypeDepth;
322 }
323
324 /// Return the number of parameters declared in this function
325 /// prototype, increasing it by one for the next call.
327 assert(isFunctionPrototypeScope());
328 return PrototypeIndex++;
329 }
330
331 using decl_range = llvm::iterator_range<DeclSetTy::iterator>;
332
334 return decl_range(DeclsInScope.begin(), DeclsInScope.end());
335 }
336
337 bool decl_empty() const { return DeclsInScope.empty(); }
338
339 void AddDecl(Decl *D) {
340 if (auto *VD = dyn_cast<VarDecl>(D))
341 if (!isa<ParmVarDecl>(VD))
342 ReturnSlots.insert(VD);
343
344 DeclsInScope.insert(D);
345 }
346
347 void RemoveDecl(Decl *D) { DeclsInScope.erase(D); }
348
350 if (Scope *MSLMP = getMSLastManglingParent()) {
351 MSLMP->MSLastManglingNumber += 1;
352 MSCurManglingNumber += 1;
353 }
354 }
355
357 if (Scope *MSLMP = getMSLastManglingParent()) {
358 MSLMP->MSLastManglingNumber -= 1;
359 MSCurManglingNumber -= 1;
360 }
361 }
362
363 unsigned getMSLastManglingNumber() const {
364 if (const Scope *MSLMP = getMSLastManglingParent())
365 return MSLMP->MSLastManglingNumber;
366 return 1;
367 }
368
369 unsigned getMSCurManglingNumber() const {
370 return MSCurManglingNumber;
371 }
372
373 /// isDeclScope - Return true if this is the scope that the specified decl is
374 /// declared in.
375 bool isDeclScope(const Decl *D) const { return DeclsInScope.contains(D); }
376
377 /// Get the entity corresponding to this scope.
379 return isTemplateParamScope() ? nullptr : Entity;
380 }
381
382 /// Get the DeclContext in which to continue unqualified lookup after a
383 /// lookup in this scope.
384 DeclContext *getLookupEntity() const { return Entity; }
385
387 assert(!isTemplateParamScope() &&
388 "entity associated with template param scope");
389 Entity = E;
390 }
391 void setLookupEntity(DeclContext *E) { Entity = E; }
392
393 /// Determine whether any unrecoverable errors have occurred within this
394 /// scope. Note that this may return false even if the scope contains invalid
395 /// declarations or statements, if the errors for those invalid constructs
396 /// were suppressed because some prior invalid construct was referenced.
398 return ErrorTrap.hasUnrecoverableErrorOccurred();
399 }
400
401 /// isFunctionScope() - Return true if this scope is a function scope.
402 bool isFunctionScope() const { return getFlags() & Scope::FnScope; }
403
404 /// isClassScope - Return true if this scope is a class/struct/union scope.
405 bool isClassScope() const { return getFlags() & Scope::ClassScope; }
406
407 /// Determines whether this scope is between inheritance colon and the real
408 /// class/struct definition.
411 }
412
413 /// isInCXXInlineMethodScope - Return true if this scope is a C++ inline
414 /// method scope or is inside one.
416 if (const Scope *FnS = getFnParent()) {
417 assert(FnS->getParent() && "TUScope not created?");
418 return FnS->getParent()->isClassScope();
419 }
420 return false;
421 }
422
423 /// isInObjcMethodScope - Return true if this scope is, or is contained in, an
424 /// Objective-C method body. Note that this method is not constant time.
425 bool isInObjcMethodScope() const {
426 for (const Scope *S = this; S; S = S->getParent()) {
427 // If this scope is an objc method scope, then we succeed.
428 if (S->getFlags() & ObjCMethodScope)
429 return true;
430 }
431 return false;
432 }
433
434 /// isInObjcMethodOuterScope - Return true if this scope is an
435 /// Objective-C method outer most body.
437 if (const Scope *S = this) {
438 // If this scope is an objc method scope, then we succeed.
439 if (S->getFlags() & ObjCMethodScope)
440 return true;
441 }
442 return false;
443 }
444
445 /// isTemplateParamScope - Return true if this scope is a C++
446 /// template parameter scope.
447 bool isTemplateParamScope() const {
449 }
450
451 /// isFunctionPrototypeScope - Return true if this scope is a
452 /// function prototype scope.
455 }
456
457 /// isFunctionDeclarationScope - Return true if this scope is a
458 /// function prototype scope.
461 }
462
463 /// isAtCatchScope - Return true if this scope is \@catch.
464 bool isAtCatchScope() const {
465 return getFlags() & Scope::AtCatchScope;
466 }
467
468 /// isCatchScope - Return true if this scope is a C++ catch statement.
469 bool isCatchScope() const { return getFlags() & Scope::CatchScope; }
470
471 /// isSwitchScope - Return true if this scope is a switch scope.
472 bool isSwitchScope() const {
473 for (const Scope *S = this; S; S = S->getParent()) {
474 if (S->getFlags() & Scope::SwitchScope)
475 return true;
476 else if (S->getFlags() & (Scope::FnScope | Scope::ClassScope |
480 return false;
481 }
482 return false;
483 }
484
485 /// Return true if this scope is a loop.
486 bool isLoopScope() const {
487 // 'switch' is the only loop that is not a 'break' scope as well, so we can
488 // just check BreakScope and not SwitchScope.
489 return (getFlags() & Scope::BreakScope) &&
491 }
492
493 /// Determines whether this scope is the OpenMP directive scope
496 }
497
498 /// Determine whether this scope is some OpenMP loop directive scope
499 /// (for example, 'omp for', 'omp simd').
502 assert(isOpenMPDirectiveScope() &&
503 "OpenMP loop directive scope is not a directive scope");
504 return true;
505 }
506 return false;
507 }
508
509 /// Determine whether this scope is (or is nested into) some OpenMP
510 /// loop simd directive scope (for example, 'omp simd', 'omp for simd').
513 }
514
515 /// Determine whether this scope is a loop having OpenMP loop
516 /// directive attached.
517 bool isOpenMPLoopScope() const {
518 const Scope *P = getParent();
519 return P && P->isOpenMPLoopDirectiveScope();
520 }
521
522 /// Determine whether this scope is some OpenMP directive with
523 /// order clause which specifies concurrent scope.
526 }
527
528 /// Determine whether this scope is the statement associated with an OpenACC
529 /// Compute construct directive.
532 }
533
534 /// Determine if this scope (or its parents) are a compute construct. If the
535 /// argument is provided, the search will stop at any of the specified scopes.
536 /// Otherwise, it will stop only at the normal 'no longer search' scopes.
538 for (const Scope *S = this; S; S = S->getParent()) {
539 if (S->isOpenACCComputeConstructScope())
540 return true;
541
542 if (S->getFlags() & Flags)
543 return false;
544
545 else if (S->getFlags() &
549 return false;
550 }
551 return false;
552 }
553
554 /// Determine whether this scope is a while/do/for statement, which can have
555 /// continue statements embedded into it.
556 bool isContinueScope() const {
558 }
559
560 /// Determine whether this scope is a C++ 'try' block.
561 bool isTryScope() const { return getFlags() & Scope::TryScope; }
562
563 /// Determine whether this scope is a function-level C++ try or catch scope.
564 bool isFnTryCatchScope() const {
566 }
567
568 /// Determine whether this scope is a SEH '__try' block.
569 bool isSEHTryScope() const { return getFlags() & Scope::SEHTryScope; }
570
571 /// Determine whether this scope is a SEH '__except' block.
573
574 /// Determine whether this scope is a compound statement scope.
575 bool isCompoundStmtScope() const {
577 }
578
579 /// Determine whether this scope is a controlling scope in a
580 /// if/switch/while/for statement.
581 bool isControlScope() const { return getFlags() & Scope::ControlScope; }
582
583 /// Returns if rhs has a higher scope depth than this.
584 ///
585 /// The caller is responsible for calling this only if one of the two scopes
586 /// is an ancestor of the other.
587 bool Contains(const Scope& rhs) const { return Depth < rhs.Depth; }
588
589 /// containedInPrototypeScope - Return true if this or a parent scope
590 /// is a FunctionPrototypeScope.
591 bool containedInPrototypeScope() const;
592
594 UsingDirectives.push_back(UDir);
595 }
596
598 llvm::iterator_range<UsingDirectivesTy::iterator>;
599
601 return using_directives_range(UsingDirectives.begin(),
602 UsingDirectives.end());
603 }
604
606
607 void applyNRVO();
608
609 /// Init - This is used by the parser to implement scope caching.
610 void Init(Scope *parent, unsigned flags);
611
612 /// Sets up the specified scope flags and adjusts the scope state
613 /// variables accordingly.
614 void AddFlags(unsigned Flags);
615
616 void dumpImpl(raw_ostream &OS) const;
617 void dump() const;
618};
619
620} // namespace clang
621
622#endif // LLVM_CLANG_SEMA_SCOPE_H
NodeId Parent
Definition: ASTDiff.cpp:191
StringRef P
Defines the Diagnostic-related interfaces.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1445
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:1077
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created.
Definition: Diagnostic.h:1094
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
Scope * getMSLastManglingParent()
Definition: Scope.h:274
void setEntity(DeclContext *E)
Definition: Scope.h:386
void AddFlags(unsigned Flags)
Sets up the specified scope flags and adjusts the scope state variables accordingly.
Definition: Scope.cpp:115
bool isClassScope() const
isClassScope - Return true if this scope is a class/struct/union scope.
Definition: Scope.h:405
bool isBlockScope() const
isBlockScope - Return true if this scope correspond to a closure.
Definition: Scope.h:261
unsigned getDepth() const
Returns the depth of this scope. The translation-unit has scope depth 0.
Definition: Scope.h:316
unsigned getNextFunctionPrototypeIndex()
Return the number of parameters declared in this function prototype, increasing it by one for the nex...
Definition: Scope.h:326
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:268
void AddDecl(Decl *D)
Definition: Scope.h:339
bool isSEHExceptScope() const
Determine whether this scope is a SEH '__except' block.
Definition: Scope.h:572
llvm::iterator_range< DeclSetTy::iterator > decl_range
Definition: Scope.h:331
bool isInObjcMethodOuterScope() const
isInObjcMethodOuterScope - Return true if this scope is an Objective-C method outer most body.
Definition: Scope.h:436
bool isAtCatchScope() const
isAtCatchScope - Return true if this scope is @catch.
Definition: Scope.h:464
bool isCatchScope() const
isCatchScope - Return true if this scope is a C++ catch statement.
Definition: Scope.h:469
void setFlags(unsigned F)
Definition: Scope.h:258
bool isInObjcMethodScope() const
isInObjcMethodScope - Return true if this scope is, or is contained in, an Objective-C method body.
Definition: Scope.h:425
void incrementMSManglingNumber()
Definition: Scope.h:349
const Scope * getBreakParent() const
Definition: Scope.h:302
bool isInCXXInlineMethodScope() const
isInCXXInlineMethodScope - Return true if this scope is a C++ inline method scope or is inside one.
Definition: Scope.h:415
bool Contains(const Scope &rhs) const
Returns if rhs has a higher scope depth than this.
Definition: Scope.h:587
const Scope * getMSLastManglingParent() const
Definition: Scope.h:271
bool isOpenMPLoopDirectiveScope() const
Determine whether this scope is some OpenMP loop directive scope (for example, 'omp for',...
Definition: Scope.h:500
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:256
DeclContext * getLookupEntity() const
Get the DeclContext in which to continue unqualified lookup after a lookup in this scope.
Definition: Scope.h:384
bool isSwitchScope() const
isSwitchScope - Return true if this scope is a switch scope.
Definition: Scope.h:472
bool isOpenMPDirectiveScope() const
Determines whether this scope is the OpenMP directive scope.
Definition: Scope.h:494
using_directives_range using_directives()
Definition: Scope.h:600
Scope * getContinueParent()
getContinueParent - Return the closest scope that a continue statement would be affected by.
Definition: Scope.h:278
llvm::iterator_range< UsingDirectivesTy::iterator > using_directives_range
Definition: Scope.h:598
Scope(Scope *Parent, unsigned ScopeFlags, DiagnosticsEngine &Diag)
Definition: Scope.h:250
void setIsConditionVarScope(bool InConditionVarScope)
Definition: Scope.h:288
bool isDeclScope(const Decl *D) const
isDeclScope - Return true if this is the scope that the specified decl is declared in.
Definition: Scope.h:375
bool isFnTryCatchScope() const
Determine whether this scope is a function-level C++ try or catch scope.
Definition: Scope.h:564
void decrementMSManglingNumber()
Definition: Scope.h:356
bool isControlScope() const
Determine whether this scope is a controlling scope in a if/switch/while/for statement.
Definition: Scope.h:581
void RemoveDecl(Decl *D)
Definition: Scope.h:347
const Scope * getTemplateParamParent() const
Definition: Scope.h:310
void setLookupEntity(DeclContext *E)
Definition: Scope.h:391
unsigned getMSLastManglingNumber() const
Definition: Scope.h:363
void dump() const
Definition: Scope.cpp:196
DeclContext * getEntity() const
Get the entity corresponding to this scope.
Definition: Scope.h:378
Scope * getBlockParent()
Definition: Scope.h:306
unsigned getMSCurManglingNumber() const
Definition: Scope.h:369
bool isLoopScope() const
Return true if this scope is a loop.
Definition: Scope.h:486
bool isSEHTryScope() const
Determine whether this scope is a SEH '__try' block.
Definition: Scope.h:569
bool decl_empty() const
Definition: Scope.h:337
bool isOpenMPSimdDirectiveScope() const
Determine whether this scope is (or is nested into) some OpenMP loop simd directive scope (for exampl...
Definition: Scope.h:511
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:447
Scope * getFnParent()
Definition: Scope.h:269
unsigned getFunctionPrototypeDepth() const
Returns the number of function prototype scopes in this scope chain.
Definition: Scope.h:320
Scope * getBreakParent()
getBreakParent - Return the closest scope that a break statement would be affected by.
Definition: Scope.h:299
Scope * getDeclParent()
Definition: Scope.h:312
bool isCompoundStmtScope() const
Determine whether this scope is a compound statement scope.
Definition: Scope.h:575
decl_range decls() const
Definition: Scope.h:333
bool isInOpenACCComputeConstructScope(ScopeFlags Flags=NoScope) const
Determine if this scope (or its parents) are a compute construct.
Definition: Scope.h:537
bool isFunctionDeclarationScope() const
isFunctionDeclarationScope - Return true if this scope is a function prototype scope.
Definition: Scope.h:459
bool containedInPrototypeScope() const
containedInPrototypeScope - Return true if this or a parent scope is a FunctionPrototypeScope.
Definition: Scope.cpp:105
bool isOpenMPOrderClauseScope() const
Determine whether this scope is some OpenMP directive with order clause which specifies concurrent sc...
Definition: Scope.h:524
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:264
bool isContinueScope() const
Determine whether this scope is a while/do/for statement, which can have continue statements embedded...
Definition: Scope.h:556
Scope * getParent()
Definition: Scope.h:265
bool isClassInheritanceScope() const
Determines whether this scope is between inheritance colon and the real class/struct definition.
Definition: Scope.h:409
bool isConditionVarScope() const
Definition: Scope.h:293
bool isFunctionPrototypeScope() const
isFunctionPrototypeScope - Return true if this scope is a function prototype scope.
Definition: Scope.h:453
bool isTryScope() const
Determine whether this scope is a C++ 'try' block.
Definition: Scope.h:561
void updateNRVOCandidate(VarDecl *VD)
Definition: Scope.cpp:136
const Scope * getBlockParent() const
Definition: Scope.h:307
bool isFunctionScope() const
isFunctionScope() - Return true if this scope is a function scope.
Definition: Scope.h:402
const Scope * getContinueParent() const
Definition: Scope.h:282
bool isOpenACCComputeConstructScope() const
Determine whether this scope is the statement associated with an OpenACC Compute construct directive.
Definition: Scope.h:530
void dumpImpl(raw_ostream &OS) const
Definition: Scope.cpp:198
const Scope * getDeclParent() const
Definition: Scope.h:313
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred within this scope.
Definition: Scope.h:397
void applyNRVO()
Definition: Scope.cpp:165
bool isOpenMPLoopScope() const
Determine whether this scope is a loop having OpenMP loop directive attached.
Definition: Scope.h:517
Scope * getTemplateParamParent()
Definition: Scope.h:309
ScopeFlags
ScopeFlags - These are bitfields that are or'd together when creating a scope, which defines the sort...
Definition: Scope.h:45
@ OpenMPDirectiveScope
This is the scope of OpenMP executable directive.
Definition: Scope.h:111
@ FunctionPrototypeScope
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:85
@ OpenMPOrderClauseScope
This is a scope of some OpenMP directive with order clause which specifies concurrent.
Definition: Scope.h:150
@ LambdaScope
This is the scope for a lambda, after the lambda introducer.
Definition: Scope.h:155
@ NoScope
Definition: Scope.h:47
@ BlockScope
This is a scope that corresponds to a block/closure object.
Definition: Scope.h:75
@ SEHTryScope
This scope corresponds to an SEH try.
Definition: Scope.h:125
@ ContinueScope
This is a while, do, for, which can have continue statements embedded into it.
Definition: Scope.h:59
@ OpenACCComputeConstructScope
This is the scope of an OpenACC Compute Construct, which restricts jumping into/out of it.
Definition: Scope.h:158
@ ControlScope
The controlling scope in a if/switch/while/for statement.
Definition: Scope.h:66
@ ClassInheritanceScope
We are between inheritance colon and the real class/struct definition scope.
Definition: Scope.h:138
@ AtCatchScope
This is a scope that corresponds to the Objective-C @catch statement.
Definition: Scope.h:95
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:81
@ SEHFilterScope
We are currently in the filter expression of an SEH except block.
Definition: Scope.h:131
@ SwitchScope
This is a scope that corresponds to a switch statement.
Definition: Scope.h:102
@ BreakScope
This is a while, do, switch, for, etc that can have break statements embedded into it.
Definition: Scope.h:55
@ CatchScope
This is the scope of a C++ catch statement.
Definition: Scope.h:141
@ CompoundStmtScope
This is a compound statement scope.
Definition: Scope.h:134
@ FnTryCatchScope
This is the scope for a function-level C++ try or catch scope.
Definition: Scope.h:108
@ SEHExceptScope
This scope corresponds to an SEH except.
Definition: Scope.h:128
@ ClassScope
The scope of a struct/union/class definition.
Definition: Scope.h:69
@ TryScope
This is the scope of a C++ try statement.
Definition: Scope.h:105
@ OpenMPSimdDirectiveScope
This is the scope of some OpenMP simd directive.
Definition: Scope.h:119
@ FunctionDeclarationScope
This is a scope that corresponds to the parameters within a function prototype for a function declara...
Definition: Scope.h:91
@ ConditionVarScope
This is a scope in which a condition variable is currently being parsed.
Definition: Scope.h:146
@ FnScope
This indicates that the scope corresponds to a function, which means that labels are set here.
Definition: Scope.h:51
@ ObjCMethodScope
This scope corresponds to an Objective-C method body.
Definition: Scope.h:99
@ EnumScope
This scope corresponds to an enum.
Definition: Scope.h:122
@ OpenMPLoopDirectiveScope
This is the scope of some OpenMP loop directive.
Definition: Scope.h:114
@ DeclScope
This is a scope that can contain a declaration.
Definition: Scope.h:63
void PushUsingDirective(UsingDirectiveDecl *UDir)
Definition: Scope.h:593
Represents C++ using-directive.
Definition: DeclCXX.h:3012
Represents a variable declaration or definition.
Definition: Decl.h:918
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
The JSON file list parser is used to communicate input to InstallAPI.
Diagnostic wrappers for TextAPI types for error reporting.
Definition: Dominators.h:30