Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===--- Sema.h - Semantic Analysis & AST Building --------------*- 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 Sema class, which performs semantic analysis and

// builds ASTs.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_SEMA_SEMA_H

#define LLVM_CLANG_SEMA_SEMA_H

#include "clang/AST/ASTConcept.h"

#include "clang/AST/ASTFwd.h"

#include "clang/AST/Attr.h"

#include "clang/AST/Availability.h"

#include "clang/AST/ComparisonCategories.h"

#include "clang/AST/DeclTemplate.h"

#include "clang/AST/DeclarationName.h"

#include "clang/AST/Expr.h"

#include "clang/AST/ExprCXX.h"

#include "clang/AST/ExprConcepts.h"

#include "clang/AST/ExprObjC.h"

#include "clang/AST/ExprOpenMP.h"

#include "clang/AST/ExternalASTSource.h"

#include "clang/AST/LocInfoType.h"

#include "clang/AST/MangleNumberingContext.h"

#include "clang/AST/NSAPI.h"

#include "clang/AST/PrettyPrinter.h"

#include "clang/AST/StmtCXX.h"

#include "clang/AST/StmtOpenMP.h"

#include "clang/AST/TypeLoc.h"

#include "clang/AST/TypeOrdering.h"

#include "clang/Basic/BitmaskEnum.h"

#include "clang/Basic/Builtins.h"

#include "clang/Basic/DarwinSDKInfo.h"

#include "clang/Basic/ExpressionTraits.h"

#include "clang/Basic/Module.h"

#include "clang/Basic/OpenCLOptions.h"

#include "clang/Basic/OpenMPKinds.h"

#include "clang/Basic/PragmaKinds.h"

#include "clang/Basic/Specifiers.h"

#include "clang/Basic/TemplateKinds.h"

#include "clang/Basic/TypeTraits.h"

#include "clang/Sema/AnalysisBasedWarnings.h"

#include "clang/Sema/CleanupInfo.h"

#include "clang/Sema/DeclSpec.h"

#include "clang/Sema/ExternalSemaSource.h"

#include "clang/Sema/IdentifierResolver.h"

#include "clang/Sema/ObjCMethodList.h"

#include "clang/Sema/Ownership.h"

#include "clang/Sema/Scope.h"

#include "clang/Sema/SemaConcept.h"

#include "clang/Sema/TypoCorrection.h"

#include "clang/Sema/Weak.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/SetVector.h"

#include "llvm/ADT/SmallBitVector.h"

#include "llvm/ADT/SmallPtrSet.h"

#include "llvm/ADT/SmallSet.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/TinyPtrVector.h"

#include "llvm/Frontend/OpenMP/OMPConstants.h"

#include <deque>

#include <memory>

#include <optional>

#include <string>

#include <tuple>

#include <vector>

namespace llvm {

  class APSInt;

  template <typename ValueT, typename ValueInfoT> class DenseSet;

  class SmallBitVector;

  struct InlineAsmIdentifierInfo;

}

namespace clang {

  class ADLResult;

  class ASTConsumer;

  class ASTContext;

  class ASTMutationListener;

  class ASTReader;

  class ASTWriter;

  class ArrayType;

  class ParsedAttr;

  class BindingDecl;

  class BlockDecl;

  class CapturedDecl;

  class CXXBasePath;

  class CXXBasePaths;

  class CXXBindTemporaryExpr;

  typedef SmallVector<CXXBaseSpecifier*, 4> CXXCastPath;

  class CXXConstructorDecl;

  class CXXConversionDecl;

  class CXXDeleteExpr;

  class CXXDestructorDecl;

  class CXXFieldCollector;

  class CXXMemberCallExpr;

  class CXXMethodDecl;

  class CXXScopeSpec;

  class CXXTemporary;

  class CXXTryStmt;

  class CallExpr;

  class ClassTemplateDecl;

  class ClassTemplatePartialSpecializationDecl;

  class ClassTemplateSpecializationDecl;

  class VarTemplatePartialSpecializationDecl;

  class CodeCompleteConsumer;

  class CodeCompletionAllocator;

  class CodeCompletionTUInfo;

  class CodeCompletionResult;

  class CoroutineBodyStmt;

  class Decl;

  class DeclAccessPair;

  class DeclContext;

  class DeclRefExpr;

  class DeclaratorDecl;

  class DeducedTemplateArgument;

  class DependentDiagnostic;

  class DesignatedInitExpr;

  class Designation;

  class EnableIfAttr;

  class EnumConstantDecl;

  class Expr;

  class ExtVectorType;

  class FormatAttr;

  class FriendDecl;

  class FunctionDecl;

  class FunctionProtoType;

  class FunctionTemplateDecl;

  class ImplicitConversionSequence;

  typedef MutableArrayRef<ImplicitConversionSequence> ConversionSequenceList;

  class InitListExpr;

  class InitializationKind;

  class InitializationSequence;

  class InitializedEntity;

  class IntegerLiteral;

  class LabelStmt;

  class LambdaExpr;

  class LangOptions;

  class LocalInstantiationScope;

  class LookupResult;

  class MacroInfo;

  typedef ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> ModuleIdPath;

  class ModuleLoader;

  class MultiLevelTemplateArgumentList;

  class NamedDecl;

  class ObjCCategoryDecl;

  class ObjCCategoryImplDecl;

  class ObjCCompatibleAliasDecl;

  class ObjCContainerDecl;

  class ObjCImplDecl;

  class ObjCImplementationDecl;

  class ObjCInterfaceDecl;

  class ObjCIvarDecl;

  template <class T> class ObjCList;

  class ObjCMessageExpr;

  class ObjCMethodDecl;

  class ObjCPropertyDecl;

  class ObjCProtocolDecl;

  class OMPThreadPrivateDecl;

  class OMPRequiresDecl;

  class OMPDeclareReductionDecl;

  class OMPDeclareSimdDecl;

  class OMPClause;

  struct OMPVarListLocTy;

  struct OverloadCandidate;

  enum class OverloadCandidateParamOrder : char;

  enum OverloadCandidateRewriteKind : unsigned;

  class OverloadCandidateSet;

  class OverloadExpr;

  class ParenListExpr;

  class ParmVarDecl;

  class Preprocessor;

  class PseudoDestructorTypeStorage;

  class PseudoObjectExpr;

  class QualType;

  class StandardConversionSequence;

  class Stmt;

  class StringLiteral;

  class SwitchStmt;

  class TemplateArgument;

  class TemplateArgumentList;

  class TemplateArgumentLoc;

  class TemplateDecl;

  class TemplateInstantiationCallback;

  class TemplateParameterList;

  class TemplatePartialOrderingContext;

  class TemplateTemplateParmDecl;

  class Token;

  class TypeAliasDecl;

  class TypedefDecl;

  class TypedefNameDecl;

  class TypeLoc;

  class TypoCorrectionConsumer;

  class UnqualifiedId;

  class UnresolvedLookupExpr;

  class UnresolvedMemberExpr;

  class UnresolvedSetImpl;

  class UnresolvedSetIterator;

  class UsingDecl;

  class UsingShadowDecl;

  class ValueDecl;

  class VarDecl;

  class VarTemplateSpecializationDecl;

  class VisibilityAttr;

  class VisibleDeclConsumer;

  class IndirectFieldDecl;

  struct DeductionFailureInfo;

  class TemplateSpecCandidateSet;

namespace sema {

  class AccessedEntity;

  class BlockScopeInfo;

  class Capture;

  class CapturedRegionScopeInfo;

  class CapturingScopeInfo;

  class CompoundScopeInfo;

  class DelayedDiagnostic;

  class DelayedDiagnosticPool;

  class FunctionScopeInfo;

  class LambdaScopeInfo;

  class PossiblyUnreachableDiag;

  class RISCVIntrinsicManager;

  class SemaPPCallbacks;

  class TemplateDeductionInfo;

}

namespace threadSafety {

  class BeforeSet;

  void threadSafetyCleanup(BeforeSet* Cache);

}

// FIXME: No way to easily map from TemplateTypeParmTypes to

// TemplateTypeParmDecls, so we have this horrible PointerUnion.

typedef std::pair<llvm::PointerUnion<const TemplateTypeParmType *, NamedDecl *>,

                  SourceLocation>

    UnexpandedParameterPack;

/// Describes whether we've seen any nullability information for the given

/// file.

struct FileNullability {

  /// The first pointer declarator (of any pointer kind) in the file that does

  /// not have a corresponding nullability annotation.

  SourceLocation PointerLoc;

  /// The end location for the first pointer declarator in the file. Used for

  /// placing fix-its.

  SourceLocation PointerEndLoc;

  /// Which kind of pointer declarator we saw.

  uint8_t PointerKind;

  /// Whether we saw any type nullability annotations in the given file.

  bool SawTypeNullability = false;

};

/// A mapping from file IDs to a record of whether we've seen nullability

/// information in that file.

class FileNullabilityMap {

  /// A mapping from file IDs to the nullability information for each file ID.

  llvm::DenseMap<FileID, FileNullability> Map;

  /// A single-element cache based on the file ID.

  struct {

    FileID File;

    FileNullability Nullability;

  } Cache;

public:

  FileNullability &operator[](FileID file) {

    // Check the single-element cache.

    if (file == Cache.File)

      return Cache.Nullability;

    // It's not in the single-element cache; flush the cache if we have one.

    if (!Cache.File.isInvalid()) {

      Map[Cache.File] = Cache.Nullability;

    }

    // Pull this entry into the cache.

    Cache.File = file;

    Cache.Nullability = Map[file];

    return Cache.Nullability;

  }

};

/// Tracks expected type during expression parsing, for use in code completion.

/// The type is tied to a particular token, all functions that update or consume

/// the type take a start location of the token they are looking at as a

/// parameter. This avoids updating the type on hot paths in the parser.

class PreferredTypeBuilder {

public:

  PreferredTypeBuilder(bool Enabled) : Enabled(Enabled) {}

  void enterCondition(Sema &S, SourceLocation Tok);

  void enterReturn(Sema &S, SourceLocation Tok);

  void enterVariableInit(SourceLocation Tok, Decl *D);

  /// Handles e.g. BaseType{ .D = Tok...

  void enterDesignatedInitializer(SourceLocation Tok, QualType BaseType,

                                  const Designation &D);

  /// Computing a type for the function argument may require running

  /// overloading, so we postpone its computation until it is actually needed.

  ///

  /// Clients should be very careful when using this function, as it stores a

  /// function_ref, clients should make sure all calls to get() with the same

  /// location happen while function_ref is alive.

  ///

  /// The callback should also emit signature help as a side-effect, but only

  /// if the completion point has been reached.

  void enterFunctionArgument(SourceLocation Tok,

                             llvm::function_ref<QualType()> ComputeType);

  void enterParenExpr(SourceLocation Tok, SourceLocation LParLoc);

  void enterUnary(Sema &S, SourceLocation Tok, tok::TokenKind OpKind,

                  SourceLocation OpLoc);

  void enterBinary(Sema &S, SourceLocation Tok, Expr *LHS, tok::TokenKind Op);

  void enterMemAccess(Sema &S, SourceLocation Tok, Expr *Base);

  void enterSubscript(Sema &S, SourceLocation Tok, Expr *LHS);

  /// Handles all type casts, including C-style cast, C++ casts, etc.

  void enterTypeCast(SourceLocation Tok, QualType CastType);

  /// Get the expected type associated with this location, if any.

  ///

  /// If the location is a function argument, determining the expected type

  /// involves considering all function overloads and the arguments so far.

  /// In this case, signature help for these function overloads will be reported

  /// as a side-effect (only if the completion point has been reached).

  QualType get(SourceLocation Tok) const {

    if (!Enabled || Tok != ExpectedLoc)

      return QualType();

    if (!Type.isNull())

      return Type;

    if (ComputeType)

      return ComputeType();

    return QualType();

  }

private:

  bool Enabled;

  /// Start position of a token for which we store expected type.

  SourceLocation ExpectedLoc;

  /// Expected type for a token starting at ExpectedLoc.

  QualType Type;

  /// A function to compute expected type at ExpectedLoc. It is only considered

  /// if Type is null.

  llvm::function_ref<QualType()> ComputeType;

};

/// Sema - This implements semantic analysis and AST building for C.

class Sema final {

  Sema(const Sema &) = delete;

  void operator=(const Sema &) = delete;

  ///Source of additional semantic information.

  IntrusiveRefCntPtr<ExternalSemaSource> ExternalSource;

  static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);

  /// Determine whether two declarations should be linked together, given that

  /// the old declaration might not be visible and the new declaration might

  /// not have external linkage.

  bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,

                                    const NamedDecl *New) {

    if (isVisible(Old))

     return true;

    // See comment in below overload for why it's safe to compute the linkage

    // of the new declaration here.

    if (New->isExternallyDeclarable()) {

      assert(Old->isExternallyDeclarable() &&

             "should not have found a non-externally-declarable previous decl");

      return true;

    }

    return false;

  }

  bool shouldLinkPossiblyHiddenDecl(LookupResult &Old, const NamedDecl *New);

  void setupImplicitSpecialMemberType(CXXMethodDecl *SpecialMem,

                                      QualType ResultTy,

                                      ArrayRef<QualType> Args);

public:

  /// The maximum alignment, same as in llvm::Value. We duplicate them here

  /// because that allows us not to duplicate the constants in clang code,

  /// which we must to since we can't directly use the llvm constants.

  /// The value is verified against llvm here: lib/CodeGen/CGDecl.cpp

  ///

  /// This is the greatest alignment value supported by load, store, and alloca

  /// instructions, and global values.

  static const unsigned MaxAlignmentExponent = 32;

  static const uint64_t MaximumAlignment = 1ull << MaxAlignmentExponent;

  typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;

  typedef OpaquePtr<TemplateName> TemplateTy;

  typedef OpaquePtr<QualType> TypeTy;

  OpenCLOptions OpenCLFeatures;

  FPOptions CurFPFeatures;

  const LangOptions &LangOpts;

  Preprocessor &PP;

  ASTContext &Context;

  ASTConsumer &Consumer;

  DiagnosticsEngine &Diags;

  SourceManager &SourceMgr;

  /// Flag indicating whether or not to collect detailed statistics.

  bool CollectStats;

  /// Code-completion consumer.

  CodeCompleteConsumer *CodeCompleter;

  /// CurContext - This is the current declaration context of parsing.

  DeclContext *CurContext;

  /// Generally null except when we temporarily switch decl contexts,

  /// like in \see ActOnObjCTemporaryExitContainerContext.

  DeclContext *OriginalLexicalContext;

  /// VAListTagName - The declaration name corresponding to __va_list_tag.

  /// This is used as part of a hack to omit that class from ADL results.

  DeclarationName VAListTagName;

  bool MSStructPragmaOn; // True when \#pragma ms_struct on

  /// Controls member pointer representation format under the MS ABI.

  LangOptions::PragmaMSPointersToMembersKind

      MSPointerToMemberRepresentationMethod;

  /// Stack of active SEH __finally scopes.  Can be empty.

  SmallVector<Scope*, 2> CurrentSEHFinally;

  /// Source location for newly created implicit MSInheritanceAttrs

  SourceLocation ImplicitMSInheritanceAttrLoc;

  /// Holds TypoExprs that are created from `createDelayedTypo`. This is used by

  /// `TransformTypos` in order to keep track of any TypoExprs that are created

  /// recursively during typo correction and wipe them away if the correction

  /// fails.

  llvm::SmallVector<TypoExpr *, 2> TypoExprs;

  /// pragma clang section kind

  enum PragmaClangSectionKind {

    PCSK_Invalid      = 0,

    PCSK_BSS          = 1,

    PCSK_Data         = 2,

    PCSK_Rodata       = 3,

    PCSK_Text         = 4,

    PCSK_Relro        = 5

   };

  enum PragmaClangSectionAction {

    PCSA_Set     = 0,

    PCSA_Clear   = 1

  };

  struct PragmaClangSection {

    std::string SectionName;

    bool Valid = false;

    SourceLocation PragmaLocation;

  };

   PragmaClangSection PragmaClangBSSSection;

   PragmaClangSection PragmaClangDataSection;

   PragmaClangSection PragmaClangRodataSection;

   PragmaClangSection PragmaClangRelroSection;

   PragmaClangSection PragmaClangTextSection;

  enum PragmaMsStackAction {

    PSK_Reset     = 0x0,                // #pragma ()

    PSK_Set       = 0x1,                // #pragma (value)

    PSK_Push      = 0x2,                // #pragma (push[, id])

    PSK_Pop       = 0x4,                // #pragma (pop[, id])

    PSK_Show      = 0x8,                // #pragma (show) -- only for "pack"!

    PSK_Push_Set  = PSK_Push | PSK_Set, // #pragma (push[, id], value)

    PSK_Pop_Set   = PSK_Pop | PSK_Set,  // #pragma (pop[, id], value)

  };

  // #pragma pack and align.

  class AlignPackInfo {

  public:

    // `Native` represents default align mode, which may vary based on the

    // platform.

    enum Mode : unsigned char { Native, Natural, Packed, Mac68k };

    // #pragma pack info constructor

    AlignPackInfo(AlignPackInfo::Mode M, unsigned Num, bool IsXL)

        : PackAttr(true), AlignMode(M), PackNumber(Num), XLStack(IsXL) {

      assert(Num == PackNumber && "The pack number has been truncated.");

    }

    // #pragma align info constructor

    AlignPackInfo(AlignPackInfo::Mode M, bool IsXL)

        : PackAttr(false), AlignMode(M),

          PackNumber(M == Packed ? 1 : UninitPackVal), XLStack(IsXL) {}

    explicit AlignPackInfo(bool IsXL) : AlignPackInfo(Native, IsXL) {}

    AlignPackInfo() : AlignPackInfo(Native, false) {}

    // When a AlignPackInfo itself cannot be used, this returns an 32-bit

    // integer encoding for it. This should only be passed to

    // AlignPackInfo::getFromRawEncoding, it should not be inspected directly.

    static uint32_t getRawEncoding(const AlignPackInfo &Info) {

      std::uint32_t Encoding{};

      if (Info.IsXLStack())

        Encoding |= IsXLMask;

      Encoding |= static_cast<uint32_t>(Info.getAlignMode()) << 1;

      if (Info.IsPackAttr())

        Encoding |= PackAttrMask;

      Encoding |= static_cast<uint32_t>(Info.getPackNumber()) << 4;

      return Encoding;

    }

    static AlignPackInfo getFromRawEncoding(unsigned Encoding) {

      bool IsXL = static_cast<bool>(Encoding & IsXLMask);

      AlignPackInfo::Mode M =

          static_cast<AlignPackInfo::Mode>((Encoding & AlignModeMask) >> 1);

      int PackNumber = (Encoding & PackNumMask) >> 4;

      if (Encoding & PackAttrMask)

        return AlignPackInfo(M, PackNumber, IsXL);

      return AlignPackInfo(M, IsXL);

    }

    bool IsPackAttr() const { return PackAttr; }

    bool IsAlignAttr() const { return !PackAttr; }

    Mode getAlignMode() const { return AlignMode; }

    unsigned getPackNumber() const { return PackNumber; }

    bool IsPackSet() const {

      // #pragma align, #pragma pack(), and #pragma pack(0) do not set the pack

      // attriute on a decl.

      return PackNumber != UninitPackVal && PackNumber != 0;

    }

    bool IsXLStack() const { return XLStack; }

    bool operator==(const AlignPackInfo &Info) const {

      return std::tie(AlignMode, PackNumber, PackAttr, XLStack) ==

             std::tie(Info.AlignMode, Info.PackNumber, Info.PackAttr,

                      Info.XLStack);

    }

    bool operator!=(const AlignPackInfo &Info) const {

      return !(*this == Info);

    }

  private:

    /// \brief True if this is a pragma pack attribute,

    ///         not a pragma align attribute.

    bool PackAttr;

    /// \brief The alignment mode that is in effect.

    Mode AlignMode;

    /// \brief The pack number of the stack.

    unsigned char PackNumber;

    /// \brief True if it is a XL #pragma align/pack stack.

    bool XLStack;

    /// \brief Uninitialized pack value.

    static constexpr unsigned char UninitPackVal = -1;

    // Masks to encode and decode an AlignPackInfo.

    static constexpr uint32_t IsXLMask{0x0000'0001};

    static constexpr uint32_t AlignModeMask{0x0000'0006};

    static constexpr uint32_t PackAttrMask{0x00000'0008};

    static constexpr uint32_t PackNumMask{0x0000'01F0};

  };

  template<typename ValueType>

  struct PragmaStack {

    struct Slot {

      llvm::StringRef StackSlotLabel;

      ValueType Value;

      SourceLocation PragmaLocation;

      SourceLocation PragmaPushLocation;

      Slot(llvm::StringRef StackSlotLabel, ValueType Value,

           SourceLocation PragmaLocation, SourceLocation PragmaPushLocation)

          : StackSlotLabel(StackSlotLabel), Value(Value),

            PragmaLocation(PragmaLocation),

            PragmaPushLocation(PragmaPushLocation) {}

    };

    void Act(SourceLocation PragmaLocation, PragmaMsStackAction Action,

             llvm::StringRef StackSlotLabel, ValueType Value) {

      if (Action == PSK_Reset) {

        CurrentValue = DefaultValue;

        CurrentPragmaLocation = PragmaLocation;

        return;

      }

      if (Action & PSK_Push)

        Stack.emplace_back(StackSlotLabel, CurrentValue, CurrentPragmaLocation,

                           PragmaLocation);

      else if (Action & PSK_Pop) {

        if (!StackSlotLabel.empty()) {

          // If we've got a label, try to find it and jump there.

          auto I = llvm::find_if(llvm::reverse(Stack), [&](const Slot &x) {

            return x.StackSlotLabel == StackSlotLabel;

          });

          // If we found the label so pop from there.

          if (I != Stack.rend()) {

            CurrentValue = I->Value;

            CurrentPragmaLocation = I->PragmaLocation;

            Stack.erase(std::prev(I.base()), Stack.end());

          }

        } else if (!Stack.empty()) {

          // We do not have a label, just pop the last entry.

          CurrentValue = Stack.back().Value;

          CurrentPragmaLocation = Stack.back().PragmaLocation;

          Stack.pop_back();

        }

      }

      if (Action & PSK_Set) {

        CurrentValue = Value;

        CurrentPragmaLocation = PragmaLocation;

      }

    }

    // MSVC seems to add artificial slots to #pragma stacks on entering a C++

    // method body to restore the stacks on exit, so it works like this:

    //

    //   struct S {

    //     #pragma <name>(push, InternalPragmaSlot, <current_pragma_value>)

    //     void Method {}

    //     #pragma <name>(pop, InternalPragmaSlot)

    //   };

    //

    // It works even with #pragma vtordisp, although MSVC doesn't support

    //   #pragma vtordisp(push [, id], n)

    // syntax.

    //

    // Push / pop a named sentinel slot.

    void SentinelAction(PragmaMsStackAction Action, StringRef Label) {

      assert((Action == PSK_Push || Action == PSK_Pop) &&

             "Can only push / pop #pragma stack sentinels!");

      Act(CurrentPragmaLocation, Action, Label, CurrentValue);

    }

    // Constructors.

    explicit PragmaStack(const ValueType &Default)

        : DefaultValue(Default), CurrentValue(Default) {}

    bool hasValue() const { return CurrentValue != DefaultValue; }

    SmallVector<Slot, 2> Stack;

    ValueType DefaultValue; // Value used for PSK_Reset action.

    ValueType CurrentValue;

    SourceLocation CurrentPragmaLocation;

  };

  // FIXME: We should serialize / deserialize these if they occur in a PCH (but

  // we shouldn't do so if they're in a module).

  /// Whether to insert vtordisps prior to virtual bases in the Microsoft

  /// C++ ABI.  Possible values are 0, 1, and 2, which mean:

  ///

  /// 0: Suppress all vtordisps

  /// 1: Insert vtordisps in the presence of vbase overrides and non-trivial

  ///    structors

  /// 2: Always insert vtordisps to support RTTI on partially constructed

  ///    objects

  PragmaStack<MSVtorDispMode> VtorDispStack;

  PragmaStack<AlignPackInfo> AlignPackStack;

  // The current #pragma align/pack values and locations at each #include.

  struct AlignPackIncludeState {

    AlignPackInfo CurrentValue;

    SourceLocation CurrentPragmaLocation;

    bool HasNonDefaultValue, ShouldWarnOnInclude;

  };

  SmallVector<AlignPackIncludeState, 8> AlignPackIncludeStack;

  // Segment #pragmas.

  PragmaStack<StringLiteral *> DataSegStack;

  PragmaStack<StringLiteral *> BSSSegStack;

  PragmaStack<StringLiteral *> ConstSegStack;

  PragmaStack<StringLiteral *> CodeSegStack;

  // #pragma strict_gs_check.

  PragmaStack<bool> StrictGuardStackCheckStack;

  // This stack tracks the current state of Sema.CurFPFeatures.

  PragmaStack<FPOptionsOverride> FpPragmaStack;

  FPOptionsOverride CurFPFeatureOverrides() {

    FPOptionsOverride result;

    if (!FpPragmaStack.hasValue()) {

      result = FPOptionsOverride();

    } else {

      result = FpPragmaStack.CurrentValue;

    }

    return result;

  }

  // RAII object to push / pop sentinel slots for all MS #pragma stacks.

  // Actions should be performed only if we enter / exit a C++ method body.

  class PragmaStackSentinelRAII {

  public:

    PragmaStackSentinelRAII(Sema &S, StringRef SlotLabel, bool ShouldAct);

    ~PragmaStackSentinelRAII();

  private:

    Sema &S;

    StringRef SlotLabel;

    bool ShouldAct;

  };

  /// A mapping that describes the nullability we've seen in each header file.

  FileNullabilityMap NullabilityMap;

  /// Last section used with #pragma init_seg.

  StringLiteral *CurInitSeg;

  SourceLocation CurInitSegLoc;

  /// Sections used with #pragma alloc_text.

  llvm::StringMap<std::tuple<StringRef, SourceLocation>> FunctionToSectionMap;

  /// VisContext - Manages the stack for \#pragma GCC visibility.

  void *VisContext; // Really a "PragmaVisStack*"

  /// This an attribute introduced by \#pragma clang attribute.

  struct PragmaAttributeEntry {

    SourceLocation Loc;

    ParsedAttr *Attribute;

    SmallVector<attr::SubjectMatchRule, 4> MatchRules;

    bool IsUsed;

  };

  /// A push'd group of PragmaAttributeEntries.

  struct PragmaAttributeGroup {

    /// The location of the push attribute.

    SourceLocation Loc;

    /// The namespace of this push group.

    const IdentifierInfo *Namespace;

    SmallVector<PragmaAttributeEntry, 2> Entries;

  };

  SmallVector<PragmaAttributeGroup, 2> PragmaAttributeStack;

  /// The declaration that is currently receiving an attribute from the

  /// #pragma attribute stack.

  const Decl *PragmaAttributeCurrentTargetDecl;

  /// This represents the last location of a "#pragma clang optimize off"

  /// directive if such a directive has not been closed by an "on" yet. If

  /// optimizations are currently "on", this is set to an invalid location.

  SourceLocation OptimizeOffPragmaLocation;

  /// The "on" or "off" argument passed by \#pragma optimize, that denotes

  /// whether the optimizations in the list passed to the pragma should be

  /// turned off or on. This boolean is true by default because command line

  /// options are honored when `#pragma optimize("", on)`.

  /// (i.e. `ModifyFnAttributeMSPragmaOptimze()` does nothing)

  bool MSPragmaOptimizeIsOn = true;

  /// Set of no-builtin functions listed by \#pragma function.

  llvm::SmallSetVector<StringRef, 4> MSFunctionNoBuiltins;

  /// Flag indicating if Sema is building a recovery call expression.

  ///

  /// This flag is used to avoid building recovery call expressions

  /// if Sema is already doing so, which would cause infinite recursions.

  bool IsBuildingRecoveryCallExpr;

  /// Used to control the generation of ExprWithCleanups.

  CleanupInfo Cleanup;

  /// ExprCleanupObjects - This is the stack of objects requiring

  /// cleanup that are created by the current full expression.

  SmallVector<ExprWithCleanups::CleanupObject, 8> ExprCleanupObjects;

  /// Store a set of either DeclRefExprs or MemberExprs that contain a reference

  /// to a variable (constant) that may or may not be odr-used in this Expr, and

  /// we won't know until all lvalue-to-rvalue and discarded value conversions

  /// have been applied to all subexpressions of the enclosing full expression.

  /// This is cleared at the end of each full expression.

  using MaybeODRUseExprSet = llvm::SetVector<Expr *, SmallVector<Expr *, 4>,

                                             llvm::SmallPtrSet<Expr *, 4>>;

  MaybeODRUseExprSet MaybeODRUseExprs;

  std::unique_ptr<sema::FunctionScopeInfo> CachedFunctionScope;

  /// Stack containing information about each of the nested

  /// function, block, and method scopes that are currently active.

  SmallVector<sema::FunctionScopeInfo *, 4> FunctionScopes;

  /// The index of the first FunctionScope that corresponds to the current

  /// context.

  unsigned FunctionScopesStart = 0;

  ArrayRef<sema::FunctionScopeInfo*> getFunctionScopes() const {

    return llvm::ArrayRef(FunctionScopes.begin() + FunctionScopesStart,

                          FunctionScopes.end());

  }

  /// Stack containing information needed when in C++2a an 'auto' is encountered

  /// in a function declaration parameter type specifier in order to invent a

  /// corresponding template parameter in the enclosing abbreviated function

  /// template. This information is also present in LambdaScopeInfo, stored in

  /// the FunctionScopes stack.

  SmallVector<InventedTemplateParameterInfo, 4> InventedParameterInfos;

  /// The index of the first InventedParameterInfo that refers to the current

  /// context.

  unsigned InventedParameterInfosStart = 0;

  ArrayRef<InventedTemplateParameterInfo> getInventedParameterInfos() const {

    return llvm::ArrayRef(InventedParameterInfos.begin() +

                              InventedParameterInfosStart,

                          InventedParameterInfos.end());

  }

  typedef LazyVector<TypedefNameDecl *, ExternalSemaSource,

                     &ExternalSemaSource::ReadExtVectorDecls, 2, 2>

    ExtVectorDeclsType;

  /// ExtVectorDecls - This is a list all the extended vector types. This allows

  /// us to associate a raw vector type with one of the ext_vector type names.

  /// This is only necessary for issuing pretty diagnostics.

  ExtVectorDeclsType ExtVectorDecls;

  /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.

  std::unique_ptr<CXXFieldCollector> FieldCollector;

  typedef llvm::SmallSetVector<NamedDecl *, 16> NamedDeclSetType;

  /// Set containing all declared private fields that are not used.

  NamedDeclSetType UnusedPrivateFields;

  /// Set containing all typedefs that are likely unused.

  llvm::SmallSetVector<const TypedefNameDecl *, 4>

      UnusedLocalTypedefNameCandidates;

  /// Delete-expressions to be analyzed at the end of translation unit

  ///

  /// This list contains class members, and locations of delete-expressions

  /// that could not be proven as to whether they mismatch with new-expression

  /// used in initializer of the field.

  typedef std::pair<SourceLocation, bool> DeleteExprLoc;

  typedef llvm::SmallVector<DeleteExprLoc, 4> DeleteLocs;

  llvm::MapVector<FieldDecl *, DeleteLocs> DeleteExprs;

  typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;

  /// PureVirtualClassDiagSet - a set of class declarations which we have

  /// emitted a list of pure virtual functions. Used to prevent emitting the

  /// same list more than once.

  std::unique_ptr<RecordDeclSetTy> PureVirtualClassDiagSet;

  /// ParsingInitForAutoVars - a set of declarations with auto types for which

  /// we are currently parsing the initializer.