include/clang/Sema/Scope.h - llvm-project/clang - Git at Google

 //===- Scope.h - Scope interface --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the Scope interface.
 //
 //===----------------------------------------------------------------------===//

 #ifndef LLVM_CLANG_SEMA_SCOPE_H
 #define LLVM_CLANG_SEMA_SCOPE_H

 #include "clang/AST/Decl.h"
 #include "clang/Basic/Diagnostic.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/iterator_range.h"
 #include <cassert>
 #include <optional>

 namespace llvm {

 class raw_ostream;

 } // namespace llvm

 namespace clang {

 class Decl;
 class DeclContext;
 class UsingDirectiveDecl;
 class VarDecl;

 /// Scope - A scope is a transient data structure that is used while parsing the
 /// program.  It assists with resolving identifiers to the appropriate
 /// declaration.
 class Scope {
 public:
   /// ScopeFlags - These are bitfields that are or'd together when creating a
   /// scope, which defines the sorts of things the scope contains.
   enum ScopeFlags {
     // A bitfield value representing no scopes.
     NoScope = 0,

     /// This indicates that the scope corresponds to a function, which
     /// means that labels are set here.
     FnScope = 0x01,

     /// This is a while, do, switch, for, etc that can have break
     /// statements embedded into it.
     BreakScope = 0x02,

     /// This is a while, do, for, which can have continue statements
     /// embedded into it.
     ContinueScope = 0x04,

     /// This is a scope that can contain a declaration.  Some scopes
     /// just contain loop constructs but don't contain decls.
     DeclScope = 0x08,

     /// The controlling scope in a if/switch/while/for statement.
     ControlScope = 0x10,

     /// The scope of a struct/union/class definition.
     ClassScope = 0x20,

     /// This is a scope that corresponds to a block/closure object.
     /// Blocks serve as top-level scopes for some objects like labels, they
     /// also prevent things like break and continue.  BlockScopes always have
     /// the FnScope and DeclScope flags set as well.
     BlockScope = 0x40,

     /// This is a scope that corresponds to the
     /// template parameters of a C++ template. Template parameter
     /// scope starts at the 'template' keyword and ends when the
     /// template declaration ends.
     TemplateParamScope = 0x80,

     /// This is a scope that corresponds to the
     /// parameters within a function prototype.
     FunctionPrototypeScope = 0x100,

     /// This is a scope that corresponds to the parameters within
     /// a function prototype for a function declaration (as opposed to any
     /// other kind of function declarator). Always has FunctionPrototypeScope
     /// set as well.
     FunctionDeclarationScope = 0x200,

     /// This is a scope that corresponds to the Objective-C
     /// \@catch statement.
     AtCatchScope = 0x400,

     /// This scope corresponds to an Objective-C method body.
     /// It always has FnScope and DeclScope set as well.
     ObjCMethodScope = 0x800,

     /// This is a scope that corresponds to a switch statement.
     SwitchScope = 0x1000,

     /// This is the scope of a C++ try statement.
     TryScope = 0x2000,

     /// This is the scope for a function-level C++ try or catch scope.
     FnTryCatchScope = 0x4000,

     /// This is the scope of OpenMP executable directive.
     OpenMPDirectiveScope = 0x8000,

     /// This is the scope of some OpenMP loop directive.
     OpenMPLoopDirectiveScope = 0x10000,

     /// This is the scope of some OpenMP simd directive.
     /// For example, it is used for 'omp simd', 'omp for simd'.
     /// This flag is propagated to children scopes.
     OpenMPSimdDirectiveScope = 0x20000,

     /// This scope corresponds to an enum.
     EnumScope = 0x40000,

     /// This scope corresponds to an SEH try.
     SEHTryScope = 0x80000,

     /// This scope corresponds to an SEH except.
     SEHExceptScope = 0x100000,

     /// We are currently in the filter expression of an SEH except block.
     SEHFilterScope = 0x200000,

     /// This is a compound statement scope.
     CompoundStmtScope = 0x400000,

     /// We are between inheritance colon and the real class/struct definition
     /// scope.
     ClassInheritanceScope = 0x800000,

     /// This is the scope of a C++ catch statement.
     CatchScope = 0x1000000,

     /// This is a scope in which a condition variable is currently being
     /// parsed. If such a scope is a ContinueScope, it's invalid to jump to the
     /// continue block from here.
     ConditionVarScope = 0x2000000,

     /// This is a scope of some OpenMP directive with
     /// order clause which specifies concurrent
     OpenMPOrderClauseScope = 0x4000000,
     /// This is the scope for a lambda, after the lambda introducer.
     /// Lambdas need two FunctionPrototypeScope scopes (because there is a
     /// template scope in between), the outer scope does not increase the
     /// depth of recursion.
     LambdaScope = 0x8000000,
     /// This is the scope of an OpenACC Compute Construct, which restricts
     /// jumping into/out of it.
     OpenACCComputeConstructScope = 0x10000000,

     /// This is a scope of type alias declaration.
     TypeAliasScope = 0x20000000,
   };

 private:
   /// The parent scope for this scope.  This is null for the translation-unit
   /// scope.
   Scope *AnyParent;

   /// Flags - This contains a set of ScopeFlags, which indicates how the scope
   /// interrelates with other control flow statements.
   unsigned Flags;

   /// Depth - This is the depth of this scope.  The translation-unit scope has
   /// depth 0.
   unsigned short Depth;

   /// Declarations with static linkage are mangled with the number of
   /// scopes seen as a component.
   unsigned short MSLastManglingNumber;

   unsigned short MSCurManglingNumber;

   /// PrototypeDepth - This is the number of function prototype scopes
   /// enclosing this scope, including this scope.
   unsigned short PrototypeDepth;

   /// PrototypeIndex - This is the number of parameters currently
   /// declared in this scope.
   unsigned short PrototypeIndex;

   /// FnParent - If this scope has a parent scope that is a function body, this
   /// pointer is non-null and points to it.  This is used for label processing.
   Scope *FnParent;
   Scope *MSLastManglingParent;

   /// BreakParent/ContinueParent - This is a direct link to the innermost
   /// BreakScope/ContinueScope which contains the contents of this scope
   /// for control flow purposes (and might be this scope itself), or null
   /// if there is no such scope.
   Scope *BreakParent, *ContinueParent;

   /// BlockParent - This is a direct link to the immediately containing
   /// BlockScope if this scope is not one, or null if there is none.
   Scope *BlockParent;

   /// TemplateParamParent - This is a direct link to the
   /// immediately containing template parameter scope. In the
   /// case of nested templates, template parameter scopes can have
   /// other template parameter scopes as parents.
   Scope *TemplateParamParent;

   /// DeclScopeParent - This is a direct link to the immediately containing
   /// DeclScope, i.e. scope which can contain declarations.
   Scope *DeclParent;

   /// DeclsInScope - This keeps track of all declarations in this scope.  When
   /// the declaration is added to the scope, it is set as the current
   /// declaration for the identifier in the IdentifierTable.  When the scope is
   /// popped, these declarations are removed from the IdentifierTable's notion
   /// of current declaration.  It is up to the current Action implementation to
   /// implement these semantics.
   using DeclSetTy = llvm::SmallPtrSet<Decl *, 32>;
   DeclSetTy DeclsInScope;

   /// The DeclContext with which this scope is associated. For
   /// example, the entity of a class scope is the class itself, the
   /// entity of a function scope is a function, etc.
   DeclContext *Entity;

   using UsingDirectivesTy = SmallVector<UsingDirectiveDecl *, 2>;
   UsingDirectivesTy UsingDirectives;

   /// Used to determine if errors occurred in this scope.
   DiagnosticErrorTrap ErrorTrap;

   /// A single NRVO candidate variable in this scope.
   /// There are three possible values:
   ///  1) pointer to VarDecl that denotes NRVO candidate itself.
   ///  2) nullptr value means that NRVO is not allowed in this scope
   ///     (e.g. return a function parameter).
   ///  3) std::nullopt value means that there is no NRVO candidate in this scope
   ///     (i.e. there are no return statements in this scope).
   std::optional<VarDecl *> NRVO;

   /// Represents return slots for NRVO candidates in the current scope.
   /// If a variable is present in this set, it means that a return slot is
   /// available for this variable in the current scope.
   llvm::SmallPtrSet<VarDecl *, 8> ReturnSlots;

   void setFlags(Scope *Parent, unsigned F);

 public:
   Scope(Scope *Parent, unsigned ScopeFlags, DiagnosticsEngine &Diag)
       : ErrorTrap(Diag) {
     Init(Parent, ScopeFlags);
   }

   /// getFlags - Return the flags for this scope.
   unsigned getFlags() const { return Flags; }

   void setFlags(unsigned F) { setFlags(getParent(), F); }

   /// isBlockScope - Return true if this scope correspond to a closure.
   bool isBlockScope() const { return Flags & BlockScope; }

   /// getParent - Return the scope that this is nested in.
   const Scope *getParent() const { return AnyParent; }
   Scope *getParent() { return AnyParent; }

   /// getFnParent - Return the closest scope that is a function body.
   const Scope *getFnParent() const { return FnParent; }
   Scope *getFnParent() { return FnParent; }

   const Scope *getMSLastManglingParent() const {
     return MSLastManglingParent;
   }
   Scope *getMSLastManglingParent() { return MSLastManglingParent; }

   /// getContinueParent - Return the closest scope that a continue statement
   /// would be affected by.
   Scope *getContinueParent() {
     return ContinueParent;
   }

   const Scope *getContinueParent() const {
     return const_cast<Scope*>(this)->getContinueParent();
   }

   // Set whether we're in the scope of a condition variable, where 'continue'
   // is disallowed despite being a continue scope.
   void setIsConditionVarScope(bool InConditionVarScope) {
     Flags = (Flags & ~ConditionVarScope) |
             (InConditionVarScope ? ConditionVarScope : 0);
   }

   bool isConditionVarScope() const {
     return Flags & ConditionVarScope;
   }

   /// getBreakParent - Return the closest scope that a break statement
   /// would be affected by.
   Scope *getBreakParent() {
     return BreakParent;
   }
   const Scope *getBreakParent() const {
     return const_cast<Scope*>(this)->getBreakParent();
   }

   Scope *getBlockParent() { return BlockParent; }
   const Scope *getBlockParent() const { return BlockParent; }

   Scope *getTemplateParamParent() { return TemplateParamParent; }
   const Scope *getTemplateParamParent() const { return TemplateParamParent; }

   Scope *getDeclParent() { return DeclParent; }
   const Scope *getDeclParent() const { return DeclParent; }

   /// Returns the depth of this scope. The translation-unit has scope depth 0.
   unsigned getDepth() const { return Depth; }

   /// Returns the number of function prototype scopes in this scope
   /// chain.
   unsigned getFunctionPrototypeDepth() const {
     return PrototypeDepth;
   }

   /// Return the number of parameters declared in this function
   /// prototype, increasing it by one for the next call.
   unsigned getNextFunctionPrototypeIndex() {
     assert(isFunctionPrototypeScope());
     return PrototypeIndex++;
   }

   using decl_range = llvm::iterator_range<DeclSetTy::iterator>;

   decl_range decls() const {
     return decl_range(DeclsInScope.begin(), DeclsInScope.end());
   }

   bool decl_empty() const { return DeclsInScope.empty(); }

   void AddDecl(Decl *D) {
     if (auto *VD = dyn_cast<VarDecl>(D))
       if (!isa<ParmVarDecl>(VD))
         ReturnSlots.insert(VD);

     DeclsInScope.insert(D);
   }

   void RemoveDecl(Decl *D) { DeclsInScope.erase(D); }

   void incrementMSManglingNumber() {
     if (Scope *MSLMP = getMSLastManglingParent()) {
       MSLMP->MSLastManglingNumber += 1;
       MSCurManglingNumber += 1;
     }
   }

   void decrementMSManglingNumber() {
     if (Scope *MSLMP = getMSLastManglingParent()) {
       MSLMP->MSLastManglingNumber -= 1;
       MSCurManglingNumber -= 1;
     }
   }

   unsigned getMSLastManglingNumber() const {
     if (const Scope *MSLMP = getMSLastManglingParent())
       return MSLMP->MSLastManglingNumber;
     return 1;
   }

   unsigned getMSCurManglingNumber() const {
     return MSCurManglingNumber;
   }

   /// isDeclScope - Return true if this is the scope that the specified decl is
   /// declared in.
   bool isDeclScope(const Decl *D) const { return DeclsInScope.contains(D); }

   /// Get the entity corresponding to this scope.
   DeclContext *getEntity() const {
     return isTemplateParamScope() ? nullptr : Entity;
   }

   /// Get the DeclContext in which to continue unqualified lookup after a
   /// lookup in this scope.
   DeclContext *getLookupEntity() const { return Entity; }

   void setEntity(DeclContext *E) {
     assert(!isTemplateParamScope() &&
            "entity associated with template param scope");
     Entity = E;
   }
   void setLookupEntity(DeclContext *E) { Entity = E; }

   /// Determine whether any unrecoverable errors have occurred within this
   /// scope. Note that this may return false even if the scope contains invalid
   /// declarations or statements, if the errors for those invalid constructs
   /// were suppressed because some prior invalid construct was referenced.
   bool hasUnrecoverableErrorOccurred() const {
     return ErrorTrap.hasUnrecoverableErrorOccurred();
   }

   /// isFunctionScope() - Return true if this scope is a function scope.
   bool isFunctionScope() const { return getFlags() & Scope::FnScope; }

   /// isClassScope - Return true if this scope is a class/struct/union scope.
   bool isClassScope() const { return getFlags() & Scope::ClassScope; }

   /// Determines whether this scope is between inheritance colon and the real
   /// class/struct definition.
   bool isClassInheritanceScope() const {
     return getFlags() & Scope::ClassInheritanceScope;
   }

   /// isInCXXInlineMethodScope - Return true if this scope is a C++ inline
   /// method scope or is inside one.
   bool isInCXXInlineMethodScope() const {
     if (const Scope *FnS = getFnParent()) {
       assert(FnS->getParent() && "TUScope not created?");
       return FnS->getParent()->isClassScope();
     }
     return false;
   }

   /// isInObjcMethodScope - Return true if this scope is, or is contained in, an
   /// Objective-C method body.  Note that this method is not constant time.
   bool isInObjcMethodScope() const {
     for (const Scope *S = this; S; S = S->getParent()) {
       // If this scope is an objc method scope, then we succeed.
       if (S->getFlags() & ObjCMethodScope)
         return true;
     }
     return false;
   }

   /// isInObjcMethodOuterScope - Return true if this scope is an
   /// Objective-C method outer most body.
   bool isInObjcMethodOuterScope() const {
     if (const Scope *S = this) {
       // If this scope is an objc method scope, then we succeed.
       if (S->getFlags() & ObjCMethodScope)
         return true;
     }
     return false;
   }

   /// isTemplateParamScope - Return true if this scope is a C++
   /// template parameter scope.
   bool isTemplateParamScope() const {
     return getFlags() & Scope::TemplateParamScope;
   }

   /// isFunctionPrototypeScope - Return true if this scope is a
   /// function prototype scope.
   bool isFunctionPrototypeScope() const {
     return getFlags() & Scope::FunctionPrototypeScope;
   }

   /// isFunctionDeclarationScope - Return true if this scope is a
   /// function prototype scope.
   bool isFunctionDeclarationScope() const {
     return getFlags() & Scope::FunctionDeclarationScope;
   }

   /// isAtCatchScope - Return true if this scope is \@catch.
   bool isAtCatchScope() const {
     return getFlags() & Scope::AtCatchScope;
   }

   /// isCatchScope - Return true if this scope is a C++ catch statement.
   bool isCatchScope() const { return getFlags() & Scope::CatchScope; }

   /// isSwitchScope - Return true if this scope is a switch scope.
   bool isSwitchScope() const {
     for (const Scope *S = this; S; S = S->getParent()) {
       if (S->getFlags() & Scope::SwitchScope)
         return true;
       else if (S->getFlags() & (Scope::FnScope | Scope::ClassScope |
                                 Scope::BlockScope | Scope::TemplateParamScope |
                                 Scope::FunctionPrototypeScope |
                                 Scope::AtCatchScope | Scope::ObjCMethodScope))
         return false;
     }
     return false;
   }

   /// Return true if this scope is a loop.
   bool isLoopScope() const {
     // 'switch' is the only loop that is not a 'break' scope as well, so we can
     // just check BreakScope and not SwitchScope.
     return (getFlags() & Scope::BreakScope) &&
            !(getFlags() & Scope::SwitchScope);
   }

   /// Determines whether this scope is the OpenMP directive scope
   bool isOpenMPDirectiveScope() const {
     return (getFlags() & Scope::OpenMPDirectiveScope);
   }

   /// Determine whether this scope is some OpenMP loop directive scope
   /// (for example, 'omp for', 'omp simd').
   bool isOpenMPLoopDirectiveScope() const {
     if (getFlags() & Scope::OpenMPLoopDirectiveScope) {
       assert(isOpenMPDirectiveScope() &&
              "OpenMP loop directive scope is not a directive scope");
       return true;
     }
     return false;
   }

   /// Determine whether this scope is (or is nested into) some OpenMP
   /// loop simd directive scope (for example, 'omp simd', 'omp for simd').
   bool isOpenMPSimdDirectiveScope() const {
     return getFlags() & Scope::OpenMPSimdDirectiveScope;
   }

   /// Determine whether this scope is a loop having OpenMP loop
   /// directive attached.
   bool isOpenMPLoopScope() const {
     const Scope *P = getParent();
     return P && P->isOpenMPLoopDirectiveScope();
   }

   /// Determine whether this scope is some OpenMP directive with
   /// order clause which specifies concurrent scope.
   bool isOpenMPOrderClauseScope() const {
     return getFlags() & Scope::OpenMPOrderClauseScope;
   }

   /// Determine whether this scope is the statement associated with an OpenACC
   /// Compute construct directive.
   bool isOpenACCComputeConstructScope() const {
     return getFlags() & Scope::OpenACCComputeConstructScope;
   }

   /// Determine if this scope (or its parents) are a compute construct. If the
   /// argument is provided, the search will stop at any of the specified scopes.
   /// Otherwise, it will stop only at the normal 'no longer search' scopes.
   bool isInOpenACCComputeConstructScope(ScopeFlags Flags = NoScope) const {
     for (const Scope *S = this; S; S = S->getParent()) {
       if (S->isOpenACCComputeConstructScope())
         return true;

       if (S->getFlags() & Flags)
         return false;

       else if (S->getFlags() &
                (Scope::FnScope | Scope::ClassScope | Scope::BlockScope |
                 Scope::TemplateParamScope | Scope::FunctionPrototypeScope |
                 Scope::AtCatchScope | Scope::ObjCMethodScope))
         return false;
     }
     return false;
   }

   /// Determine whether this scope is a while/do/for statement, which can have
   /// continue statements embedded into it.
   bool isContinueScope() const {
     return getFlags() & ScopeFlags::ContinueScope;
   }

   /// Determine whether this scope is a C++ 'try' block.
   bool isTryScope() const { return getFlags() & Scope::TryScope; }

   /// Determine whether this scope is a function-level C++ try or catch scope.
   bool isFnTryCatchScope() const {
     return getFlags() & ScopeFlags::FnTryCatchScope;
   }

   /// Determine whether this scope is a SEH '__try' block.
   bool isSEHTryScope() const { return getFlags() & Scope::SEHTryScope; }

   /// Determine whether this scope is a SEH '__except' block.
   bool isSEHExceptScope() const { return getFlags() & Scope::SEHExceptScope; }

   /// Determine whether this scope is a compound statement scope.
   bool isCompoundStmtScope() const {
     return getFlags() & Scope::CompoundStmtScope;
   }

   /// Determine whether this scope is a controlling scope in a
   /// if/switch/while/for statement.
   bool isControlScope() const { return getFlags() & Scope::ControlScope; }

   /// Determine whether this scope is a type alias scope.
   bool isTypeAliasScope() const { return getFlags() & Scope::TypeAliasScope; }

   /// Returns if rhs has a higher scope depth than this.
   ///
   /// The caller is responsible for calling this only if one of the two scopes
   /// is an ancestor of the other.
   bool Contains(const Scope& rhs) const { return Depth < rhs.Depth; }

   /// containedInPrototypeScope - Return true if this or a parent scope
   /// is a FunctionPrototypeScope.
   bool containedInPrototypeScope() const;

   void PushUsingDirective(UsingDirectiveDecl *UDir) {
     UsingDirectives.push_back(UDir);
   }

   using using_directives_range =
       llvm::iterator_range<UsingDirectivesTy::iterator>;

   using_directives_range using_directives() {
     return using_directives_range(UsingDirectives.begin(),
                                   UsingDirectives.end());
   }

   void updateNRVOCandidate(VarDecl *VD);

   void applyNRVO();

   /// Init - This is used by the parser to implement scope caching.
   void Init(Scope *parent, unsigned flags);

   /// Sets up the specified scope flags and adjusts the scope state
   /// variables accordingly.
   void AddFlags(unsigned Flags);

   void dumpImpl(raw_ostream &OS) const;
   void dump() const;
 };

 } // namespace clang

 #endif // LLVM_CLANG_SEMA_SCOPE_H
	//===- Scope.h - Scope interface --------------------------------- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file defines the Scope interface.
	//
	//===----------------------------------------------------------------------===//

	#ifndef LLVM_CLANG_SEMA_SCOPE_H
	#define LLVM_CLANG_SEMA_SCOPE_H

	#include "clang/AST/Decl.h"
	#include "clang/Basic/Diagnostic.h"
	#include "llvm/ADT/PointerIntPair.h"
	#include "llvm/ADT/SmallPtrSet.h"
	#include "llvm/ADT/SmallVector.h"
	#include "llvm/ADT/iterator_range.h"
	#include <cassert>
	#include <optional>

	namespace llvm {

	class raw_ostream;

	} // namespace llvm

	namespace clang {

	class Decl;
	class DeclContext;
	class UsingDirectiveDecl;
	class VarDecl;

	/// Scope - A scope is a transient data structure that is used while parsing the
	/// program. It assists with resolving identifiers to the appropriate
	/// declaration.
	class Scope {
	public:
	/// ScopeFlags - These are bitfields that are or'd together when creating a
	/// scope, which defines the sorts of things the scope contains.
	enum ScopeFlags {
	// A bitfield value representing no scopes.
	NoScope = 0,

	/// This indicates that the scope corresponds to a function, which
	/// means that labels are set here.
	FnScope = 0x01,

	/// This is a while, do, switch, for, etc that can have break
	/// statements embedded into it.
	BreakScope = 0x02,

	/// This is a while, do, for, which can have continue statements
	/// embedded into it.
	ContinueScope = 0x04,

	/// This is a scope that can contain a declaration. Some scopes
	/// just contain loop constructs but don't contain decls.
	DeclScope = 0x08,

	/// The controlling scope in a if/switch/while/for statement.
	ControlScope = 0x10,

	/// The scope of a struct/union/class definition.
	ClassScope = 0x20,

	/// This is a scope that corresponds to a block/closure object.
	/// Blocks serve as top-level scopes for some objects like labels, they
	/// also prevent things like break and continue. BlockScopes always have
	/// the FnScope and DeclScope flags set as well.
	BlockScope = 0x40,

	/// This is a scope that corresponds to the
	/// template parameters of a C++ template. Template parameter
	/// scope starts at the 'template' keyword and ends when the
	/// template declaration ends.
	TemplateParamScope = 0x80,

	/// This is a scope that corresponds to the
	/// parameters within a function prototype.
	FunctionPrototypeScope = 0x100,

	/// This is a scope that corresponds to the parameters within
	/// a function prototype for a function declaration (as opposed to any
	/// other kind of function declarator). Always has FunctionPrototypeScope
	/// set as well.
	FunctionDeclarationScope = 0x200,

	/// This is a scope that corresponds to the Objective-C
	/// \@catch statement.
	AtCatchScope = 0x400,

	/// This scope corresponds to an Objective-C method body.
	/// It always has FnScope and DeclScope set as well.
	ObjCMethodScope = 0x800,

	/// This is a scope that corresponds to a switch statement.
	SwitchScope = 0x1000,

	/// This is the scope of a C++ try statement.
	TryScope = 0x2000,

	/// This is the scope for a function-level C++ try or catch scope.
	FnTryCatchScope = 0x4000,

	/// This is the scope of OpenMP executable directive.
	OpenMPDirectiveScope = 0x8000,

	/// This is the scope of some OpenMP loop directive.
	OpenMPLoopDirectiveScope = 0x10000,

	/// This is the scope of some OpenMP simd directive.
	/// For example, it is used for 'omp simd', 'omp for simd'.
	/// This flag is propagated to children scopes.
	OpenMPSimdDirectiveScope = 0x20000,

	/// This scope corresponds to an enum.
	EnumScope = 0x40000,

	/// This scope corresponds to an SEH try.
	SEHTryScope = 0x80000,

	/// This scope corresponds to an SEH except.
	SEHExceptScope = 0x100000,

	/// We are currently in the filter expression of an SEH except block.
	SEHFilterScope = 0x200000,

	/// This is a compound statement scope.
	CompoundStmtScope = 0x400000,

	/// We are between inheritance colon and the real class/struct definition
	/// scope.
	ClassInheritanceScope = 0x800000,

	/// This is the scope of a C++ catch statement.
	CatchScope = 0x1000000,

	/// This is a scope in which a condition variable is currently being
	/// parsed. If such a scope is a ContinueScope, it's invalid to jump to the
	/// continue block from here.
	ConditionVarScope = 0x2000000,

	/// This is a scope of some OpenMP directive with
	/// order clause which specifies concurrent
	OpenMPOrderClauseScope = 0x4000000,
	/// This is the scope for a lambda, after the lambda introducer.
	/// Lambdas need two FunctionPrototypeScope scopes (because there is a
	/// template scope in between), the outer scope does not increase the
	/// depth of recursion.
	LambdaScope = 0x8000000,
	/// This is the scope of an OpenACC Compute Construct, which restricts
	/// jumping into/out of it.
	OpenACCComputeConstructScope = 0x10000000,

	/// This is a scope of type alias declaration.
	TypeAliasScope = 0x20000000,
	};

	private:
	/// The parent scope for this scope. This is null for the translation-unit
	/// scope.
	Scope *AnyParent;

	/// Flags - This contains a set of ScopeFlags, which indicates how the scope
	/// interrelates with other control flow statements.
	unsigned Flags;

	/// Depth - This is the depth of this scope. The translation-unit scope has
	/// depth 0.
	unsigned short Depth;

	/// Declarations with static linkage are mangled with the number of
	/// scopes seen as a component.
	unsigned short MSLastManglingNumber;

	unsigned short MSCurManglingNumber;

	/// PrototypeDepth - This is the number of function prototype scopes
	/// enclosing this scope, including this scope.
	unsigned short PrototypeDepth;

	/// PrototypeIndex - This is the number of parameters currently
	/// declared in this scope.
	unsigned short PrototypeIndex;

	/// FnParent - If this scope has a parent scope that is a function body, this
	/// pointer is non-null and points to it. This is used for label processing.
	Scope *FnParent;
	Scope *MSLastManglingParent;

	/// BreakParent/ContinueParent - This is a direct link to the innermost
	/// BreakScope/ContinueScope which contains the contents of this scope
	/// for control flow purposes (and might be this scope itself), or null
	/// if there is no such scope.
	Scope BreakParent, ContinueParent;

	/// BlockParent - This is a direct link to the immediately containing
	/// BlockScope if this scope is not one, or null if there is none.
	Scope *BlockParent;

	/// TemplateParamParent - This is a direct link to the
	/// immediately containing template parameter scope. In the
	/// case of nested templates, template parameter scopes can have
	/// other template parameter scopes as parents.
	Scope *TemplateParamParent;

	/// DeclScopeParent - This is a direct link to the immediately containing
	/// DeclScope, i.e. scope which can contain declarations.
	Scope *DeclParent;

	/// DeclsInScope - This keeps track of all declarations in this scope. When
	/// the declaration is added to the scope, it is set as the current
	/// declaration for the identifier in the IdentifierTable. When the scope is
	/// popped, these declarations are removed from the IdentifierTable's notion
	/// of current declaration. It is up to the current Action implementation to
	/// implement these semantics.
	using DeclSetTy = llvm::SmallPtrSet<Decl *, 32>;
	DeclSetTy DeclsInScope;

	/// The DeclContext with which this scope is associated. For
	/// example, the entity of a class scope is the class itself, the
	/// entity of a function scope is a function, etc.
	DeclContext *Entity;

	using UsingDirectivesTy = SmallVector<UsingDirectiveDecl *, 2>;
	UsingDirectivesTy UsingDirectives;

	/// Used to determine if errors occurred in this scope.
	DiagnosticErrorTrap ErrorTrap;

	/// A single NRVO candidate variable in this scope.
	/// There are three possible values:
	/// 1) pointer to VarDecl that denotes NRVO candidate itself.
	/// 2) nullptr value means that NRVO is not allowed in this scope
	/// (e.g. return a function parameter).
	/// 3) std::nullopt value means that there is no NRVO candidate in this scope
	/// (i.e. there are no return statements in this scope).
	std::optional<VarDecl *> NRVO;

	/// Represents return slots for NRVO candidates in the current scope.
	/// If a variable is present in this set, it means that a return slot is
	/// available for this variable in the current scope.
	llvm::SmallPtrSet<VarDecl *, 8> ReturnSlots;

	void setFlags(Scope *Parent, unsigned F);

	public:
	Scope(Scope *Parent, unsigned ScopeFlags, DiagnosticsEngine &Diag)
	: ErrorTrap(Diag) {
	Init(Parent, ScopeFlags);
	}

	/// getFlags - Return the flags for this scope.
	unsigned getFlags() const { return Flags; }

	void setFlags(unsigned F) { setFlags(getParent(), F); }

	/// isBlockScope - Return true if this scope correspond to a closure.
	bool isBlockScope() const { return Flags & BlockScope; }

	/// getParent - Return the scope that this is nested in.
	const Scope *getParent() const { return AnyParent; }
	Scope *getParent() { return AnyParent; }

	/// getFnParent - Return the closest scope that is a function body.
	const Scope *getFnParent() const { return FnParent; }
	Scope *getFnParent() { return FnParent; }

	const Scope *getMSLastManglingParent() const {
	return MSLastManglingParent;
	}
	Scope *getMSLastManglingParent() { return MSLastManglingParent; }

	/// getContinueParent - Return the closest scope that a continue statement
	/// would be affected by.
	Scope *getContinueParent() {
	return ContinueParent;
	}

	const Scope *getContinueParent() const {
	return const_cast<Scope*>(this)->getContinueParent();
	}

	// Set whether we're in the scope of a condition variable, where 'continue'
	// is disallowed despite being a continue scope.
	void setIsConditionVarScope(bool InConditionVarScope) {
	Flags = (Flags & ~ConditionVarScope) \|
	(InConditionVarScope ? ConditionVarScope : 0);
	}

	bool isConditionVarScope() const {
	return Flags & ConditionVarScope;
	}

	/// getBreakParent - Return the closest scope that a break statement
	/// would be affected by.
	Scope *getBreakParent() {
	return BreakParent;
	}
	const Scope *getBreakParent() const {
	return const_cast<Scope*>(this)->getBreakParent();
	}

	Scope *getBlockParent() { return BlockParent; }
	const Scope *getBlockParent() const { return BlockParent; }

	Scope *getTemplateParamParent() { return TemplateParamParent; }
	const Scope *getTemplateParamParent() const { return TemplateParamParent; }

	Scope *getDeclParent() { return DeclParent; }
	const Scope *getDeclParent() const { return DeclParent; }

	/// Returns the depth of this scope. The translation-unit has scope depth 0.
	unsigned getDepth() const { return Depth; }

	/// Returns the number of function prototype scopes in this scope
	/// chain.
	unsigned getFunctionPrototypeDepth() const {
	return PrototypeDepth;
	}

	/// Return the number of parameters declared in this function
	/// prototype, increasing it by one for the next call.
	unsigned getNextFunctionPrototypeIndex() {
	assert(isFunctionPrototypeScope());
	return PrototypeIndex++;
	}

	using decl_range = llvm::iterator_range<DeclSetTy::iterator>;

	decl_range decls() const {
	return decl_range(DeclsInScope.begin(), DeclsInScope.end());
	}

	bool decl_empty() const { return DeclsInScope.empty(); }

	void AddDecl(Decl *D) {
	if (auto *VD = dyn_cast<VarDecl>(D))
	if (!isa<ParmVarDecl>(VD))
	ReturnSlots.insert(VD);

	DeclsInScope.insert(D);
	}

	void RemoveDecl(Decl *D) { DeclsInScope.erase(D); }

	void incrementMSManglingNumber() {
	if (Scope *MSLMP = getMSLastManglingParent()) {
	MSLMP->MSLastManglingNumber += 1;
	MSCurManglingNumber += 1;
	}
	}

	void decrementMSManglingNumber() {
	if (Scope *MSLMP = getMSLastManglingParent()) {
	MSLMP->MSLastManglingNumber -= 1;
	MSCurManglingNumber -= 1;
	}
	}

	unsigned getMSLastManglingNumber() const {
	if (const Scope *MSLMP = getMSLastManglingParent())
	return MSLMP->MSLastManglingNumber;
	return 1;
	}

	unsigned getMSCurManglingNumber() const {
	return MSCurManglingNumber;
	}

	/// isDeclScope - Return true if this is the scope that the specified decl is
	/// declared in.
	bool isDeclScope(const Decl *D) const { return DeclsInScope.contains(D); }

	/// Get the entity corresponding to this scope.
	DeclContext *getEntity() const {
	return isTemplateParamScope() ? nullptr : Entity;
	}

	/// Get the DeclContext in which to continue unqualified lookup after a
	/// lookup in this scope.
	DeclContext *getLookupEntity() const { return Entity; }

	void setEntity(DeclContext *E) {
	assert(!isTemplateParamScope() &&
	"entity associated with template param scope");
	Entity = E;
	}
	void setLookupEntity(DeclContext *E) { Entity = E; }

	/// Determine whether any unrecoverable errors have occurred within this
	/// scope. Note that this may return false even if the scope contains invalid
	/// declarations or statements, if the errors for those invalid constructs
	/// were suppressed because some prior invalid construct was referenced.
	bool hasUnrecoverableErrorOccurred() const {
	return ErrorTrap.hasUnrecoverableErrorOccurred();
	}

	/// isFunctionScope() - Return true if this scope is a function scope.
	bool isFunctionScope() const { return getFlags() & Scope::FnScope; }

	/// isClassScope - Return true if this scope is a class/struct/union scope.
	bool isClassScope() const { return getFlags() & Scope::ClassScope; }

	/// Determines whether this scope is between inheritance colon and the real
	/// class/struct definition.
	bool isClassInheritanceScope() const {
	return getFlags() & Scope::ClassInheritanceScope;
	}

	/// isInCXXInlineMethodScope - Return true if this scope is a C++ inline
	/// method scope or is inside one.
	bool isInCXXInlineMethodScope() const {
	if (const Scope *FnS = getFnParent()) {
	assert(FnS->getParent() && "TUScope not created?");
	return FnS->getParent()->isClassScope();
	}
	return false;
	}

	/// isInObjcMethodScope - Return true if this scope is, or is contained in, an
	/// Objective-C method body. Note that this method is not constant time.
	bool isInObjcMethodScope() const {
	for (const Scope *S = this; S; S = S->getParent()) {
	// If this scope is an objc method scope, then we succeed.
	if (S->getFlags() & ObjCMethodScope)
	return true;
	}
	return false;
	}

	/// isInObjcMethodOuterScope - Return true if this scope is an
	/// Objective-C method outer most body.
	bool isInObjcMethodOuterScope() const {
	if (const Scope *S = this) {
	// If this scope is an objc method scope, then we succeed.
	if (S->getFlags() & ObjCMethodScope)
	return true;
	}
	return false;
	}

	/// isTemplateParamScope - Return true if this scope is a C++
	/// template parameter scope.
	bool isTemplateParamScope() const {
	return getFlags() & Scope::TemplateParamScope;
	}

	/// isFunctionPrototypeScope - Return true if this scope is a
	/// function prototype scope.
	bool isFunctionPrototypeScope() const {
	return getFlags() & Scope::FunctionPrototypeScope;
	}

	/// isFunctionDeclarationScope - Return true if this scope is a
	/// function prototype scope.
	bool isFunctionDeclarationScope() const {
	return getFlags() & Scope::FunctionDeclarationScope;
	}

	/// isAtCatchScope - Return true if this scope is \@catch.
	bool isAtCatchScope() const {
	return getFlags() & Scope::AtCatchScope;
	}

	/// isCatchScope - Return true if this scope is a C++ catch statement.
	bool isCatchScope() const { return getFlags() & Scope::CatchScope; }

	/// isSwitchScope - Return true if this scope is a switch scope.
	bool isSwitchScope() const {
	for (const Scope *S = this; S; S = S->getParent()) {
	if (S->getFlags() & Scope::SwitchScope)
	return true;
	else if (S->getFlags() & (Scope::FnScope \| Scope::ClassScope \|
	Scope::BlockScope \| Scope::TemplateParamScope \|
	Scope::FunctionPrototypeScope \|
	Scope::AtCatchScope \| Scope::ObjCMethodScope))
	return false;
	}
	return false;
	}

	/// Return true if this scope is a loop.
	bool isLoopScope() const {
	// 'switch' is the only loop that is not a 'break' scope as well, so we can
	// just check BreakScope and not SwitchScope.
	return (getFlags() & Scope::BreakScope) &&
	!(getFlags() & Scope::SwitchScope);
	}

	/// Determines whether this scope is the OpenMP directive scope
	bool isOpenMPDirectiveScope() const {
	return (getFlags() & Scope::OpenMPDirectiveScope);
	}

	/// Determine whether this scope is some OpenMP loop directive scope
	/// (for example, 'omp for', 'omp simd').
	bool isOpenMPLoopDirectiveScope() const {
	if (getFlags() & Scope::OpenMPLoopDirectiveScope) {
	assert(isOpenMPDirectiveScope() &&
	"OpenMP loop directive scope is not a directive scope");
	return true;
	}
	return false;
	}

	/// Determine whether this scope is (or is nested into) some OpenMP
	/// loop simd directive scope (for example, 'omp simd', 'omp for simd').
	bool isOpenMPSimdDirectiveScope() const {
	return getFlags() & Scope::OpenMPSimdDirectiveScope;
	}

	/// Determine whether this scope is a loop having OpenMP loop
	/// directive attached.
	bool isOpenMPLoopScope() const {
	const Scope *P = getParent();
	return P && P->isOpenMPLoopDirectiveScope();
	}

	/// Determine whether this scope is some OpenMP directive with
	/// order clause which specifies concurrent scope.
	bool isOpenMPOrderClauseScope() const {
	return getFlags() & Scope::OpenMPOrderClauseScope;
	}

	/// Determine whether this scope is the statement associated with an OpenACC
	/// Compute construct directive.
	bool isOpenACCComputeConstructScope() const {
	return getFlags() & Scope::OpenACCComputeConstructScope;
	}

	/// Determine if this scope (or its parents) are a compute construct. If the
	/// argument is provided, the search will stop at any of the specified scopes.
	/// Otherwise, it will stop only at the normal 'no longer search' scopes.
	bool isInOpenACCComputeConstructScope(ScopeFlags Flags = NoScope) const {
	for (const Scope *S = this; S; S = S->getParent()) {
	if (S->isOpenACCComputeConstructScope())
	return true;

	if (S->getFlags() & Flags)
	return false;

	else if (S->getFlags() &
	(Scope::FnScope \| Scope::ClassScope \| Scope::BlockScope \|
	Scope::TemplateParamScope \| Scope::FunctionPrototypeScope \|
	Scope::AtCatchScope \| Scope::ObjCMethodScope))
	return false;
	}
	return false;
	}

	/// Determine whether this scope is a while/do/for statement, which can have
	/// continue statements embedded into it.
	bool isContinueScope() const {
	return getFlags() & ScopeFlags::ContinueScope;
	}

	/// Determine whether this scope is a C++ 'try' block.
	bool isTryScope() const { return getFlags() & Scope::TryScope; }

	/// Determine whether this scope is a function-level C++ try or catch scope.
	bool isFnTryCatchScope() const {
	return getFlags() & ScopeFlags::FnTryCatchScope;
	}

	/// Determine whether this scope is a SEH '__try' block.
	bool isSEHTryScope() const { return getFlags() & Scope::SEHTryScope; }

	/// Determine whether this scope is a SEH '__except' block.
	bool isSEHExceptScope() const { return getFlags() & Scope::SEHExceptScope; }

	/// Determine whether this scope is a compound statement scope.
	bool isCompoundStmtScope() const {
	return getFlags() & Scope::CompoundStmtScope;
	}

	/// Determine whether this scope is a controlling scope in a
	/// if/switch/while/for statement.
	bool isControlScope() const { return getFlags() & Scope::ControlScope; }

	/// Determine whether this scope is a type alias scope.
	bool isTypeAliasScope() const { return getFlags() & Scope::TypeAliasScope; }

	/// Returns if rhs has a higher scope depth than this.
	///
	/// The caller is responsible for calling this only if one of the two scopes
	/// is an ancestor of the other.
	bool Contains(const Scope& rhs) const { return Depth < rhs.Depth; }

	/// containedInPrototypeScope - Return true if this or a parent scope
	/// is a FunctionPrototypeScope.
	bool containedInPrototypeScope() const;

	void PushUsingDirective(UsingDirectiveDecl *UDir) {
	UsingDirectives.push_back(UDir);
	}

	using using_directives_range =
	llvm::iterator_range<UsingDirectivesTy::iterator>;

	using_directives_range using_directives() {
	return using_directives_range(UsingDirectives.begin(),
	UsingDirectives.end());
	}

	void updateNRVOCandidate(VarDecl *VD);

	void applyNRVO();

	/// Init - This is used by the parser to implement scope caching.
	void Init(Scope *parent, unsigned flags);

	/// Sets up the specified scope flags and adjusts the scope state
	/// variables accordingly.
	void AddFlags(unsigned Flags);

	void dumpImpl(raw_ostream &OS) const;
	void dump() const;
	};

	} // namespace clang

	#endif // LLVM_CLANG_SEMA_SCOPE_H