clang  14.0.0git
ScopeInfo.h
Go to the documentation of this file.
1 //===- ScopeInfo.h - Information about a semantic context -------*- 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 FunctionScopeInfo and its subclasses, which contain
10 // information about a single function, block, lambda, or method body.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_SEMA_SCOPEINFO_H
15 #define LLVM_CLANG_SEMA_SCOPEINFO_H
16 
17 #include "clang/AST/Expr.h"
18 #include "clang/AST/ExprCXX.h"
19 #include "clang/AST/Type.h"
21 #include "clang/Basic/LLVM.h"
24 #include "clang/Sema/CleanupInfo.h"
25 #include "clang/Sema/DeclSpec.h"
26 #include "llvm/ADT/DenseMap.h"
27 #include "llvm/ADT/DenseMapInfo.h"
28 #include "llvm/ADT/MapVector.h"
29 #include "llvm/ADT/PointerIntPair.h"
30 #include "llvm/ADT/SmallPtrSet.h"
31 #include "llvm/ADT/SmallSet.h"
32 #include "llvm/ADT/SmallVector.h"
33 #include "llvm/ADT/StringRef.h"
34 #include "llvm/ADT/StringSwitch.h"
35 #include "llvm/ADT/TinyPtrVector.h"
36 #include "llvm/Support/Casting.h"
37 #include "llvm/Support/ErrorHandling.h"
38 #include <algorithm>
39 #include <cassert>
40 #include <utility>
41 
42 namespace clang {
43 
44 class BlockDecl;
45 class CapturedDecl;
46 class CXXMethodDecl;
47 class CXXRecordDecl;
48 class ImplicitParamDecl;
49 class NamedDecl;
50 class ObjCIvarRefExpr;
51 class ObjCMessageExpr;
52 class ObjCPropertyDecl;
53 class ObjCPropertyRefExpr;
54 class ParmVarDecl;
55 class RecordDecl;
56 class ReturnStmt;
57 class Scope;
58 class Stmt;
59 class SwitchStmt;
60 class TemplateParameterList;
61 class TemplateTypeParmDecl;
62 class VarDecl;
63 
64 namespace sema {
65 
66 /// Contains information about the compound statement currently being
67 /// parsed.
69 public:
70  /// Whether this compound stamement contains `for' or `while' loops
71  /// with empty bodies.
72  bool HasEmptyLoopBodies = false;
73 
74  /// Whether this compound statement corresponds to a GNU statement
75  /// expression.
76  bool IsStmtExpr;
77 
79 
81  HasEmptyLoopBodies = true;
82  }
83 };
84 
86 public:
89  llvm::TinyPtrVector<const Stmt*> Stmts;
90 
93  : PD(PD), Loc(Loc), Stmts(Stmts) {}
94 };
95 
96 /// Retains information about a function, method, or block that is
97 /// currently being parsed.
99 protected:
100  enum ScopeKind {
105  };
106 
107 public:
108  /// What kind of scope we are describing.
110 
111  /// Whether this function contains a VLA, \@try, try, C++
112  /// initializer, or anything else that can't be jumped past.
114 
115  /// Whether this function contains any switches or direct gotos.
117 
118  /// Whether this function contains any indirect gotos.
119  bool HasIndirectGoto : 1;
120 
121  /// Whether this function contains any statement marked with
122  /// \c [[clang::musttail]].
123  bool HasMustTail : 1;
124 
125  /// Whether a statement was dropped because it was invalid.
126  bool HasDroppedStmt : 1;
127 
128  /// True if current scope is for OpenMP declare reduction combiner.
130 
131  /// Whether there is a fallthrough statement in this function.
133 
134  /// Whether this function uses constrained floating point intrinsics
135  bool UsesFPIntrin : 1;
136 
137  /// Whether we make reference to a declaration that could be
138  /// unavailable.
140 
141  /// A flag that is set when parsing a method that must call super's
142  /// implementation, such as \c -dealloc, \c -finalize, or any method marked
143  /// with \c __attribute__((objc_requires_super)).
145 
146  /// True when this is a method marked as a designated initializer.
148 
149  /// This starts true for a method marked as designated initializer and will
150  /// be set to false if there is an invocation to a designated initializer of
151  /// the super class.
153 
154  /// True when this is an initializer method not marked as a designated
155  /// initializer within a class that has at least one initializer marked as a
156  /// designated initializer.
158 
159  /// This starts true for a secondary initializer method and will be set to
160  /// false if there is an invocation of an initializer on 'self'.
162 
163  /// True only when this function has not already built, or attempted
164  /// to build, the initial and final coroutine suspend points
166 
167  /// An enumeration represeting the kind of the first coroutine statement
168  /// in the function. One of co_return, co_await, or co_yield.
169  unsigned char FirstCoroutineStmtKind : 2;
170 
171  /// First coroutine statement in the current function.
172  /// (ex co_return, co_await, co_yield)
174 
175  /// First 'return' statement in the current function.
177 
178  /// First C++ 'try' statement in the current function.
180 
181  /// First SEH '__try' statement in the current function.
183 
184 private:
185  /// Used to determine if errors occurred in this function or block.
186  DiagnosticErrorTrap ErrorTrap;
187 
188 public:
189  /// A SwitchStmt, along with a flag indicating if its list of case statements
190  /// is incomplete (because we dropped an invalid one while parsing).
191  using SwitchInfo = llvm::PointerIntPair<SwitchStmt*, 1, bool>;
192 
193  /// SwitchStack - This is the current set of active switch statements in the
194  /// block.
196 
197  /// The list of return statements that occur within the function or
198  /// block, if there is any chance of applying the named return value
199  /// optimization, or if we need to infer a return type.
201 
202  /// The promise object for this coroutine, if any.
204 
205  /// A mapping between the coroutine function parameters that were moved
206  /// to the coroutine frame, and their move statements.
207  llvm::SmallMapVector<ParmVarDecl *, Stmt *, 4> CoroutineParameterMoves;
208 
209  /// The initial and final coroutine suspend points.
210  std::pair<Stmt *, Stmt *> CoroutineSuspends;
211 
212  /// The stack of currently active compound stamement scopes in the
213  /// function.
215 
216  /// The set of blocks that are introduced in this function.
218 
219  /// The set of __block variables that are introduced in this function.
220  llvm::TinyPtrVector<VarDecl *> ByrefBlockVars;
221 
222  /// A list of PartialDiagnostics created but delayed within the
223  /// current function scope. These diagnostics are vetted for reachability
224  /// prior to being emitted.
226 
227  /// A list of parameters which have the nonnull attribute and are
228  /// modified in the function.
230 
231 public:
232  /// Represents a simple identification of a weak object.
233  ///
234  /// Part of the implementation of -Wrepeated-use-of-weak.
235  ///
236  /// This is used to determine if two weak accesses refer to the same object.
237  /// Here are some examples of how various accesses are "profiled":
238  ///
239  /// Access Expression | "Base" Decl | "Property" Decl
240  /// :---------------: | :-----------------: | :------------------------------:
241  /// self.property | self (VarDecl) | property (ObjCPropertyDecl)
242  /// self.implicitProp | self (VarDecl) | -implicitProp (ObjCMethodDecl)
243  /// self->ivar.prop | ivar (ObjCIvarDecl) | prop (ObjCPropertyDecl)
244  /// cxxObj.obj.prop | obj (FieldDecl) | prop (ObjCPropertyDecl)
245  /// [self foo].prop | 0 (unknown) | prop (ObjCPropertyDecl)
246  /// self.prop1.prop2 | prop1 (ObjCPropertyDecl) | prop2 (ObjCPropertyDecl)
247  /// MyClass.prop | MyClass (ObjCInterfaceDecl) | -prop (ObjCMethodDecl)
248  /// MyClass.foo.prop | +foo (ObjCMethodDecl) | -prop (ObjCPropertyDecl)
249  /// weakVar | 0 (known) | weakVar (VarDecl)
250  /// self->weakIvar | self (VarDecl) | weakIvar (ObjCIvarDecl)
251  ///
252  /// Objects are identified with only two Decls to make it reasonably fast to
253  /// compare them.
255  /// The base object decl, as described in the class documentation.
256  ///
257  /// The extra flag is "true" if the Base and Property are enough to uniquely
258  /// identify the object in memory.
259  ///
260  /// \sa isExactProfile()
261  using BaseInfoTy = llvm::PointerIntPair<const NamedDecl *, 1, bool>;
262  BaseInfoTy Base;
263 
264  /// The "property" decl, as described in the class documentation.
265  ///
266  /// Note that this may not actually be an ObjCPropertyDecl, e.g. in the
267  /// case of "implicit" properties (regular methods accessed via dot syntax).
268  const NamedDecl *Property = nullptr;
269 
270  /// Used to find the proper base profile for a given base expression.
271  static BaseInfoTy getBaseInfo(const Expr *BaseE);
272 
273  inline WeakObjectProfileTy();
274  static inline WeakObjectProfileTy getSentinel();
275 
276  public:
279  WeakObjectProfileTy(const DeclRefExpr *RE);
281 
282  const NamedDecl *getBase() const { return Base.getPointer(); }
283  const NamedDecl *getProperty() const { return Property; }
284 
285  /// Returns true if the object base specifies a known object in memory,
286  /// rather than, say, an instance variable or property of another object.
287  ///
288  /// Note that this ignores the effects of aliasing; that is, \c foo.bar is
289  /// considered an exact profile if \c foo is a local variable, even if
290  /// another variable \c foo2 refers to the same object as \c foo.
291  ///
292  /// For increased precision, accesses with base variables that are
293  /// properties or ivars of 'self' (e.g. self.prop1.prop2) are considered to
294  /// be exact, though this is not true for arbitrary variables
295  /// (foo.prop1.prop2).
296  bool isExactProfile() const {
297  return Base.getInt();
298  }
299 
300  bool operator==(const WeakObjectProfileTy &Other) const {
301  return Base == Other.Base && Property == Other.Property;
302  }
303 
304  // For use in DenseMap.
305  // We can't specialize the usual llvm::DenseMapInfo at the end of the file
306  // because by that point the DenseMap in FunctionScopeInfo has already been
307  // instantiated.
308  class DenseMapInfo {
309  public:
311  return WeakObjectProfileTy();
312  }
313 
315  return WeakObjectProfileTy::getSentinel();
316  }
317 
318  static unsigned getHashValue(const WeakObjectProfileTy &Val) {
319  using Pair = std::pair<BaseInfoTy, const NamedDecl *>;
320 
321  return llvm::DenseMapInfo<Pair>::getHashValue(Pair(Val.Base,
322  Val.Property));
323  }
324 
325  static bool isEqual(const WeakObjectProfileTy &LHS,
326  const WeakObjectProfileTy &RHS) {
327  return LHS == RHS;
328  }
329  };
330  };
331 
332  /// Represents a single use of a weak object.
333  ///
334  /// Stores both the expression and whether the access is potentially unsafe
335  /// (i.e. it could potentially be warned about).
336  ///
337  /// Part of the implementation of -Wrepeated-use-of-weak.
338  class WeakUseTy {
339  llvm::PointerIntPair<const Expr *, 1, bool> Rep;
340 
341  public:
342  WeakUseTy(const Expr *Use, bool IsRead) : Rep(Use, IsRead) {}
343 
344  const Expr *getUseExpr() const { return Rep.getPointer(); }
345  bool isUnsafe() const { return Rep.getInt(); }
346  void markSafe() { Rep.setInt(false); }
347 
348  bool operator==(const WeakUseTy &Other) const {
349  return Rep == Other.Rep;
350  }
351  };
352 
353  /// Used to collect uses of a particular weak object in a function body.
354  ///
355  /// Part of the implementation of -Wrepeated-use-of-weak.
357 
358  /// Used to collect all uses of weak objects in a function body.
359  ///
360  /// Part of the implementation of -Wrepeated-use-of-weak.
361  using WeakObjectUseMap =
362  llvm::SmallDenseMap<WeakObjectProfileTy, WeakUseVector, 8,
364 
365 private:
366  /// Used to collect all uses of weak objects in this function body.
367  ///
368  /// Part of the implementation of -Wrepeated-use-of-weak.
369  WeakObjectUseMap WeakObjectUses;
370 
371 protected:
372  FunctionScopeInfo(const FunctionScopeInfo&) = default;
373 
374 public:
383  NeedsCoroutineSuspends(true), ErrorTrap(Diag) {}
384 
385  virtual ~FunctionScopeInfo();
386 
387  /// Determine whether an unrecoverable error has occurred within this
388  /// function. Note that this may return false even if the function body is
389  /// invalid, because the errors may be suppressed if they're caused by prior
390  /// invalid declarations.
391  ///
392  /// FIXME: Migrate the caller of this to use containsErrors() instead once
393  /// it's ready.
395  return ErrorTrap.hasUnrecoverableErrorOccurred();
396  }
397 
398  /// Record that a weak object was accessed.
399  ///
400  /// Part of the implementation of -Wrepeated-use-of-weak.
401  template <typename ExprT>
402  inline void recordUseOfWeak(const ExprT *E, bool IsRead = true);
403 
404  void recordUseOfWeak(const ObjCMessageExpr *Msg,
405  const ObjCPropertyDecl *Prop);
406 
407  /// Record that a given expression is a "safe" access of a weak object (e.g.
408  /// assigning it to a strong variable.)
409  ///
410  /// Part of the implementation of -Wrepeated-use-of-weak.
411  void markSafeWeakUse(const Expr *E);
412 
414  return WeakObjectUses;
415  }
416 
418  HasBranchIntoScope = true;
419  }
420 
423  }
424 
426  HasIndirectGoto = true;
427  }
428 
429  void setHasMustTail() { HasMustTail = true; }
430 
432  HasDroppedStmt = true;
433  }
434 
437  }
438 
440  HasFallthroughStmt = true;
441  }
442 
444  UsesFPIntrin = true;
445  }
446 
449  FirstCXXTryLoc = TryLoc;
450  }
451 
454  FirstSEHTryLoc = TryLoc;
455  }
456 
457  bool NeedsScopeChecking() const {
458  return !HasDroppedStmt && (HasIndirectGoto || HasMustTail ||
460  }
461 
462  // Add a block introduced in this function.
463  void addBlock(const BlockDecl *BD) {
464  Blocks.insert(BD);
465  }
466 
467  // Add a __block variable introduced in this function.
469  ByrefBlockVars.push_back(VD);
470  }
471 
472  bool isCoroutine() const { return !FirstCoroutineStmtLoc.isInvalid(); }
473 
474  void setFirstCoroutineStmt(SourceLocation Loc, StringRef Keyword) {
475  assert(FirstCoroutineStmtLoc.isInvalid() &&
476  "first coroutine statement location already set");
477  FirstCoroutineStmtLoc = Loc;
478  FirstCoroutineStmtKind = llvm::StringSwitch<unsigned char>(Keyword)
479  .Case("co_return", 0)
480  .Case("co_await", 1)
481  .Case("co_yield", 2);
482  }
483 
484  StringRef getFirstCoroutineStmtKeyword() const {
486  && "no coroutine statement available");
487  switch (FirstCoroutineStmtKind) {
488  case 0: return "co_return";
489  case 1: return "co_await";
490  case 2: return "co_yield";
491  default:
492  llvm_unreachable("FirstCoroutineStmtKind has an invalid value");
493  };
494  }
495 
496  void setNeedsCoroutineSuspends(bool value = true) {
497  assert((!value || CoroutineSuspends.first == nullptr) &&
498  "we already have valid suspend points");
499  NeedsCoroutineSuspends = value;
500  }
501 
503  return !NeedsCoroutineSuspends && CoroutineSuspends.first == nullptr;
504  }
505 
506  void setCoroutineSuspends(Stmt *Initial, Stmt *Final) {
507  assert(Initial && Final && "suspend points cannot be null");
508  assert(CoroutineSuspends.first == nullptr && "suspend points already set");
509  NeedsCoroutineSuspends = false;
510  CoroutineSuspends.first = Initial;
511  CoroutineSuspends.second = Final;
512  }
513 
514  /// Clear out the information in this function scope, making it
515  /// suitable for reuse.
516  void Clear();
517 
518  bool isPlainFunction() const { return Kind == SK_Function; }
519 };
520 
521 class Capture {
522  // There are three categories of capture: capturing 'this', capturing
523  // local variables, and C++1y initialized captures (which can have an
524  // arbitrary initializer, and don't really capture in the traditional
525  // sense at all).
526  //
527  // There are three ways to capture a local variable:
528  // - capture by copy in the C++11 sense,
529  // - capture by reference in the C++11 sense, and
530  // - __block capture.
531  // Lambdas explicitly specify capture by copy or capture by reference.
532  // For blocks, __block capture applies to variables with that annotation,
533  // variables of reference type are captured by reference, and other
534  // variables are captured by copy.
535  enum CaptureKind {
536  Cap_ByCopy, Cap_ByRef, Cap_Block, Cap_VLA
537  };
538 
539  union {
540  /// If Kind == Cap_VLA, the captured type.
542 
543  /// Otherwise, the captured variable (if any).
545  };
546 
547  /// The source location at which the first capture occurred.
548  SourceLocation Loc;
549 
550  /// The location of the ellipsis that expands a parameter pack.
551  SourceLocation EllipsisLoc;
552 
553  /// The type as it was captured, which is the type of the non-static data
554  /// member that would hold the capture.
555  QualType CaptureType;
556 
557  /// The CaptureKind of this capture.
558  unsigned Kind : 2;
559 
560  /// Whether this is a nested capture (a capture of an enclosing capturing
561  /// scope's capture).
562  unsigned Nested : 1;
563 
564  /// Whether this is a capture of '*this'.
565  unsigned CapturesThis : 1;
566 
567  /// Whether an explicit capture has been odr-used in the body of the
568  /// lambda.
569  unsigned ODRUsed : 1;
570 
571  /// Whether an explicit capture has been non-odr-used in the body of
572  /// the lambda.
573  unsigned NonODRUsed : 1;
574 
575  /// Whether the capture is invalid (a capture was required but the entity is
576  /// non-capturable).
577  unsigned Invalid : 1;
578 
579 public:
580  Capture(VarDecl *Var, bool Block, bool ByRef, bool IsNested,
581  SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType,
582  bool Invalid)
583  : CapturedVar(Var), Loc(Loc), EllipsisLoc(EllipsisLoc),
584  CaptureType(CaptureType),
585  Kind(Block ? Cap_Block : ByRef ? Cap_ByRef : Cap_ByCopy),
586  Nested(IsNested), CapturesThis(false), ODRUsed(false),
587  NonODRUsed(false), Invalid(Invalid) {}
588 
590  Capture(IsThisCapture, bool IsNested, SourceLocation Loc,
591  QualType CaptureType, const bool ByCopy, bool Invalid)
592  : Loc(Loc), CaptureType(CaptureType),
593  Kind(ByCopy ? Cap_ByCopy : Cap_ByRef), Nested(IsNested),
594  CapturesThis(true), ODRUsed(false), NonODRUsed(false),
595  Invalid(Invalid) {}
596 
598  Capture(IsVLACapture, const VariableArrayType *VLA, bool IsNested,
599  SourceLocation Loc, QualType CaptureType)
600  : CapturedVLA(VLA), Loc(Loc), CaptureType(CaptureType), Kind(Cap_VLA),
601  Nested(IsNested), CapturesThis(false), ODRUsed(false),
602  NonODRUsed(false), Invalid(false) {}
603 
604  bool isThisCapture() const { return CapturesThis; }
605  bool isVariableCapture() const {
606  return !isThisCapture() && !isVLATypeCapture();
607  }
608 
609  bool isCopyCapture() const { return Kind == Cap_ByCopy; }
610  bool isReferenceCapture() const { return Kind == Cap_ByRef; }
611  bool isBlockCapture() const { return Kind == Cap_Block; }
612  bool isVLATypeCapture() const { return Kind == Cap_VLA; }
613 
614  bool isNested() const { return Nested; }
615 
616  bool isInvalid() const { return Invalid; }
617 
618  /// Determine whether this capture is an init-capture.
619  bool isInitCapture() const;
620 
621  bool isODRUsed() const { return ODRUsed; }
622  bool isNonODRUsed() const { return NonODRUsed; }
623  void markUsed(bool IsODRUse) {
624  if (IsODRUse)
625  ODRUsed = true;
626  else
627  NonODRUsed = true;
628  }
629 
630  VarDecl *getVariable() const {
631  assert(isVariableCapture());
632  return CapturedVar;
633  }
634 
636  assert(isVLATypeCapture());
637  return CapturedVLA;
638  }
639 
640  /// Retrieve the location at which this variable was captured.
641  SourceLocation getLocation() const { return Loc; }
642 
643  /// Retrieve the source location of the ellipsis, whose presence
644  /// indicates that the capture is a pack expansion.
645  SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
646 
647  /// Retrieve the capture type for this capture, which is effectively
648  /// the type of the non-static data member in the lambda/block structure
649  /// that would store this capture.
650  QualType getCaptureType() const { return CaptureType; }
651 };
652 
654 protected:
655  CapturingScopeInfo(const CapturingScopeInfo&) = default;
656 
657 public:
661  };
662 
664 
667 
668  /// CaptureMap - A map of captured variables to (index+1) into Captures.
669  llvm::DenseMap<VarDecl*, unsigned> CaptureMap;
670 
671  /// CXXThisCaptureIndex - The (index+1) of the capture of 'this';
672  /// zero if 'this' is not captured.
673  unsigned CXXThisCaptureIndex = 0;
674 
675  /// Captures - The captures.
677 
678  /// - Whether the target type of return statements in this context
679  /// is deduced (e.g. a lambda or block with omitted return type).
680  bool HasImplicitReturnType = false;
681 
682  /// ReturnType - The target type of return statements in this context,
683  /// or null if unknown.
685 
686  void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested,
687  SourceLocation Loc, SourceLocation EllipsisLoc,
688  QualType CaptureType, bool Invalid) {
689  Captures.push_back(Capture(Var, isBlock, isByref, isNested, Loc,
690  EllipsisLoc, CaptureType, Invalid));
691  CaptureMap[Var] = Captures.size();
692  }
693 
695  QualType CaptureType) {
696  Captures.push_back(Capture(Capture::VLACapture, VLAType,
697  /*FIXME: IsNested*/ false, Loc, CaptureType));
698  }
699 
700  void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType,
701  bool ByCopy);
702 
703  /// Determine whether the C++ 'this' is captured.
704  bool isCXXThisCaptured() const { return CXXThisCaptureIndex != 0; }
705 
706  /// Retrieve the capture of C++ 'this', if it has been captured.
708  assert(isCXXThisCaptured() && "this has not been captured");
709  return Captures[CXXThisCaptureIndex - 1];
710  }
711 
712  /// Determine whether the given variable has been captured.
713  bool isCaptured(VarDecl *Var) const {
714  return CaptureMap.count(Var);
715  }
716 
717  /// Determine whether the given variable-array type has been captured.
718  bool isVLATypeCaptured(const VariableArrayType *VAT) const;
719 
720  /// Retrieve the capture of the given variable, if it has been
721  /// captured already.
723  assert(isCaptured(Var) && "Variable has not been captured");
724  return Captures[CaptureMap[Var] - 1];
725  }
726 
727  const Capture &getCapture(VarDecl *Var) const {
728  llvm::DenseMap<VarDecl*, unsigned>::const_iterator Known
729  = CaptureMap.find(Var);
730  assert(Known != CaptureMap.end() && "Variable has not been captured");
731  return Captures[Known->second - 1];
732  }
733 
734  static bool classof(const FunctionScopeInfo *FSI) {
735  return FSI->Kind == SK_Block || FSI->Kind == SK_Lambda
736  || FSI->Kind == SK_CapturedRegion;
737  }
738 };
739 
740 /// Retains information about a block that is currently being parsed.
741 class BlockScopeInfo final : public CapturingScopeInfo {
742 public:
744 
745  /// TheScope - This is the scope for the block itself, which contains
746  /// arguments etc.
748 
749  /// BlockType - The function type of the block, if one was given.
750  /// Its return type may be BuiltinType::Dependent.
752 
755  TheScope(BlockScope) {
756  Kind = SK_Block;
757  }
758 
759  ~BlockScopeInfo() override;
760 
761  static bool classof(const FunctionScopeInfo *FSI) {
762  return FSI->Kind == SK_Block;
763  }
764 };
765 
766 /// Retains information about a captured region.
768 public:
769  /// The CapturedDecl for this statement.
771 
772  /// The captured record type.
774 
775  /// This is the enclosing scope of the captured region.
777 
778  /// The implicit parameter for the captured variables.
780 
781  /// The kind of captured region.
782  unsigned short CapRegionKind;
783 
784  unsigned short OpenMPLevel;
785  unsigned short OpenMPCaptureLevel;
786 
788  RecordDecl *RD, ImplicitParamDecl *Context,
789  CapturedRegionKind K, unsigned OpenMPLevel,
790  unsigned OpenMPCaptureLevel)
796  }
797 
798  ~CapturedRegionScopeInfo() override;
799 
800  /// A descriptive name for the kind of captured region this is.
801  StringRef getRegionName() const {
802  switch (CapRegionKind) {
803  case CR_Default:
804  return "default captured statement";
805  case CR_ObjCAtFinally:
806  return "Objective-C @finally statement";
807  case CR_OpenMP:
808  return "OpenMP region";
809  }
810  llvm_unreachable("Invalid captured region kind!");
811  }
812 
813  static bool classof(const FunctionScopeInfo *FSI) {
814  return FSI->Kind == SK_CapturedRegion;
815  }
816 };
817 
818 class LambdaScopeInfo final :
820 public:
821  /// The class that describes the lambda.
822  CXXRecordDecl *Lambda = nullptr;
823 
824  /// The lambda's compiler-generated \c operator().
826 
827  /// Source range covering the lambda introducer [...].
829 
830  /// Source location of the '&' or '=' specifying the default capture
831  /// type, if any.
833 
834  /// The number of captures in the \c Captures list that are
835  /// explicit captures.
836  unsigned NumExplicitCaptures = 0;
837 
838  /// Whether this is a mutable lambda.
839  bool Mutable = false;
840 
841  /// Whether the (empty) parameter list is explicit.
842  bool ExplicitParams = false;
843 
844  /// Whether any of the capture expressions requires cleanups.
846 
847  /// Whether the lambda contains an unexpanded parameter pack.
849 
850  /// Packs introduced by this lambda, if any.
852 
853  /// Source range covering the explicit template parameter list (if it exists).
855 
856  /// The requires-clause immediately following the explicit template parameter
857  /// list, if any. (Note that there may be another requires-clause included as
858  /// part of the lambda-declarator.)
860 
861  /// If this is a generic lambda, and the template parameter
862  /// list has been created (from the TemplateParams) then store
863  /// a reference to it (cache it to avoid reconstructing it).
865 
866  /// Contains all variable-referring-expressions (i.e. DeclRefExprs
867  /// or MemberExprs) that refer to local variables in a generic lambda
868  /// or a lambda in a potentially-evaluated-if-used context.
869  ///
870  /// Potentially capturable variables of a nested lambda that might need
871  /// to be captured by the lambda are housed here.
872  /// This is specifically useful for generic lambdas or
873  /// lambdas within a potentially evaluated-if-used context.
874  /// If an enclosing variable is named in an expression of a lambda nested
875  /// within a generic lambda, we don't always know know whether the variable
876  /// will truly be odr-used (i.e. need to be captured) by that nested lambda,
877  /// until its instantiation. But we still need to capture it in the
878  /// enclosing lambda if all intervening lambdas can capture the variable.
880 
881  /// Contains all variable-referring-expressions that refer
882  /// to local variables that are usable as constant expressions and
883  /// do not involve an odr-use (they may still need to be captured
884  /// if the enclosing full-expression is instantiation dependent).
885  llvm::SmallSet<Expr *, 8> NonODRUsedCapturingExprs;
886 
887  /// A map of explicit capture indices to their introducer source ranges.
888  llvm::DenseMap<unsigned, SourceRange> ExplicitCaptureRanges;
889 
890  /// Contains all of the variables defined in this lambda that shadow variables
891  /// that were defined in parent contexts. Used to avoid warnings when the
892  /// shadowed variables are uncaptured by this lambda.
894  const VarDecl *VD;
896  };
898 
900 
903  Kind = SK_Lambda;
904  }
905 
906  /// Note when all explicit captures have been added.
908  NumExplicitCaptures = Captures.size();
909  }
910 
911  static bool classof(const FunctionScopeInfo *FSI) {
912  return FSI->Kind == SK_Lambda;
913  }
914 
915  /// Is this scope known to be for a generic lambda? (This will be false until
916  /// we parse a template parameter list or the first 'auto'-typed parameter).
917  bool isGenericLambda() const {
918  return !TemplateParams.empty() || GLTemplateParameterList;
919  }
920 
921  /// Add a variable that might potentially be captured by the
922  /// lambda and therefore the enclosing lambdas.
923  ///
924  /// This is also used by enclosing lambda's to speculatively capture
925  /// variables that nested lambda's - depending on their enclosing
926  /// specialization - might need to capture.
927  /// Consider:
928  /// void f(int, int); <-- don't capture
929  /// void f(const int&, double); <-- capture
930  /// void foo() {
931  /// const int x = 10;
932  /// auto L = [=](auto a) { // capture 'x'
933  /// return [=](auto b) {
934  /// f(x, a); // we may or may not need to capture 'x'
935  /// };
936  /// };
937  /// }
938  void addPotentialCapture(Expr *VarExpr) {
939  assert(isa<DeclRefExpr>(VarExpr) || isa<MemberExpr>(VarExpr) ||
940  isa<FunctionParmPackExpr>(VarExpr));
941  PotentiallyCapturingExprs.push_back(VarExpr);
942  }
943 
946  }
947 
948  bool hasPotentialThisCapture() const {
950  }
951 
952  /// Mark a variable's reference in a lambda as non-odr using.
953  ///
954  /// For generic lambdas, if a variable is named in a potentially evaluated
955  /// expression, where the enclosing full expression is dependent then we
956  /// must capture the variable (given a default capture).
957  /// This is accomplished by recording all references to variables
958  /// (DeclRefExprs or MemberExprs) within said nested lambda in its array of
959  /// PotentialCaptures. All such variables have to be captured by that lambda,
960  /// except for as described below.
961  /// If that variable is usable as a constant expression and is named in a
962  /// manner that does not involve its odr-use (e.g. undergoes
963  /// lvalue-to-rvalue conversion, or discarded) record that it is so. Upon the
964  /// act of analyzing the enclosing full expression (ActOnFinishFullExpr)
965  /// if we can determine that the full expression is not instantiation-
966  /// dependent, then we can entirely avoid its capture.
967  ///
968  /// const int n = 0;
969  /// [&] (auto x) {
970  /// (void)+n + x;
971  /// };
972  /// Interestingly, this strategy would involve a capture of n, even though
973  /// it's obviously not odr-used here, because the full-expression is
974  /// instantiation-dependent. It could be useful to avoid capturing such
975  /// variables, even when they are referred to in an instantiation-dependent
976  /// expression, if we can unambiguously determine that they shall never be
977  /// odr-used. This would involve removal of the variable-referring-expression
978  /// from the array of PotentialCaptures during the lvalue-to-rvalue
979  /// conversions. But per the working draft N3797, (post-chicago 2013) we must
980  /// capture such variables.
981  /// Before anyone is tempted to implement a strategy for not-capturing 'n',
982  /// consider the insightful warning in:
983  /// /cfe-commits/Week-of-Mon-20131104/092596.html
984  /// "The problem is that the set of captures for a lambda is part of the ABI
985  /// (since lambda layout can be made visible through inline functions and the
986  /// like), and there are no guarantees as to which cases we'll manage to build
987  /// an lvalue-to-rvalue conversion in, when parsing a template -- some
988  /// seemingly harmless change elsewhere in Sema could cause us to start or stop
989  /// building such a node. So we need a rule that anyone can implement and get
990  /// exactly the same result".
991  void markVariableExprAsNonODRUsed(Expr *CapturingVarExpr) {
992  assert(isa<DeclRefExpr>(CapturingVarExpr) ||
993  isa<MemberExpr>(CapturingVarExpr) ||
994  isa<FunctionParmPackExpr>(CapturingVarExpr));
995  NonODRUsedCapturingExprs.insert(CapturingVarExpr);
996  }
997  bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const {
998  assert(isa<DeclRefExpr>(CapturingVarExpr) ||
999  isa<MemberExpr>(CapturingVarExpr) ||
1000  isa<FunctionParmPackExpr>(CapturingVarExpr));
1001  return NonODRUsedCapturingExprs.count(CapturingVarExpr);
1002  }
1006  PotentiallyCapturingExprs.end(), E),
1008  }
1010  PotentiallyCapturingExprs.clear();
1012  }
1014  return PotentiallyCapturingExprs.size();
1015  }
1016 
1017  bool hasPotentialCaptures() const {
1020  }
1021 
1023  llvm::function_ref<void(VarDecl *, Expr *)> Callback) const;
1024 };
1025 
1026 FunctionScopeInfo::WeakObjectProfileTy::WeakObjectProfileTy()
1027  : Base(nullptr, false) {}
1028 
1029 FunctionScopeInfo::WeakObjectProfileTy
1030 FunctionScopeInfo::WeakObjectProfileTy::getSentinel() {
1031  FunctionScopeInfo::WeakObjectProfileTy Result;
1032  Result.Base.setInt(true);
1033  return Result;
1034 }
1035 
1036 template <typename ExprT>
1037 void FunctionScopeInfo::recordUseOfWeak(const ExprT *E, bool IsRead) {
1038  assert(E);
1039  WeakUseVector &Uses = WeakObjectUses[WeakObjectProfileTy(E)];
1040  Uses.push_back(WeakUseTy(E, IsRead));
1041 }
1042 
1043 inline void CapturingScopeInfo::addThisCapture(bool isNested,
1044  SourceLocation Loc,
1045  QualType CaptureType,
1046  bool ByCopy) {
1047  Captures.push_back(Capture(Capture::ThisCapture, isNested, Loc, CaptureType,
1048  ByCopy, /*Invalid*/ false));
1049  CXXThisCaptureIndex = Captures.size();
1050 }
1051 
1052 } // namespace sema
1053 
1054 } // namespace clang
1055 
1056 #endif // LLVM_CLANG_SEMA_SCOPEINFO_H
clang::sema::CapturedRegionScopeInfo::classof
static bool classof(const FunctionScopeInfo *FSI)
Definition: ScopeInfo.h:813
clang::sema::FunctionScopeInfo::WeakObjectProfileTy::DenseMapInfo::getHashValue
static unsigned getHashValue(const WeakObjectProfileTy &Val)
Definition: ScopeInfo.h:318
clang::sema::FunctionScopeInfo::WeakObjectProfileTy::DenseMapInfo::getTombstoneKey
static WeakObjectProfileTy getTombstoneKey()
Definition: ScopeInfo.h:314
clang::sema::CapturingScopeInfo::addCapture
void addCapture(VarDecl *Var, bool isBlock, bool isByref, bool isNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
Definition: ScopeInfo.h:686
clang::sema::Capture::isThisCapture
bool isThisCapture() const
Definition: ScopeInfo.h:604
clang::sema::LambdaScopeInfo::ExplicitTemplateParamsRange
SourceRange ExplicitTemplateParamsRange
Source range covering the explicit template parameter list (if it exists).
Definition: ScopeInfo.h:854
clang::sema::FunctionScopeInfo::NeedsCoroutineSuspends
bool NeedsCoroutineSuspends
True only when this function has not already built, or attempted to build, the initial and final coro...
Definition: ScopeInfo.h:165
clang::sema::FunctionScopeInfo::PossiblyUnreachableDiags
SmallVector< PossiblyUnreachableDiag, 4 > PossiblyUnreachableDiags
A list of PartialDiagnostics created but delayed within the current function scope.
Definition: ScopeInfo.h:225
clang::sema::Capture::markUsed
void markUsed(bool IsODRUse)
Definition: ScopeInfo.h:623
clang::sema::Capture::getLocation
SourceLocation getLocation() const
Retrieve the location at which this variable was captured.
Definition: ScopeInfo.h:641
clang::InventedTemplateParameterInfo
Definition: DeclSpec.h:2712
clang::sema::FunctionScopeInfo::getWeakObjectUses
const WeakObjectUseMap & getWeakObjectUses() const
Definition: ScopeInfo.h:413
clang::sema::FunctionScopeInfo::setHasFallthroughStmt
void setHasFallthroughStmt()
Definition: ScopeInfo.h:439
clang::sema::FunctionScopeInfo::getFirstCoroutineStmtKeyword
StringRef getFirstCoroutineStmtKeyword() const
Definition: ScopeInfo.h:484
clang::sema::FunctionScopeInfo::Kind
ScopeKind Kind
What kind of scope we are describing.
Definition: ScopeInfo.h:109
clang::sema::Capture::isODRUsed
bool isODRUsed() const
Definition: ScopeInfo.h:621
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:212
clang::sema::FunctionScopeInfo::CoroutineSuspends
std::pair< Stmt *, Stmt * > CoroutineSuspends
The initial and final coroutine suspend points.
Definition: ScopeInfo.h:210
clang::sema::LambdaScopeInfo::ExplicitParams
bool ExplicitParams
Whether the (empty) parameter list is explicit.
Definition: ScopeInfo.h:842
clang::sema::CapturedRegionScopeInfo::CapturedRegionScopeInfo
CapturedRegionScopeInfo(DiagnosticsEngine &Diag, Scope *S, CapturedDecl *CD, RecordDecl *RD, ImplicitParamDecl *Context, CapturedRegionKind K, unsigned OpenMPLevel, unsigned OpenMPCaptureLevel)
Definition: ScopeInfo.h:787
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::sema::FunctionScopeInfo::SK_Lambda
@ SK_Lambda
Definition: ScopeInfo.h:103
clang::sema::BlockScopeInfo::BlockScopeInfo
BlockScopeInfo(DiagnosticsEngine &Diag, Scope *BlockScope, BlockDecl *Block)
Definition: ScopeInfo.h:753
clang::sema::FunctionScopeInfo::ByrefBlockVars
llvm::TinyPtrVector< VarDecl * > ByrefBlockVars
The set of __block variables that are introduced in this function.
Definition: ScopeInfo.h:220
clang::sema::CapturingScopeInfo::CapturingScopeInfo
CapturingScopeInfo(const CapturingScopeInfo &)=default
clang::sema::Capture::isInitCapture
bool isInitCapture() const
Determine whether this capture is an init-capture.
Definition: ScopeInfo.cpp:220
clang::sema::Capture::getVariable
VarDecl * getVariable() const
Definition: ScopeInfo.h:630
clang::sema::LambdaScopeInfo::Mutable
bool Mutable
Whether this is a mutable lambda.
Definition: ScopeInfo.h:839
llvm::SmallVector< SwitchInfo, 8 >
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::sema::Capture::isReferenceCapture
bool isReferenceCapture() const
Definition: ScopeInfo.h:610
clang::sema::FunctionScopeInfo::setUsesFPIntrin
void setUsesFPIntrin()
Definition: ScopeInfo.h:443
clang::sema::FunctionScopeInfo::SwitchInfo
llvm::PointerIntPair< SwitchStmt *, 1, bool > SwitchInfo
A SwitchStmt, along with a flag indicating if its list of case statements is incomplete (because we d...
Definition: ScopeInfo.h:191
clang::sema::FunctionScopeInfo::Clear
void Clear()
Clear out the information in this function scope, making it suitable for reuse.
Definition: ScopeInfo.cpp:25
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:249
clang::sema::FunctionScopeInfo::CoroutineParameterMoves
llvm::SmallMapVector< ParmVarDecl *, Stmt *, 4 > CoroutineParameterMoves
A mapping between the coroutine function parameters that were moved to the coroutine frame,...
Definition: ScopeInfo.h:207
clang::sema::FunctionScopeInfo::HasBranchIntoScope
bool HasBranchIntoScope
Whether this function contains any switches or direct gotos.
Definition: ScopeInfo.h:116
clang::sema::Capture::Capture
Capture(IsThisCapture, bool IsNested, SourceLocation Loc, QualType CaptureType, const bool ByCopy, bool Invalid)
Definition: ScopeInfo.h:590
clang::sema::LambdaScopeInfo::NumExplicitCaptures
unsigned NumExplicitCaptures
The number of captures in the Captures list that are explicit captures.
Definition: ScopeInfo.h:836
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:673
clang::sema::FunctionScopeInfo::FirstCoroutineStmtKind
unsigned char FirstCoroutineStmtKind
An enumeration represeting the kind of the first coroutine statement in the function.
Definition: ScopeInfo.h:169
clang::sema::FunctionScopeInfo::addByrefBlockVar
void addByrefBlockVar(VarDecl *VD)
Definition: ScopeInfo.h:468
clang::sema::FunctionScopeInfo::setHasOMPDeclareReductionCombiner
void setHasOMPDeclareReductionCombiner()
Definition: ScopeInfo.h:435
clang::sema::FunctionScopeInfo::WeakObjectProfileTy::isExactProfile
bool isExactProfile() const
Returns true if the object base specifies a known object in memory, rather than, say,...
Definition: ScopeInfo.h:296
clang::sema::FunctionScopeInfo::NeedsScopeChecking
bool NeedsScopeChecking() const
Definition: ScopeInfo.h:457
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:191
clang::sema::CompoundScopeInfo::CompoundScopeInfo
CompoundScopeInfo(bool IsStmtExpr)
Definition: ScopeInfo.h:78
clang::sema::LambdaScopeInfo::GLTemplateParameterList
TemplateParameterList * GLTemplateParameterList
If this is a generic lambda, and the template parameter list has been created (from the TemplateParam...
Definition: ScopeInfo.h:864
clang::sema::FunctionScopeInfo::WeakObjectProfileTy::DenseMapInfo::isEqual
static bool isEqual(const WeakObjectProfileTy &LHS, const WeakObjectProfileTy &RHS)
Definition: ScopeInfo.h:325
clang::CapturedRegionKind
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:16
clang::sema::CapturingScopeInfo::ImplicitCaptureStyle
ImplicitCaptureStyle
Definition: ScopeInfo.h:658
clang::sema::CapturingScopeInfo::addVLATypeCapture
void addVLATypeCapture(SourceLocation Loc, const VariableArrayType *VLAType, QualType CaptureType)
Definition: ScopeInfo.h:694
llvm::SmallPtrSet
Definition: ASTContext.h:82
clang::sema::FunctionScopeInfo::FirstSEHTryLoc
SourceLocation FirstSEHTryLoc
First SEH '__try' statement in the current function.
Definition: ScopeInfo.h:182
clang::sema::FunctionScopeInfo::WeakUseTy::operator==
bool operator==(const WeakUseTy &Other) const
Definition: ScopeInfo.h:348
clang::DiagnosticErrorTrap::hasUnrecoverableErrorOccurred
bool hasUnrecoverableErrorOccurred() const
Determine whether any unrecoverable errors have occurred since this object instance was created.
Definition: Diagnostic.h:1084
clang::sema::FunctionScopeInfo::SK_Function
@ SK_Function
Definition: ScopeInfo.h:101
clang::sema::LambdaScopeInfo::LambdaScopeInfo
LambdaScopeInfo(DiagnosticsEngine &Diag)
Definition: ScopeInfo.h:901
DeclSpec.h
clang::sema::FunctionScopeInfo::UsesFPIntrin
bool UsesFPIntrin
Whether this function uses constrained floating point intrinsics.
Definition: ScopeInfo.h:135
clang::sema::BlockScopeInfo::TheDecl
BlockDecl * TheDecl
Definition: ScopeInfo.h:743
clang::sema::Capture
Definition: ScopeInfo.h:521
clang::sema::LambdaScopeInfo::isGenericLambda
bool isGenericLambda() const
Is this scope known to be for a generic lambda? (This will be false until we parse a template paramet...
Definition: ScopeInfo.h:917
clang::sema::LambdaScopeInfo::ShadowedOuterDecl
Contains all of the variables defined in this lambda that shadow variables that were defined in paren...
Definition: ScopeInfo.h:893
clang::sema::CapturingScopeInfo::classof
static bool classof(const FunctionScopeInfo *FSI)
Definition: ScopeInfo.h:734
clang::CapturedDecl
Represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:4342
clang::sema::BlockScopeInfo
Retains information about a block that is currently being parsed.
Definition: ScopeInfo.h:741
clang::sema::LambdaScopeInfo::RequiresClause
ExprResult RequiresClause
The requires-clause immediately following the explicit template parameter list, if any.
Definition: ScopeInfo.h:859
clang::sema::LambdaScopeInfo::finishedExplicitCaptures
void finishedExplicitCaptures()
Note when all explicit captures have been added.
Definition: ScopeInfo.h:907
clang::DiagnosticErrorTrap
RAII class that determines when any errors have occurred between the time the instance was created an...
Definition: Diagnostic.h:1067
clang::sema::FunctionScopeInfo::Returns
SmallVector< ReturnStmt *, 4 > Returns
The list of return statements that occur within the function or block, if there is any chance of appl...
Definition: ScopeInfo.h:200
clang::sema::FunctionScopeInfo::WeakUseTy::WeakUseTy
WeakUseTy(const Expr *Use, bool IsRead)
Definition: ScopeInfo.h:342
clang::sema::LambdaScopeInfo::CallOperator
CXXMethodDecl * CallOperator
The lambda's compiler-generated operator().
Definition: ScopeInfo.h:825
clang::sema::BlockScopeInfo::classof
static bool classof(const FunctionScopeInfo *FSI)
Definition: ScopeInfo.h:761
clang::sema::Capture::IsVLACapture
IsVLACapture
Definition: ScopeInfo.h:597
clang::sema::FunctionScopeInfo::SK_Block
@ SK_Block
Definition: ScopeInfo.h:102
clang::sema::Capture::isCopyCapture
bool isCopyCapture() const
Definition: ScopeInfo.h:609
clang::sema::FunctionScopeInfo::setHasBranchProtectedScope
void setHasBranchProtectedScope()
Definition: ScopeInfo.h:421
clang::sema::CapturedRegionScopeInfo
Retains information about a captured region.
Definition: ScopeInfo.h:767
clang::sema::FunctionScopeInfo::recordUseOfWeak
void recordUseOfWeak(const ExprT *E, bool IsRead=true)
Record that a weak object was accessed.
Definition: ScopeInfo.h:1037
clang::sema::FunctionScopeInfo::WeakUseVector
SmallVector< WeakUseTy, 4 > WeakUseVector
Used to collect uses of a particular weak object in a function body.
Definition: ScopeInfo.h:356
clang::sema::Capture::ThisCapture
@ ThisCapture
Definition: ScopeInfo.h:589
clang::sema::CapturingScopeInfo::ImpCap_Block
@ ImpCap_Block
Definition: ScopeInfo.h:659
clang::ObjCPropertyRefExpr
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:614
clang::sema::CapturedRegionScopeInfo::CapRegionKind
unsigned short CapRegionKind
The kind of captured region.
Definition: ScopeInfo.h:782
llvm::DenseMapInfo
Definition: TypeOrdering.h:37
clang::sema::PossiblyUnreachableDiag::Loc
SourceLocation Loc
Definition: ScopeInfo.h:88
clang::sema::LambdaScopeInfo::Lambda
CXXRecordDecl * Lambda
The class that describes the lambda.
Definition: ScopeInfo.h:822
clang::sema::FunctionScopeInfo::WeakUseTy::isUnsafe
bool isUnsafe() const
Definition: ScopeInfo.h:345
clang::CR_ObjCAtFinally
@ CR_ObjCAtFinally
Definition: CapturedStmt.h:18
clang::sema::PossiblyUnreachableDiag::Stmts
llvm::TinyPtrVector< const Stmt * > Stmts
Definition: ScopeInfo.h:89
clang::sema::FunctionScopeInfo::FirstCXXTryLoc
SourceLocation FirstCXXTryLoc
First C++ 'try' statement in the current function.
Definition: ScopeInfo.h:179
clang::sema::LambdaScopeInfo::getNumPotentialVariableCaptures
unsigned getNumPotentialVariableCaptures() const
Definition: ScopeInfo.h:1013
clang::sema::FunctionScopeInfo::Blocks
llvm::SmallPtrSet< const BlockDecl *, 1 > Blocks
The set of blocks that are introduced in this function.
Definition: ScopeInfo.h:217
clang::sema::FunctionScopeInfo::HasMustTail
bool HasMustTail
Whether this function contains any statement marked with [[clang::musttail]].
Definition: ScopeInfo.h:123
clang::sema::Capture::CapturedVLA
const VariableArrayType * CapturedVLA
If Kind == Cap_VLA, the captured type.
Definition: ScopeInfo.h:541
clang::sema::LambdaScopeInfo::markVariableExprAsNonODRUsed
void markVariableExprAsNonODRUsed(Expr *CapturingVarExpr)
Mark a variable's reference in a lambda as non-odr using.
Definition: ScopeInfo.h:991
clang::sema::LambdaScopeInfo::removePotentialCapture
void removePotentialCapture(Expr *E)
Definition: ScopeInfo.h:1003
clang::BlockDecl
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4153
clang::sema::FunctionScopeInfo::WeakObjectProfileTy::DenseMapInfo
Definition: ScopeInfo.h:308
clang::sema::FunctionScopeInfo::HasDroppedStmt
bool HasDroppedStmt
Whether a statement was dropped because it was invalid.
Definition: ScopeInfo.h:126
clang::sema::CompoundScopeInfo::IsStmtExpr
bool IsStmtExpr
Whether this compound statement corresponds to a GNU statement expression.
Definition: ScopeInfo.h:76
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::sema::Capture::getCapturedVLAType
const VariableArrayType * getCapturedVLAType() const
Definition: ScopeInfo.h:635
clang::sema::LambdaScopeInfo::PotentialThisCaptureLocation
SourceLocation PotentialThisCaptureLocation
Definition: ScopeInfo.h:899
clang::sema::PossiblyUnreachableDiag::PD
PartialDiagnostic PD
Definition: ScopeInfo.h:87
clang::sema::Capture::getCaptureType
QualType getCaptureType() const
Retrieve the capture type for this capture, which is effectively the type of the non-static data memb...
Definition: ScopeInfo.h:650
clang::sema::FunctionScopeInfo::setHasCXXTry
void setHasCXXTry(SourceLocation TryLoc)
Definition: ScopeInfo.h:447
clang::sema::FunctionScopeInfo::setHasIndirectGoto
void setHasIndirectGoto()
Definition: ScopeInfo.h:425
clang::sema::FunctionScopeInfo::hasUnrecoverableErrorOccurred
bool hasUnrecoverableErrorOccurred() const
Determine whether an unrecoverable error has occurred within this function.
Definition: ScopeInfo.h:394
clang::sema::CapturingScopeInfo::ImpCap_None
@ ImpCap_None
Definition: ScopeInfo.h:659
clang::sema::Capture::isInvalid
bool isInvalid() const
Definition: ScopeInfo.h:616
clang::sema::LambdaScopeInfo::hasPotentialThisCapture
bool hasPotentialThisCapture() const
Definition: ScopeInfo.h:948
clang::sema::FunctionScopeInfo::CoroutinePromise
VarDecl * CoroutinePromise
The promise object for this coroutine, if any.
Definition: ScopeInfo.h:203
clang::sema::CompoundScopeInfo::HasEmptyLoopBodies
bool HasEmptyLoopBodies
Whether this compound stamement contains ‘for’ or ‘while’ loops with empty bodies.
Definition: ScopeInfo.h:72
clang::sema::Capture::isNonODRUsed
bool isNonODRUsed() const
Definition: ScopeInfo.h:622
clang::sema::LambdaScopeInfo::hasPotentialCaptures
bool hasPotentialCaptures() const
Definition: ScopeInfo.h:1017
clang::sema::FunctionScopeInfo::WeakUseTy
Represents a single use of a weak object.
Definition: ScopeInfo.h:338
clang::sema::CapturedRegionScopeInfo::getRegionName
StringRef getRegionName() const
A descriptive name for the kind of captured region this is.
Definition: ScopeInfo.h:801
clang::sema::FunctionScopeInfo::SwitchStack
SmallVector< SwitchInfo, 8 > SwitchStack
SwitchStack - This is the current set of active switch statements in the block.
Definition: ScopeInfo.h:195
clang::sema::FunctionScopeInfo::HasBranchProtectedScope
bool HasBranchProtectedScope
Whether this function contains a VLA, @try, try, C++ initializer, or anything else that can't be jump...
Definition: ScopeInfo.h:113
clang::sema::FunctionScopeInfo::HasPotentialAvailabilityViolations
bool HasPotentialAvailabilityViolations
Whether we make reference to a declaration that could be unavailable.
Definition: ScopeInfo.h:139
Type.h
clang::sema::CapturingScopeInfo::ImpCap_CapturedRegion
@ ImpCap_CapturedRegion
Definition: ScopeInfo.h:660
clang::ImplicitParamDecl
Definition: Decl.h:1601
clang::sema::FunctionScopeInfo::setHasBranchIntoScope
void setHasBranchIntoScope()
Definition: ScopeInfo.h:417
clang::CR_OpenMP
@ CR_OpenMP
Definition: CapturedStmt.h:19
Expr.h
clang::sema::FunctionScopeInfo::ScopeKind
ScopeKind
Definition: ScopeInfo.h:100
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:876
clang::sema::CapturingScopeInfo::getCapture
Capture & getCapture(VarDecl *Var)
Retrieve the capture of the given variable, if it has been captured already.
Definition: ScopeInfo.h:722
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
clang::sema::FunctionScopeInfo::~FunctionScopeInfo
virtual ~FunctionScopeInfo()
Definition: ScopeInfo.cpp:249
clang::sema::LambdaScopeInfo::visitPotentialCaptures
void visitPotentialCaptures(llvm::function_ref< void(VarDecl *, Expr *)> Callback) const
Definition: ScopeInfo.cpp:233
ExprCXX.h
Base
clang::sema::FunctionScopeInfo::setHasDroppedStmt
void setHasDroppedStmt()
Definition: ScopeInfo.h:431
clang::sema::CapturedRegionScopeInfo::~CapturedRegionScopeInfo
~CapturedRegionScopeInfo() override
Definition: ScopeInfo.cpp:251
clang::sema::CapturingScopeInfo::ImpCaptureStyle
ImplicitCaptureStyle ImpCaptureStyle
Definition: ScopeInfo.h:663
clang::sema::FunctionScopeInfo::ObjCShouldCallSuper
bool ObjCShouldCallSuper
A flag that is set when parsing a method that must call super's implementation, such as -dealloc,...
Definition: ScopeInfo.h:144
clang::sema::FunctionScopeInfo::FunctionScopeInfo
FunctionScopeInfo(DiagnosticsEngine &Diag)
Definition: ScopeInfo.h:375
clang::ObjCMessageExpr
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:940
clang::sema::FunctionScopeInfo::setHasSEHTry
void setHasSEHTry(SourceLocation TryLoc)
Definition: ScopeInfo.h:452
clang::sema::Capture::isNested
bool isNested() const
Definition: ScopeInfo.h:614
clang::sema::CapturedRegionScopeInfo::TheRecordDecl
RecordDecl * TheRecordDecl
The captured record type.
Definition: ScopeInfo.h:773
clang::sema::BlockScopeInfo::FunctionType
QualType FunctionType
BlockType - The function type of the block, if one was given.
Definition: ScopeInfo.h:751
clang::sema::LambdaScopeInfo::LocalPacks
SmallVector< NamedDecl *, 4 > LocalPacks
Packs introduced by this lambda, if any.
Definition: ScopeInfo.h:851
clang::sema::CapturingScopeInfo::ImpCap_LambdaByval
@ ImpCap_LambdaByval
Definition: ScopeInfo.h:659
clang::sema::Capture::CapturedVar
VarDecl * CapturedVar
Otherwise, the captured variable (if any).
Definition: ScopeInfo.h:544
clang::sema::Capture::Capture
Capture(IsVLACapture, const VariableArrayType *VLA, bool IsNested, SourceLocation Loc, QualType CaptureType)
Definition: ScopeInfo.h:598
clang::sema::FunctionScopeInfo
Retains information about a function, method, or block that is currently being parsed.
Definition: ScopeInfo.h:98
clang::sema::FunctionScopeInfo::WeakUseTy::markSafe
void markSafe()
Definition: ScopeInfo.h:346
clang::transformer::remove
ASTEdit remove(RangeSelector S)
Removes the source selected by S.
Definition: RewriteRule.cpp:146
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:255
SourceLocation.h
clang::CR_Default
@ CR_Default
Definition: CapturedStmt.h:17
clang::sema::FunctionScopeInfo::FirstCoroutineStmtLoc
SourceLocation FirstCoroutineStmtLoc
First coroutine statement in the current function.
Definition: ScopeInfo.h:173
clang::sema::FunctionScopeInfo::ObjCWarnForNoInitDelegation
bool ObjCWarnForNoInitDelegation
This starts true for a secondary initializer method and will be set to false if there is an invocatio...
Definition: ScopeInfo.h:161
clang::VariableArrayType
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:3033
clang::sema::CapturingScopeInfo::Captures
SmallVector< Capture, 4 > Captures
Captures - The captures.
Definition: ScopeInfo.h:676
clang::sema::FunctionScopeInfo::ObjCIsDesignatedInit
bool ObjCIsDesignatedInit
True when this is a method marked as a designated initializer.
Definition: ScopeInfo.h:147
false
#define false
Definition: stdbool.h:17
clang::sema::LambdaScopeInfo::Cleanup
CleanupInfo Cleanup
Whether any of the capture expressions requires cleanups.
Definition: ScopeInfo.h:845
clang::sema::FunctionScopeInfo::FirstReturnLoc
SourceLocation FirstReturnLoc
First 'return' statement in the current function.
Definition: ScopeInfo.h:176
clang::InventedTemplateParameterInfo::TemplateParams
SmallVector< NamedDecl *, 4 > TemplateParams
Store the list of the template parameters for a generic lambda or an abbreviated function template.
Definition: DeclSpec.h:2729
clang::sema::FunctionScopeInfo::WeakObjectProfileTy::operator==
bool operator==(const WeakObjectProfileTy &Other) const
Definition: ScopeInfo.h:300
clang::sema::CapturedRegionScopeInfo::TheCapturedDecl
CapturedDecl * TheCapturedDecl
The CapturedDecl for this statement.
Definition: ScopeInfo.h:770
clang::sema::Capture::isVLATypeCapture
bool isVLATypeCapture() const
Definition: ScopeInfo.h:612
llvm::ArrayRef
Definition: LLVM.h:34
clang::sema::FunctionScopeInfo::WeakUseTy::getUseExpr
const Expr * getUseExpr() const
Definition: ScopeInfo.h:344
clang::ObjCPropertyDecl
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:729
clang::sema::CapturingScopeInfo::getCapture
const Capture & getCapture(VarDecl *Var) const
Definition: ScopeInfo.h:727
CapturedStmt.h
clang::sema::FunctionScopeInfo::ObjCIsSecondaryInit
bool ObjCIsSecondaryInit
True when this is an initializer method not marked as a designated initializer within a class that ha...
Definition: ScopeInfo.h:157
LLVM.h
clang::sema::LambdaScopeInfo::clearPotentialCaptures
void clearPotentialCaptures()
Definition: ScopeInfo.h:1009
clang::sema::PossiblyUnreachableDiag
Definition: ScopeInfo.h:85
clang::sema::FunctionScopeInfo::ObjCWarnForNoDesignatedInitChain
bool ObjCWarnForNoDesignatedInitChain
This starts true for a method marked as designated initializer and will be set to false if there is a...
Definition: ScopeInfo.h:152
clang::sema::CapturingScopeInfo::CapturingScopeInfo
CapturingScopeInfo(DiagnosticsEngine &Diag, ImplicitCaptureStyle Style)
Definition: ScopeInfo.h:665
clang::sema::LambdaScopeInfo::IntroducerRange
SourceRange IntroducerRange
Source range covering the lambda introducer [...].
Definition: ScopeInfo.h:828
clang::sema::CapturingScopeInfo::isCaptured
bool isCaptured(VarDecl *Var) const
Determine whether the given variable has been captured.
Definition: ScopeInfo.h:713
clang::sema::FunctionScopeInfo::isCoroutine
bool isCoroutine() const
Definition: ScopeInfo.h:472
clang::sema::FunctionScopeInfo::markSafeWeakUse
void markSafeWeakUse(const Expr *E)
Record that a given expression is a "safe" access of a weak object (e.g.
Definition: ScopeInfo.cpp:158
clang::sema::BlockScopeInfo::TheScope
Scope * TheScope
TheScope - This is the scope for the block itself, which contains arguments etc.
Definition: ScopeInfo.h:747
clang::PartialDiagnostic
Definition: PartialDiagnostic.h:34
clang::ActionResult< Expr * >
clang::sema::LambdaScopeInfo::isVariableExprMarkedAsNonODRUsed
bool isVariableExprMarkedAsNonODRUsed(Expr *CapturingVarExpr) const
Definition: ScopeInfo.h:997
clang::sema::CapturingScopeInfo::CaptureMap
llvm::DenseMap< VarDecl *, unsigned > CaptureMap
CaptureMap - A map of captured variables to (index+1) into Captures.
Definition: ScopeInfo.h:669
clang::sema::FunctionScopeInfo::setHasMustTail
void setHasMustTail()
Definition: ScopeInfo.h:429
clang::sema::LambdaScopeInfo
Definition: ScopeInfo.h:818
clang::sema::FunctionScopeInfo::WeakObjectUseMap
llvm::SmallDenseMap< WeakObjectProfileTy, WeakUseVector, 8, WeakObjectProfileTy::DenseMapInfo > WeakObjectUseMap
Used to collect all uses of weak objects in a function body.
Definition: ScopeInfo.h:363
clang::sema::FunctionScopeInfo::setFirstCoroutineStmt
void setFirstCoroutineStmt(SourceLocation Loc, StringRef Keyword)
Definition: ScopeInfo.h:474
clang::sema::LambdaScopeInfo::ContainsUnexpandedParameterPack
bool ContainsUnexpandedParameterPack
Whether the lambda contains an unexpanded parameter pack.
Definition: ScopeInfo.h:848
clang::sema::CapturingScopeInfo::ImpCap_LambdaByref
@ ImpCap_LambdaByref
Definition: ScopeInfo.h:659
clang::sema::FunctionScopeInfo::WeakObjectProfileTy
Represents a simple identification of a weak object.
Definition: ScopeInfo.h:254
clang::SourceLocation::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:113
clang::sema::FunctionScopeInfo::HasOMPDeclareReductionCombiner
bool HasOMPDeclareReductionCombiner
True if current scope is for OpenMP declare reduction combiner.
Definition: ScopeInfo.h:129
clang::sema::BlockScopeInfo::~BlockScopeInfo
~BlockScopeInfo() override
Definition: ScopeInfo.cpp:250
clang::sema::CapturedRegionScopeInfo::ContextParam
ImplicitParamDecl * ContextParam
The implicit parameter for the captured variables.
Definition: ScopeInfo.h:779
PartialDiagnostic.h
clang::sema::LambdaScopeInfo::NonODRUsedCapturingExprs
llvm::SmallSet< Expr *, 8 > NonODRUsedCapturingExprs
Contains all variable-referring-expressions that refer to local variables that are usable as constant...
Definition: ScopeInfo.h:885
clang
Definition: CalledOnceCheck.h:17
clang::sema::CapturedRegionScopeInfo::TheScope
Scope * TheScope
This is the enclosing scope of the captured region.
Definition: ScopeInfo.h:776
clang::sema::FunctionScopeInfo::CompoundScopes
SmallVector< CompoundScopeInfo, 4 > CompoundScopes
The stack of currently active compound stamement scopes in the function.
Definition: ScopeInfo.h:214
clang::sema::CompoundScopeInfo
Contains information about the compound statement currently being parsed.
Definition: ScopeInfo.h:68
clang::sema::CapturedRegionScopeInfo::OpenMPCaptureLevel
unsigned short OpenMPCaptureLevel
Definition: ScopeInfo.h:785
clang::sema::FunctionScopeInfo::WeakObjectProfileTy::DenseMapInfo::getEmptyKey
static WeakObjectProfileTy getEmptyKey()
Definition: ScopeInfo.h:310
clang::sema::LambdaScopeInfo::PotentiallyCapturingExprs
llvm::SmallVector< Expr *, 4 > PotentiallyCapturingExprs
Contains all variable-referring-expressions (i.e.
Definition: ScopeInfo.h:879
clang::sema::LambdaScopeInfo::ExplicitCaptureRanges
llvm::DenseMap< unsigned, SourceRange > ExplicitCaptureRanges
A map of explicit capture indices to their introducer source ranges.
Definition: ScopeInfo.h:888
clang::DeclaratorContext::Block
@ Block
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:68
clang::sema::Capture::VLACapture
@ VLACapture
Definition: ScopeInfo.h:597
clang::sema::FunctionScopeInfo::isPlainFunction
bool isPlainFunction() const
Definition: ScopeInfo.h:518
CleanupInfo.h
clang::sema::LambdaScopeInfo::ShadowingDecls
llvm::SmallVector< ShadowedOuterDecl, 4 > ShadowingDecls
Definition: ScopeInfo.h:897
clang::sema::LambdaScopeInfo::classof
static bool classof(const FunctionScopeInfo *FSI)
Definition: ScopeInfo.h:911
clang::sema::FunctionScopeInfo::ModifiedNonNullParams
llvm::SmallPtrSet< const ParmVarDecl *, 8 > ModifiedNonNullParams
A list of parameters which have the nonnull attribute and are modified in the function.
Definition: ScopeInfo.h:229
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:112
clang::sema::FunctionScopeInfo::HasIndirectGoto
bool HasIndirectGoto
Whether this function contains any indirect gotos.
Definition: ScopeInfo.h:119
clang::sema::Capture::Capture
Capture(VarDecl *Var, bool Block, bool ByRef, bool IsNested, SourceLocation Loc, SourceLocation EllipsisLoc, QualType CaptureType, bool Invalid)
Definition: ScopeInfo.h:580
clang::sema::CapturingScopeInfo::HasImplicitReturnType
bool HasImplicitReturnType
Definition: ScopeInfo.h:680
clang::sema::FunctionScopeInfo::WeakObjectProfileTy::getProperty
const NamedDecl * getProperty() const
Definition: ScopeInfo.h:283
clang::sema::FunctionScopeInfo::SK_CapturedRegion
@ SK_CapturedRegion
Definition: ScopeInfo.h:104
clang::sema::CapturingScopeInfo::addThisCapture
void addThisCapture(bool isNested, SourceLocation Loc, QualType CaptureType, bool ByCopy)
Definition: ScopeInfo.h:1043
clang::ObjCSubstitutionContext::Property
@ Property
The type of a property.
clang::sema::CapturingScopeInfo
Definition: ScopeInfo.h:653
clang::sema::LambdaScopeInfo::ShadowedOuterDecl::ShadowedDecl
const VarDecl * ShadowedDecl
Definition: ScopeInfo.h:895
clang::sema::CapturingScopeInfo::CXXThisCaptureIndex
unsigned CXXThisCaptureIndex
CXXThisCaptureIndex - The (index+1) of the capture of 'this'; zero if 'this' is not captured.
Definition: ScopeInfo.h:673
clang::sema::Capture::isBlockCapture
bool isBlockCapture() const
Definition: ScopeInfo.h:611
clang::sema::LambdaScopeInfo::addPotentialThisCapture
void addPotentialThisCapture(SourceLocation Loc)
Definition: ScopeInfo.h:944
clang::sema::CapturingScopeInfo::getCXXThisCapture
Capture & getCXXThisCapture()
Retrieve the capture of C++ 'this', if it has been captured.
Definition: ScopeInfo.h:707
clang::sema::FunctionScopeInfo::hasInvalidCoroutineSuspends
bool hasInvalidCoroutineSuspends() const
Definition: ScopeInfo.h:502
clang::sema::FunctionScopeInfo::HasFallthroughStmt
bool HasFallthroughStmt
Whether there is a fallthrough statement in this function.
Definition: ScopeInfo.h:132
clang::sema::LambdaScopeInfo::addPotentialCapture
void addPotentialCapture(Expr *VarExpr)
Add a variable that might potentially be captured by the lambda and therefore the enclosing lambdas.
Definition: ScopeInfo.h:938
clang::sema::CapturingScopeInfo::isVLATypeCaptured
bool isVLATypeCaptured(const VariableArrayType *VAT) const
Determine whether the given variable-array type has been captured.
Definition: ScopeInfo.cpp:226
clang::sema::FunctionScopeInfo::setNeedsCoroutineSuspends
void setNeedsCoroutineSuspends(bool value=true)
Definition: ScopeInfo.h:496
true
#define true
Definition: stdbool.h:16
clang::sema::Capture::IsThisCapture
IsThisCapture
Definition: ScopeInfo.h:589
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::sema::FunctionScopeInfo::FunctionScopeInfo
FunctionScopeInfo(const FunctionScopeInfo &)=default
clang::sema::Capture::isVariableCapture
bool isVariableCapture() const
Definition: ScopeInfo.h:605
clang::CleanupInfo
Definition: CleanupInfo.h:19
clang::sema::FunctionScopeInfo::setCoroutineSuspends
void setCoroutineSuspends(Stmt *Initial, Stmt *Final)
Definition: ScopeInfo.h:506
clang::sema::CapturedRegionScopeInfo::OpenMPLevel
unsigned short OpenMPLevel
Definition: ScopeInfo.h:784
clang::sema::CapturingScopeInfo::ReturnType
QualType ReturnType
ReturnType - The target type of return statements in this context, or null if unknown.
Definition: ScopeInfo.h:684
clang::sema::Capture::getEllipsisLoc
SourceLocation getEllipsisLoc() const
Retrieve the source location of the ellipsis, whose presence indicates that the capture is a pack exp...
Definition: ScopeInfo.h:645
clang::DeclRefExpr
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1217
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3859
clang::ObjCIvarRefExpr
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:548
clang::sema::PossiblyUnreachableDiag::PossiblyUnreachableDiag
PossiblyUnreachableDiag(const PartialDiagnostic &PD, SourceLocation Loc, ArrayRef< const Stmt * > Stmts)
Definition: ScopeInfo.h:91
clang::sema::LambdaScopeInfo::ShadowedOuterDecl::VD
const VarDecl * VD
Definition: ScopeInfo.h:894
clang::sema::FunctionScopeInfo::WeakObjectProfileTy::getBase
const NamedDecl * getBase() const
Definition: ScopeInfo.h:282
clang::sema::FunctionScopeInfo::addBlock
void addBlock(const BlockDecl *BD)
Definition: ScopeInfo.h:463
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1948
clang::sema::CompoundScopeInfo::setHasEmptyLoopBodies
void setHasEmptyLoopBodies()
Definition: ScopeInfo.h:80
clang::sema::LambdaScopeInfo::CaptureDefaultLoc
SourceLocation CaptureDefaultLoc
Source location of the '&' or '=' specifying the default capture type, if any.
Definition: ScopeInfo.h:832
clang::sema::CapturingScopeInfo::isCXXThisCaptured
bool isCXXThisCaptured() const
Determine whether the C++ 'this' is captured.
Definition: ScopeInfo.h:704