clang  14.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"
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.
78 
79  /// This is a scope that corresponds to the
80  /// parameters within a function prototype.
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.
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.
108 
109  /// This is the scope of some OpenMP loop directive.
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.
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
133  /// scope.
135 
136  /// This is the scope of a C++ catch statement.
137  CatchScope = 0x1000000,
138 
139  /// This is a scope in which a condition variable is currently being
140  /// parsed. If such a scope is a ContinueScope, it's invalid to jump to the
141  /// continue block from here.
142  ConditionVarScope = 0x2000000,
143  };
144 
145 private:
146  /// The parent scope for this scope. This is null for the translation-unit
147  /// scope.
148  Scope *AnyParent;
149 
150  /// Flags - This contains a set of ScopeFlags, which indicates how the scope
151  /// interrelates with other control flow statements.
152  unsigned Flags;
153 
154  /// Depth - This is the depth of this scope. The translation-unit scope has
155  /// depth 0.
156  unsigned short Depth;
157 
158  /// Declarations with static linkage are mangled with the number of
159  /// scopes seen as a component.
160  unsigned short MSLastManglingNumber;
161 
162  unsigned short MSCurManglingNumber;
163 
164  /// PrototypeDepth - This is the number of function prototype scopes
165  /// enclosing this scope, including this scope.
166  unsigned short PrototypeDepth;
167 
168  /// PrototypeIndex - This is the number of parameters currently
169  /// declared in this scope.
170  unsigned short PrototypeIndex;
171 
172  /// FnParent - If this scope has a parent scope that is a function body, this
173  /// pointer is non-null and points to it. This is used for label processing.
174  Scope *FnParent;
175  Scope *MSLastManglingParent;
176 
177  /// BreakParent/ContinueParent - This is a direct link to the innermost
178  /// BreakScope/ContinueScope which contains the contents of this scope
179  /// for control flow purposes (and might be this scope itself), or null
180  /// if there is no such scope.
181  Scope *BreakParent, *ContinueParent;
182 
183  /// BlockParent - This is a direct link to the immediately containing
184  /// BlockScope if this scope is not one, or null if there is none.
185  Scope *BlockParent;
186 
187  /// TemplateParamParent - This is a direct link to the
188  /// immediately containing template parameter scope. In the
189  /// case of nested templates, template parameter scopes can have
190  /// other template parameter scopes as parents.
191  Scope *TemplateParamParent;
192 
193  /// DeclsInScope - This keeps track of all declarations in this scope. When
194  /// the declaration is added to the scope, it is set as the current
195  /// declaration for the identifier in the IdentifierTable. When the scope is
196  /// popped, these declarations are removed from the IdentifierTable's notion
197  /// of current declaration. It is up to the current Action implementation to
198  /// implement these semantics.
199  using DeclSetTy = llvm::SmallPtrSet<Decl *, 32>;
200  DeclSetTy DeclsInScope;
201 
202  /// The DeclContext with which this scope is associated. For
203  /// example, the entity of a class scope is the class itself, the
204  /// entity of a function scope is a function, etc.
205  DeclContext *Entity;
206 
207  using UsingDirectivesTy = SmallVector<UsingDirectiveDecl *, 2>;
208  UsingDirectivesTy UsingDirectives;
209 
210  /// Used to determine if errors occurred in this scope.
211  DiagnosticErrorTrap ErrorTrap;
212 
213  /// A lattice consisting of undefined, a single NRVO candidate variable in
214  /// this scope, or over-defined. The bit is true when over-defined.
215  llvm::PointerIntPair<VarDecl *, 1, bool> NRVO;
216 
217  void setFlags(Scope *Parent, unsigned F);
218 
219 public:
221  : ErrorTrap(Diag) {
223  }
224 
225  /// getFlags - Return the flags for this scope.
226  unsigned getFlags() const { return Flags; }
227 
228  void setFlags(unsigned F) { setFlags(getParent(), F); }
229 
230  /// isBlockScope - Return true if this scope correspond to a closure.
231  bool isBlockScope() const { return Flags & BlockScope; }
232 
233  /// getParent - Return the scope that this is nested in.
234  const Scope *getParent() const { return AnyParent; }
235  Scope *getParent() { return AnyParent; }
236 
237  /// getFnParent - Return the closest scope that is a function body.
238  const Scope *getFnParent() const { return FnParent; }
239  Scope *getFnParent() { return FnParent; }
240 
242  return MSLastManglingParent;
243  }
244  Scope *getMSLastManglingParent() { return MSLastManglingParent; }
245 
246  /// getContinueParent - Return the closest scope that a continue statement
247  /// would be affected by.
249  return ContinueParent;
250  }
251 
252  const Scope *getContinueParent() const {
253  return const_cast<Scope*>(this)->getContinueParent();
254  }
255 
256  // Set whether we're in the scope of a condition variable, where 'continue'
257  // is disallowed despite being a continue scope.
258  void setIsConditionVarScope(bool InConditionVarScope) {
259  Flags = (Flags & ~ConditionVarScope) |
260  (InConditionVarScope ? ConditionVarScope : 0);
261  }
262 
263  bool isConditionVarScope() const {
264  return Flags & ConditionVarScope;
265  }
266 
267  /// getBreakParent - Return the closest scope that a break statement
268  /// would be affected by.
270  return BreakParent;
271  }
272  const Scope *getBreakParent() const {
273  return const_cast<Scope*>(this)->getBreakParent();
274  }
275 
276  Scope *getBlockParent() { return BlockParent; }
277  const Scope *getBlockParent() const { return BlockParent; }
278 
279  Scope *getTemplateParamParent() { return TemplateParamParent; }
280  const Scope *getTemplateParamParent() const { return TemplateParamParent; }
281 
282  /// Returns the depth of this scope. The translation-unit has scope depth 0.
283  unsigned getDepth() const { return Depth; }
284 
285  /// Returns the number of function prototype scopes in this scope
286  /// chain.
287  unsigned getFunctionPrototypeDepth() const {
288  return PrototypeDepth;
289  }
290 
291  /// Return the number of parameters declared in this function
292  /// prototype, increasing it by one for the next call.
294  assert(isFunctionPrototypeScope());
295  return PrototypeIndex++;
296  }
297 
298  using decl_range = llvm::iterator_range<DeclSetTy::iterator>;
299 
300  decl_range decls() const {
301  return decl_range(DeclsInScope.begin(), DeclsInScope.end());
302  }
303 
304  bool decl_empty() const { return DeclsInScope.empty(); }
305 
306  void AddDecl(Decl *D) {
307  DeclsInScope.insert(D);
308  }
309 
310  void RemoveDecl(Decl *D) {
311  DeclsInScope.erase(D);
312  }
313 
315  if (Scope *MSLMP = getMSLastManglingParent()) {
316  MSLMP->MSLastManglingNumber += 1;
317  MSCurManglingNumber += 1;
318  }
319  }
320 
322  if (Scope *MSLMP = getMSLastManglingParent()) {
323  MSLMP->MSLastManglingNumber -= 1;
324  MSCurManglingNumber -= 1;
325  }
326  }
327 
328  unsigned getMSLastManglingNumber() const {
329  if (const Scope *MSLMP = getMSLastManglingParent())
330  return MSLMP->MSLastManglingNumber;
331  return 1;
332  }
333 
334  unsigned getMSCurManglingNumber() const {
335  return MSCurManglingNumber;
336  }
337 
338  /// isDeclScope - Return true if this is the scope that the specified decl is
339  /// declared in.
340  bool isDeclScope(const Decl *D) const { return DeclsInScope.count(D) != 0; }
341 
342  /// Get the entity corresponding to this scope.
344  return isTemplateParamScope() ? nullptr : Entity;
345  }
346 
347  /// Get the DeclContext in which to continue unqualified lookup after a
348  /// lookup in this scope.
349  DeclContext *getLookupEntity() const { return Entity; }
350 
352  assert(!isTemplateParamScope() &&
353  "entity associated with template param scope");
354  Entity = E;
355  }
356  void setLookupEntity(DeclContext *E) { Entity = E; }
357 
358  /// Determine whether any unrecoverable errors have occurred within this
359  /// scope. Note that this may return false even if the scope contains invalid
360  /// declarations or statements, if the errors for those invalid constructs
361  /// were suppressed because some prior invalid construct was referenced.
363  return ErrorTrap.hasUnrecoverableErrorOccurred();
364  }
365 
366  /// isFunctionScope() - Return true if this scope is a function scope.
367  bool isFunctionScope() const { return (getFlags() & Scope::FnScope); }
368 
369  /// isClassScope - Return true if this scope is a class/struct/union scope.
370  bool isClassScope() const {
371  return (getFlags() & Scope::ClassScope);
372  }
373 
374  /// isInCXXInlineMethodScope - Return true if this scope is a C++ inline
375  /// method scope or is inside one.
377  if (const Scope *FnS = getFnParent()) {
378  assert(FnS->getParent() && "TUScope not created?");
379  return FnS->getParent()->isClassScope();
380  }
381  return false;
382  }
383 
384  /// isInObjcMethodScope - Return true if this scope is, or is contained in, an
385  /// Objective-C method body. Note that this method is not constant time.
386  bool isInObjcMethodScope() const {
387  for (const Scope *S = this; S; S = S->getParent()) {
388  // If this scope is an objc method scope, then we succeed.
389  if (S->getFlags() & ObjCMethodScope)
390  return true;
391  }
392  return false;
393  }
394 
395  /// isInObjcMethodOuterScope - Return true if this scope is an
396  /// Objective-C method outer most body.
398  if (const Scope *S = this) {
399  // If this scope is an objc method scope, then we succeed.
400  if (S->getFlags() & ObjCMethodScope)
401  return true;
402  }
403  return false;
404  }
405 
406  /// isTemplateParamScope - Return true if this scope is a C++
407  /// template parameter scope.
408  bool isTemplateParamScope() const {
410  }
411 
412  /// isFunctionPrototypeScope - Return true if this scope is a
413  /// function prototype scope.
416  }
417 
418  /// isFunctionDeclarationScope - Return true if this scope is a
419  /// function prototype scope.
422  }
423 
424  /// isAtCatchScope - Return true if this scope is \@catch.
425  bool isAtCatchScope() const {
426  return getFlags() & Scope::AtCatchScope;
427  }
428 
429  /// isSwitchScope - Return true if this scope is a switch scope.
430  bool isSwitchScope() const {
431  for (const Scope *S = this; S; S = S->getParent()) {
432  if (S->getFlags() & Scope::SwitchScope)
433  return true;
434  else if (S->getFlags() & (Scope::FnScope | Scope::ClassScope |
438  return false;
439  }
440  return false;
441  }
442 
443  /// Determines whether this scope is the OpenMP directive scope
444  bool isOpenMPDirectiveScope() const {
446  }
447 
448  /// Determine whether this scope is some OpenMP loop directive scope
449  /// (for example, 'omp for', 'omp simd').
452  assert(isOpenMPDirectiveScope() &&
453  "OpenMP loop directive scope is not a directive scope");
454  return true;
455  }
456  return false;
457  }
458 
459  /// Determine whether this scope is (or is nested into) some OpenMP
460  /// loop simd directive scope (for example, 'omp simd', 'omp for simd').
463  }
464 
465  /// Determine whether this scope is a loop having OpenMP loop
466  /// directive attached.
467  bool isOpenMPLoopScope() const {
468  const Scope *P = getParent();
469  return P && P->isOpenMPLoopDirectiveScope();
470  }
471 
472  /// Determine whether this scope is a C++ 'try' block.
473  bool isTryScope() const { return getFlags() & Scope::TryScope; }
474 
475  /// Determine whether this scope is a SEH '__try' block.
476  bool isSEHTryScope() const { return getFlags() & Scope::SEHTryScope; }
477 
478  /// Determine whether this scope is a SEH '__except' block.
479  bool isSEHExceptScope() const { return getFlags() & Scope::SEHExceptScope; }
480 
481  /// Determine whether this scope is a compound statement scope.
482  bool isCompoundStmtScope() const {
484  }
485 
486  /// Returns if rhs has a higher scope depth than this.
487  ///
488  /// The caller is responsible for calling this only if one of the two scopes
489  /// is an ancestor of the other.
490  bool Contains(const Scope& rhs) const { return Depth < rhs.Depth; }
491 
492  /// containedInPrototypeScope - Return true if this or a parent scope
493  /// is a FunctionPrototypeScope.
494  bool containedInPrototypeScope() const;
495 
497  UsingDirectives.push_back(UDir);
498  }
499 
500  using using_directives_range =
501  llvm::iterator_range<UsingDirectivesTy::iterator>;
502 
504  return using_directives_range(UsingDirectives.begin(),
505  UsingDirectives.end());
506  }
507 
509  if (NRVO.getInt())
510  return;
511  if (NRVO.getPointer() == nullptr) {
512  NRVO.setPointer(VD);
513  return;
514  }
515  if (NRVO.getPointer() != VD)
516  setNoNRVO();
517  }
518 
519  void setNoNRVO() {
520  NRVO.setInt(true);
521  NRVO.setPointer(nullptr);
522  }
523 
524  void mergeNRVOIntoParent();
525 
526  /// Init - This is used by the parser to implement scope caching.
527  void Init(Scope *parent, unsigned flags);
528 
529  /// Sets up the specified scope flags and adjusts the scope state
530  /// variables accordingly.
531  void AddFlags(unsigned Flags);
532 
533  void dumpImpl(raw_ostream &OS) const;
534  void dump() const;
535 };
536 
537 } // namespace clang
538 
539 #endif // LLVM_CLANG_SEMA_SCOPE_H
clang::Scope::isFunctionScope
bool isFunctionScope() const
isFunctionScope() - Return true if this scope is a function scope.
Definition: Scope.h:367
clang::Scope::getFnParent
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:238
clang::Scope::setFlags
void setFlags(unsigned F)
Definition: Scope.h:228
llvm
Definition: Dominators.h:30
clang::Scope::isClassScope
bool isClassScope() const
isClassScope - Return true if this scope is a class/struct/union scope.
Definition: Scope.h:370
clang::Scope::FunctionPrototypeScope
@ FunctionPrototypeScope
This is a scope that corresponds to the parameters within a function prototype.
Definition: Scope.h:81
clang::Scope::isOpenMPLoopDirectiveScope
bool isOpenMPLoopDirectiveScope() const
Determine whether this scope is some OpenMP loop directive scope (for example, 'omp for',...
Definition: Scope.h:450
clang::Scope::FnScope
@ FnScope
This indicates that the scope corresponds to a function, which means that labels are set here.
Definition: Scope.h:47
clang::Scope::getBlockParent
Scope * getBlockParent()
Definition: Scope.h:276
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1347
Diag
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.
Definition: LiteralSupport.cpp:78
clang::Scope::OpenMPLoopDirectiveScope
@ OpenMPLoopDirectiveScope
This is the scope of some OpenMP loop directive.
Definition: Scope.h:110
clang::UsingDirectiveDecl
Represents C++ using-directive.
Definition: DeclCXX.h:2882
llvm::SmallVector< UsingDirectiveDecl *, 2 >
clang::Scope::BlockScope
@ BlockScope
This is a scope that corresponds to a block/closure object.
Definition: Scope.h:71
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:191
clang::Scope::isInObjcMethodOuterScope
bool isInObjcMethodOuterScope() const
isInObjcMethodOuterScope - Return true if this scope is an Objective-C method outer most body.
Definition: Scope.h:397
clang::Scope::getMSCurManglingNumber
unsigned getMSCurManglingNumber() const
Definition: Scope.h:334
clang::Scope::isCompoundStmtScope
bool isCompoundStmtScope() const
Determine whether this scope is a compound statement scope.
Definition: Scope.h:482
clang::Scope::setIsConditionVarScope
void setIsConditionVarScope(bool InConditionVarScope)
Definition: Scope.h:258
clang::Scope::isSwitchScope
bool isSwitchScope() const
isSwitchScope - Return true if this scope is a switch scope.
Definition: Scope.h:430
llvm::SmallPtrSet< Decl *, 32 >
clang::Scope::AddDecl
void AddDecl(Decl *D)
Definition: Scope.h:306
clang::DiagnosticErrorTrap::hasUnrecoverableErrorOccurred
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created.
Definition: Diagnostic.h:1087
clang::Scope::getDepth
unsigned getDepth() const
Returns the depth of this scope. The translation-unit has scope depth 0.
Definition: Scope.h:283
clang::Scope::ConditionVarScope
@ ConditionVarScope
This is a scope in which a condition variable is currently being parsed.
Definition: Scope.h:142
clang::Scope::SwitchScope
@ SwitchScope
This is a scope that corresponds to a switch statement.
Definition: Scope.h:98
clang::Scope::setLookupEntity
void setLookupEntity(DeclContext *E)
Definition: Scope.h:356
clang::DiagnosticErrorTrap
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:1070
clang::Scope::containedInPrototypeScope
bool containedInPrototypeScope() const
containedInPrototypeScope - Return true if this or a parent scope is a FunctionPrototypeScope.
Definition: Scope.cpp:97
clang::Scope::getParent
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:234
clang::Scope::isFunctionPrototypeScope
bool isFunctionPrototypeScope() const
isFunctionPrototypeScope - Return true if this scope is a function prototype scope.
Definition: Scope.h:414
Decl.h
clang::Scope::decls
decl_range decls() const
Definition: Scope.h:300
clang::CodeGen::AlignmentSource::Decl
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
clang::Scope::OpenMPDirectiveScope
@ OpenMPDirectiveScope
This is the scope of OpenMP executable directive.
Definition: Scope.h:107
clang::Scope::SEHTryScope
@ SEHTryScope
This scope corresponds to an SEH try.
Definition: Scope.h:121
clang::Scope::setNoNRVO
void setNoNRVO()
Definition: Scope.h:519
clang::Scope::decrementMSManglingNumber
void decrementMSManglingNumber()
Definition: Scope.h:321
clang::Scope::getMSLastManglingParent
const Scope * getMSLastManglingParent() const
Definition: Scope.h:241
clang::Scope::getTemplateParamParent
Scope * getTemplateParamParent()
Definition: Scope.h:279
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::Scope::isOpenMPDirectiveScope
bool isOpenMPDirectiveScope() const
Determines whether this scope is the OpenMP directive scope.
Definition: Scope.h:444
clang::Scope::isDeclScope
bool isDeclScope(const Decl *D) const
isDeclScope - Return true if this is the scope that the specified decl is declared in.
Definition: Scope.h:340
clang::Scope::dumpImpl
void dumpImpl(raw_ostream &OS) const
Definition: Scope.cpp:138
Diagnostic.h
clang::Scope::decl_empty
bool decl_empty() const
Definition: Scope.h:304
clang::Scope::getParent
Scope * getParent()
Definition: Scope.h:235
clang::Scope::Init
void Init(Scope *parent, unsigned flags)
Init - This is used by the parser to implement scope caching.
Definition: Scope.cpp:87
clang::Scope::CompoundStmtScope
@ CompoundStmtScope
This is a compound statement scope.
Definition: Scope.h:130
clang::Scope::FunctionDeclarationScope
@ FunctionDeclarationScope
This is a scope that corresponds to the parameters within a function prototype for a function declara...
Definition: Scope.h:87
clang::Scope::hasUnrecoverableErrorOccurred
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred within this scope.
Definition: Scope.h:362
clang::Scope::Scope
Scope(Scope *Parent, unsigned ScopeFlags, DiagnosticsEngine &Diag)
Definition: Scope.h:220
clang::Scope::isAtCatchScope
bool isAtCatchScope() const
isAtCatchScope - Return true if this scope is @catch.
Definition: Scope.h:425
clang::Scope::ContinueScope
@ ContinueScope
This is a while, do, for, which can have continue statements embedded into it.
Definition: Scope.h:55
clang::Scope::getMSLastManglingNumber
unsigned getMSLastManglingNumber() const
Definition: Scope.h:328
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:876
clang::Scope::isOpenMPLoopScope
bool isOpenMPLoopScope() const
Determine whether this scope is a loop having OpenMP loop directive attached.
Definition: Scope.h:467
clang::Scope::isSEHExceptScope
bool isSEHExceptScope() const
Determine whether this scope is a SEH '__except' block.
Definition: Scope.h:479
clang::Scope::getFunctionPrototypeDepth
unsigned getFunctionPrototypeDepth() const
Returns the number of function prototype scopes in this scope chain.
Definition: Scope.h:287
clang::Scope::getLookupEntity
DeclContext * getLookupEntity() const
Get the DeclContext in which to continue unqualified lookup after a lookup in this scope.
Definition: Scope.h:349
clang::Scope::isTemplateParamScope
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:408
clang::Scope::ControlScope
@ ControlScope
The controlling scope in a if/switch/while/for statement.
Definition: Scope.h:62
clang::Scope::EnumScope
@ EnumScope
This scope corresponds to an enum.
Definition: Scope.h:118
clang::Scope::using_directives
using_directives_range using_directives()
Definition: Scope.h:503
clang::Scope::getTemplateParamParent
const Scope * getTemplateParamParent() const
Definition: Scope.h:280
clang::Scope::AddFlags
void AddFlags(unsigned Flags)
Sets up the specified scope flags and adjusts the scope state variables accordingly.
Definition: Scope.cpp:107
clang::Scope::incrementMSManglingNumber
void incrementMSManglingNumber()
Definition: Scope.h:314
clang::Scope::getBreakParent
const Scope * getBreakParent() const
Definition: Scope.h:272
clang::Scope::isInCXXInlineMethodScope
bool isInCXXInlineMethodScope() const
isInCXXInlineMethodScope - Return true if this scope is a C++ inline method scope or is inside one.
Definition: Scope.h:376
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::Scope::dump
void dump() const
Definition: Scope.cpp:136
clang::Scope::getFnParent
Scope * getFnParent()
Definition: Scope.h:239
clang::Scope::TemplateParamScope
@ TemplateParamScope
This is a scope that corresponds to the template parameters of a C++ template.
Definition: Scope.h:77
clang::Scope::isInObjcMethodScope
bool isInObjcMethodScope() const
isInObjcMethodScope - Return true if this scope is, or is contained in, an Objective-C method body.
Definition: Scope.h:386
clang::Scope::getBreakParent
Scope * getBreakParent()
getBreakParent - Return the closest scope that a break statement would be affected by.
Definition: Scope.h:269
clang::Scope::AtCatchScope
@ AtCatchScope
This is a scope that corresponds to the Objective-C @catch statement.
Definition: Scope.h:91
clang::Scope::decl_range
llvm::iterator_range< DeclSetTy::iterator > decl_range
Definition: Scope.h:298
clang::Scope::ClassInheritanceScope
@ ClassInheritanceScope
We are between inheritance colon and the real class/struct definition scope.
Definition: Scope.h:134
clang::Scope::ClassScope
@ ClassScope
The scope of a struct/union/class definition.
Definition: Scope.h:65
clang::Scope::getFlags
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:226
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:89
clang::Scope::isSEHTryScope
bool isSEHTryScope() const
Determine whether this scope is a SEH '__try' block.
Definition: Scope.h:476
clang::Scope::SEHExceptScope
@ SEHExceptScope
This scope corresponds to an SEH except.
Definition: Scope.h:124
clang::Scope::isOpenMPSimdDirectiveScope
bool isOpenMPSimdDirectiveScope() const
Determine whether this scope is (or is nested into) some OpenMP loop simd directive scope (for exampl...
Definition: Scope.h:461
clang::Scope::addNRVOCandidate
void addNRVOCandidate(VarDecl *VD)
Definition: Scope.h:508
clang::Scope::mergeNRVOIntoParent
void mergeNRVOIntoParent()
Definition: Scope.cpp:121
clang::Scope::setEntity
void setEntity(DeclContext *E)
Definition: Scope.h:351
clang::Scope::getContinueParent
Scope * getContinueParent()
getContinueParent - Return the closest scope that a continue statement would be affected by.
Definition: Scope.h:248
clang::Scope::getNextFunctionPrototypeIndex
unsigned getNextFunctionPrototypeIndex()
Return the number of parameters declared in this function prototype, increasing it by one for the nex...
Definition: Scope.h:293
clang
Definition: CalledOnceCheck.h:17
clang::Scope::CatchScope
@ CatchScope
This is the scope of a C++ catch statement.
Definition: Scope.h:137
clang::Scope::ScopeFlags
ScopeFlags
ScopeFlags - These are bitfields that are or'd together when creating a scope, which defines the sort...
Definition: Scope.h:44
clang::Scope::getEntity
DeclContext * getEntity() const
Get the entity corresponding to this scope.
Definition: Scope.h:343
clang::Scope::getMSLastManglingParent
Scope * getMSLastManglingParent()
Definition: Scope.h:244
clang::Scope::SEHFilterScope
@ SEHFilterScope
We are currently in the filter expression of an SEH except block.
Definition: Scope.h:127
clang::Scope::getBlockParent
const Scope * getBlockParent() const
Definition: Scope.h:277
clang::Scope::RemoveDecl
void RemoveDecl(Decl *D)
Definition: Scope.h:310
clang::Scope::ObjCMethodScope
@ ObjCMethodScope
This scope corresponds to an Objective-C method body.
Definition: Scope.h:95
clang::Scope::Contains
bool Contains(const Scope &rhs) const
Returns if rhs has a higher scope depth than this.
Definition: Scope.h:490
Parent
NodeId Parent
Definition: ASTDiff.cpp:192
clang::Scope::isBlockScope
bool isBlockScope() const
isBlockScope - Return true if this scope correspond to a closure.
Definition: Scope.h:231
clang::Scope::isFunctionDeclarationScope
bool isFunctionDeclarationScope() const
isFunctionDeclarationScope - Return true if this scope is a function prototype scope.
Definition: Scope.h:420
clang::Scope::TryScope
@ TryScope
This is the scope of a C++ try statement.
Definition: Scope.h:101
clang::Scope::DeclScope
@ DeclScope
This is a scope that can contain a declaration.
Definition: Scope.h:59
clang::Scope::FnTryCatchScope
@ FnTryCatchScope
This is the scope for a function-level C++ try or catch scope.
Definition: Scope.h:104
clang::Scope::BreakScope
@ BreakScope
This is a while, do, switch, for, etc that can have break statements embedded into it.
Definition: Scope.h:51
clang::Scope::getContinueParent
const Scope * getContinueParent() const
Definition: Scope.h:252
clang::Scope::OpenMPSimdDirectiveScope
@ OpenMPSimdDirectiveScope
This is the scope of some OpenMP simd directive.
Definition: Scope.h:115
clang::Scope::isConditionVarScope
bool isConditionVarScope() const
Definition: Scope.h:263
clang::Scope::isTryScope
bool isTryScope() const
Determine whether this scope is a C++ 'try' block.
Definition: Scope.h:473
clang::Scope::PushUsingDirective
void PushUsingDirective(UsingDirectiveDecl *UDir)
Definition: Scope.h:496
clang::Scope::using_directives_range
llvm::iterator_range< UsingDirectivesTy::iterator > using_directives_range
Definition: Scope.h:501