clang  10.0.0svn
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.
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 
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:
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 
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.
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.
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.
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 
298  if (Scope *MSLMP = getMSLastManglingParent()) {
299  MSLMP->MSLastManglingNumber += 1;
300  MSCurManglingNumber += 1;
301  }
302  }
303 
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 
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.
347  if (const Scope *FnS = getFnParent()) {
348  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.
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.
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').
415  if (getFlags() & Scope::OpenMPLoopDirectiveScope) {
416  assert(isOpenMPDirectiveScope() &&
417  "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').
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 
461  UsingDirectives.push_back(UDir);
462  }
463 
464  using using_directives_range =
465  llvm::iterator_range<UsingDirectivesTy::iterator>;
466 
468  return using_directives_range(UsingDirectives.begin(),
469  UsingDirectives.end());
470  }
471 
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
Scope * getFnParent()
Definition: Scope.h:233
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.
Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be placed into a PointerUnion...
Definition: Dominators.h:30
const Scope * getTemplateParamParent() const
Definition: Scope.h:263
bool isBlockScope() const
isBlockScope - Return true if this scope correspond to a closure.
Definition: Scope.h:225
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
llvm::iterator_range< DeclSetTy::iterator > decl_range
Definition: Scope.h:281
Scope * getBlockParent()
Definition: Scope.h:259
void setFlags(unsigned F)
Definition: Scope.h:222
StringRef P
bool isTemplateParamScope() const
isTemplateParamScope - Return true if this scope is a C++ template parameter scope.
Definition: Scope.h:378
void AddDecl(Decl *D)
Definition: Scope.h:289
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
Scope * getContinueParent()
getContinueParent - Return the closest scope that a continue statement would be affected by...
Definition: Scope.h:242
unsigned getDepth() const
Returns the depth of this scope. The translation-unit has scope depth 0.
Definition: Scope.h:266
Represents a variable declaration or definition.
Definition: Decl.h:812
ScopeFlags
ScopeFlags - These are bitfields that are or&#39;d together when creating a scope, which defines the sort...
Definition: Scope.h:44
bool isInObjcMethodScope() const
isInObjcMethodScope - Return true if this scope is, or is contained in, an Objective-C method body...
Definition: Scope.h:356
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:1001
Scope(Scope *Parent, unsigned ScopeFlags, DiagnosticsEngine &Diag)
Definition: Scope.h:214
Scope * getTemplateParamParent()
Definition: Scope.h:262
bool isAtCatchScope() const
isAtCatchScope - Return true if this scope is @catch.
Definition: Scope.h:389
unsigned getFunctionPrototypeDepth() const
Returns the number of function prototype scopes in this scope chain.
Definition: Scope.h:270
void decrementMSManglingNumber()
Definition: Scope.h:304
void setNoNRVO()
Definition: Scope.h:483
Scope * getBreakParent()
getBreakParent - Return the closest scope that a break statement would be affected by...
Definition: Scope.h:252
bool isFunctionPrototypeScope() const
isFunctionPrototypeScope - Return true if this scope is a function prototype scope.
Definition: Scope.h:384
static void dump(llvm::raw_ostream &OS, StringRef FunctionName, ArrayRef< CounterExpression > Expressions, ArrayRef< CounterMappingRegion > Regions)
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
bool isFunctionScope() const
isFunctionScope() - Return true if this scope is a function scope.
Definition: Scope.h:337
unsigned getMSLastManglingNumber() const
Definition: Scope.h:311
Defines the Diagnostic-related interfaces.
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
using_directives_range using_directives()
Definition: Scope.h:467
void incrementMSManglingNumber()
Definition: Scope.h:297
NodeId Parent
Definition: ASTDiff.cpp:191
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:220
bool decl_empty() const
Definition: Scope.h:287
bool isInCXXInlineMethodScope() const
isInCXXInlineMethodScope - Return true if this scope is a C++ inline method scope or is inside one...
Definition: Scope.h:346
bool isInObjcMethodOuterScope() const
isInObjcMethodOuterScope - Return true if this scope is an Objective-C method outer most body...
Definition: Scope.h:367
bool isDeclScope(Decl *D)
isDeclScope - Return true if this is the scope that the specified decl is declared in...
Definition: Scope.h:323
DeclContext * getEntity() const
Definition: Scope.h:327
Scope * getMSLastManglingParent()
Definition: Scope.h:238
bool isSEHTryScope() const
Determine whether this scope is a SEH &#39;__try&#39; block.
Definition: Scope.h:440
int Depth
Definition: ASTDiff.cpp:190
bool isClassScope() const
isClassScope - Return true if this scope is a class/struct/union scope.
Definition: Scope.h:340
decl_range decls() const
Definition: Scope.h:283
bool hasErrorOccurred() const
Definition: Scope.h:330
bool isCompoundStmtScope() const
Determine whether this scope is a compound statement scope.
Definition: Scope.h:446
bool Contains(const Scope &rhs) const
Returns if rhs has a higher scope depth than this.
Definition: Scope.h:454
unsigned getMSCurManglingNumber() const
Definition: Scope.h:317
bool isOpenMPLoopScope() const
Determine whether this scope is a loop having OpenMP loop directive attached.
Definition: Scope.h:431
const Scope * getBreakParent() const
Definition: Scope.h:255
bool hasErrorOccurred() const
Determine whether any errors have occurred since this object instance was created.
Definition: Diagnostic.h:1012
Scope * getParent()
Definition: Scope.h:229
void setEntity(DeclContext *E)
Definition: Scope.h:328
const Scope * getContinueParent() const
Definition: Scope.h:246
bool isOpenMPDirectiveScope() const
Determines whether this scope is the OpenMP directive scope.
Definition: Scope.h:408
Dataflow Directional Tag Classes.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:228
bool isSEHExceptScope() const
Determine whether this scope is a SEH &#39;__except&#39; block.
Definition: Scope.h:443
void addNRVOCandidate(VarDecl *VD)
Definition: Scope.h:472
unsigned getNextFunctionPrototypeIndex()
Return the number of parameters declared in this function prototype, increasing it by one for the nex...
Definition: Scope.h:276
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created...
Definition: Diagnostic.h:1018
void PushUsingDirective(UsingDirectiveDecl *UDir)
Definition: Scope.h:460
void RemoveDecl(Decl *D)
Definition: Scope.h:293
bool isOpenMPLoopDirectiveScope() const
Determine whether this scope is some OpenMP loop directive scope (for example, &#39;omp for&#39;...
Definition: Scope.h:414
const Scope * getMSLastManglingParent() const
Definition: Scope.h:235
bool isOpenMPSimdDirectiveScope() const
Determine whether this scope is (or is nested into) some OpenMP loop simd directive scope (for exampl...
Definition: Scope.h:425
bool isSwitchScope() const
isSwitchScope - Return true if this scope is a switch scope.
Definition: Scope.h:394
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:232
bool isTryScope() const
Determine whether this scope is a C++ &#39;try&#39; block.
Definition: Scope.h:437
bool hasUnrecoverableErrorOccurred() const
Definition: Scope.h:332
Represents C++ using-directive.
Definition: DeclCXX.h:3052
const Scope * getBlockParent() const
Definition: Scope.h:260
llvm::iterator_range< UsingDirectivesTy::iterator > using_directives_range
Definition: Scope.h:465