Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

 

 

 

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);

 

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

                  SourceLocation>

    UnexpandedParameterPack;

 

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;

 

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;

 

  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;

  }

 

class PreferredTypeBuilder {

  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();

  }

 

  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;

 

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);

 

  /// 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 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.

  llvm::SmallPtrSet<const Decl*, 4> ParsingInitForAutoVars;

 

  /// Look for a locally scoped extern "C" declaration by the given name.

  NamedDecl *findLocallyScopedExternCDecl(DeclarationName Name);

 

  typedef LazyVector<VarDecl *, ExternalSemaSource,

                     &ExternalSemaSource::ReadTentativeDefinitions, 2, 2>

    TentativeDefinitionsType;

 

  /// All the tentative definitions encountered in the TU.

  TentativeDefinitionsType TentativeDefinitions;

 

  /// All the external declarations encoutered and used in the TU.

  SmallVector<VarDecl *, 4> ExternalDeclarations;

 

  typedef LazyVector<const DeclaratorDecl *, ExternalSemaSource,

                     &ExternalSemaSource::ReadUnusedFileScopedDecls, 2, 2>

    UnusedFileScopedDeclsType;

 

  /// The set of file scoped decls seen so far that have not been used

  /// and must warn if not used. Only contains the first declaration.

  UnusedFileScopedDeclsType UnusedFileScopedDecls;

 

  typedef LazyVector<CXXConstructorDecl *, ExternalSemaSource,

                     &ExternalSemaSource::ReadDelegatingConstructors, 2, 2>

    DelegatingCtorDeclsType;

 

  /// All the delegating constructors seen so far in the file, used for

  /// cycle detection at the end of the TU.

  DelegatingCtorDeclsType DelegatingCtorDecls;

 

  /// All the overriding functions seen during a class definition

  /// that had their exception spec checks delayed, plus the overridden

  /// function.

  SmallVector<std::pair<const CXXMethodDecl*, const CXXMethodDecl*>, 2>

    DelayedOverridingExceptionSpecChecks;

 

  /// All the function redeclarations seen during a class definition that had

  /// their exception spec checks delayed, plus the prior declaration they

  /// should be checked against. Except during error recovery, the new decl

  /// should always be a friend declaration, as that's the only valid way to

  /// redeclare a special member before its class is complete.

  SmallVector<std::pair<FunctionDecl*, FunctionDecl*>, 2>

    DelayedEquivalentExceptionSpecChecks;

 

  typedef llvm::MapVector<const FunctionDecl *,

                          std::unique_ptr<LateParsedTemplate>>

      LateParsedTemplateMapT;

  LateParsedTemplateMapT LateParsedTemplateMap;

 

  /// Callback to the parser to parse templated functions when needed.

  typedef void LateTemplateParserCB(void *P, LateParsedTemplate &LPT);

  typedef void LateTemplateParserCleanupCB(void *P);

  LateTemplateParserCB *LateTemplateParser;

  LateTemplateParserCleanupCB *LateTemplateParserCleanup;

  void *OpaqueParser;

 

  void SetLateTemplateParser(LateTemplateParserCB *LTP,

                             LateTemplateParserCleanupCB *LTPCleanup,

                             void *P) {

    LateTemplateParser = LTP;

    LateTemplateParserCleanup = LTPCleanup;

    OpaqueParser = P;

  }

 

  class DelayedDiagnostics;

 

  class DelayedDiagnosticsState {

    sema::DelayedDiagnosticPool *SavedPool;

    friend class Sema::DelayedDiagnostics;

  };

  typedef DelayedDiagnosticsState ParsingDeclState;

  typedef DelayedDiagnosticsState ProcessingContextState;

 

  /// A class which encapsulates the logic for delaying diagnostics

  /// during parsing and other processing.

  class DelayedDiagnostics {

    /// The current pool of diagnostics into which delayed

    /// diagnostics should go.

    sema::DelayedDiagnosticPool *CurPool;

 

  public:

    DelayedDiagnostics() : CurPool(nullptr) {}

 

    /// Adds a delayed diagnostic.

    void add(const sema::DelayedDiagnostic &diag); // in DelayedDiagnostic.h

 

    /// Determines whether diagnostics should be delayed.

    bool shouldDelayDiagnostics() { return CurPool != nullptr; }

 

    /// Returns the current delayed-diagnostics pool.

    sema::DelayedDiagnosticPool *getCurrentPool() const {

      return CurPool;

    }

 

    /// Enter a new scope.  Access and deprecation diagnostics will be

    /// collected in this pool.

    DelayedDiagnosticsState push(sema::DelayedDiagnosticPool &pool) {

      DelayedDiagnosticsState state;

      state.SavedPool = CurPool;

      CurPool = &pool;

      return state;

    }

 

    /// Leave a delayed-diagnostic state that was previously pushed.

    /// Do not emit any of the diagnostics.  This is performed as part

    /// of the bookkeeping of popping a pool "properly".

    void popWithoutEmitting(DelayedDiagnosticsState state) {

      CurPool = state.SavedPool;

    }

 

    /// Enter a new scope where access and deprecation diagnostics are

    /// not delayed.

    DelayedDiagnosticsState pushUndelayed() {

      DelayedDiagnosticsState state;

      state.SavedPool = CurPool;

      CurPool = nullptr;

      return state;

    }

 

    /// Undo a previous pushUndelayed().

    void popUndelayed(DelayedDiagnosticsState state) {

      assert(CurPool == nullptr);

      CurPool = state.SavedPool;

    }

  } DelayedDiagnostics;

 

  /// A RAII object to temporarily push a declaration context.

  class ContextRAII {

  private:

    Sema &S;

    DeclContext *SavedContext;

    ProcessingContextState SavedContextState;

    QualType SavedCXXThisTypeOverride;

    unsigned SavedFunctionScopesStart;

    unsigned SavedInventedParameterInfosStart;

 

  public:

    ContextRAII(Sema &S, DeclContext *ContextToPush, bool NewThisContext = true)

      : S(S), SavedContext(S.CurContext),

        SavedContextState(S.DelayedDiagnostics.pushUndelayed()),

        SavedCXXThisTypeOverride(S.CXXThisTypeOverride),

        SavedFunctionScopesStart(S.FunctionScopesStart),

        SavedInventedParameterInfosStart(S.InventedParameterInfosStart)

    {

      assert(ContextToPush && "pushing null context");

      S.CurContext = ContextToPush;

      if (NewThisContext)

        S.CXXThisTypeOverride = QualType();

      // Any saved FunctionScopes do not refer to this context.

      S.FunctionScopesStart = S.FunctionScopes.size();

      S.InventedParameterInfosStart = S.InventedParameterInfos.size();

    }

 

    void pop() {

      if (!SavedContext) return;

      S.CurContext = SavedContext;

      S.DelayedDiagnostics.popUndelayed(SavedContextState);

      S.CXXThisTypeOverride = SavedCXXThisTypeOverride;

      S.FunctionScopesStart = SavedFunctionScopesStart;

      S.InventedParameterInfosStart = SavedInventedParameterInfosStart;

      SavedContext = nullptr;

    }

 

    ~ContextRAII() {

      pop();

    }

  };

 

  /// Whether the AST is currently being rebuilt to correct immediate

  /// invocations. Immediate invocation candidates and references to consteval

  /// functions aren't tracked when this is set.

  bool RebuildingImmediateInvocation = false;

 

  /// Used to change context to isConstantEvaluated without pushing a heavy

  /// ExpressionEvaluationContextRecord object.

  bool isConstantEvaluatedOverride;

 

  bool isConstantEvaluated() {

    return ExprEvalContexts.back().isConstantEvaluated() ||

           isConstantEvaluatedOverride;

  }

 

  /// RAII object to handle the state changes required to synthesize

  /// a function body.

  class SynthesizedFunctionScope {

    Sema &S;

    Sema::ContextRAII SavedContext;

    bool PushedCodeSynthesisContext = false;

 

  public:

    SynthesizedFunctionScope(Sema &S, DeclContext *DC)

        : S(S), SavedContext(S, DC) {

      S.PushFunctionScope();

      S.PushExpressionEvaluationContext(

          Sema::ExpressionEvaluationContext::PotentiallyEvaluated);

      if (auto *FD = dyn_cast<FunctionDecl>(DC))

        FD->setWillHaveBody(true);

      else

        assert(isa<ObjCMethodDecl>(DC));

    }

 

    void addContextNote(SourceLocation UseLoc) {

      assert(!PushedCodeSynthesisContext);

 

      Sema::CodeSynthesisContext Ctx;

      Ctx.Kind = Sema::CodeSynthesisContext::DefiningSynthesizedFunction;

      Ctx.PointOfInstantiation = UseLoc;

      Ctx.Entity = cast<Decl>(S.CurContext);

      S.pushCodeSynthesisContext(Ctx);

 

      PushedCodeSynthesisContext = true;

    }

 

    ~SynthesizedFunctionScope() {

      if (PushedCodeSynthesisContext)

        S.popCodeSynthesisContext();

      if (auto *FD = dyn_cast<FunctionDecl>(S.CurContext))

        FD->setWillHaveBody(false);

      S.PopExpressionEvaluationContext();

      S.PopFunctionScopeInfo();

    }

  };

 

  /// WeakUndeclaredIdentifiers - Identifiers contained in \#pragma weak before

  /// declared. Rare. May alias another identifier, declared or undeclared.

  ///

  /// For aliases, the target identifier is used as a key for eventual

  /// processing when the target is declared. For the single-identifier form,

  /// the sole identifier is used as the key. Each entry is a `SetVector`

  /// (ordered by parse order) of aliases (identified by the alias name) in case

  /// of multiple aliases to the same undeclared identifier.

  llvm::MapVector<

      IdentifierInfo *,

      llvm::SetVector<

          WeakInfo, llvm::SmallVector<WeakInfo, 1u>,

          llvm::SmallDenseSet<WeakInfo, 2u, WeakInfo::DenseMapInfoByAliasOnly>>>

      WeakUndeclaredIdentifiers;

 

  /// ExtnameUndeclaredIdentifiers - Identifiers contained in

  /// \#pragma redefine_extname before declared.  Used in Solaris system headers

  /// to define functions that occur in multiple standards to call the version

  /// in the currently selected standard.

  llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*> ExtnameUndeclaredIdentifiers;

 

 

  /// Load weak undeclared identifiers from the external source.

  void LoadExternalWeakUndeclaredIdentifiers();

 

  /// WeakTopLevelDecl - Translation-unit scoped declarations generated by

  /// \#pragma weak during processing of other Decls.

  /// I couldn't figure out a clean way to generate these in-line, so

  /// we store them here and handle separately -- which is a hack.

  /// It would be best to refactor this.

  SmallVector<Decl*,2> WeakTopLevelDecl;

 

  IdentifierResolver IdResolver;

 

  /// Translation Unit Scope - useful to Objective-C actions that need

  /// to lookup file scope declarations in the "ordinary" C decl namespace.

  /// For example, user-defined classes, built-in "id" type, etc.

  Scope *TUScope;

 

  /// The C++ "std" namespace, where the standard library resides.

  LazyDeclPtr StdNamespace;

 

  /// The C++ "std::bad_alloc" class, which is defined by the C++

  /// standard library.

  LazyDeclPtr StdBadAlloc;

 

  /// The C++ "std::align_val_t" enum class, which is defined by the C++

  /// standard library.

  LazyDeclPtr StdAlignValT;

 

  /// The C++ "std::experimental" namespace, where the experimental parts

  /// of the standard library resides.

  NamespaceDecl *StdExperimentalNamespaceCache;

 

  /// The C++ "std::initializer_list" template, which is defined in

  /// \<initializer_list>.

  ClassTemplateDecl *StdInitializerList;

 

  /// The C++ "std::coroutine_traits" template, which is defined in

  /// \<coroutine_traits>

  ClassTemplateDecl *StdCoroutineTraitsCache;

  /// The namespace where coroutine components are defined. In standard,

  /// they are defined in std namespace. And in the previous implementation,

  /// they are defined in std::experimental namespace.

  NamespaceDecl *CoroTraitsNamespaceCache;

 

  /// The C++ "type_info" declaration, which is defined in \<typeinfo>.

  RecordDecl *CXXTypeInfoDecl;

 

  /// The MSVC "_GUID" struct, which is defined in MSVC header files.

  RecordDecl *MSVCGuidDecl;

 

  /// The C++ "std::source_location::__impl" struct, defined in

  /// \<source_location>.

  RecordDecl *StdSourceLocationImplDecl;

 

  /// Caches identifiers/selectors for NSFoundation APIs.

  std::unique_ptr<NSAPI> NSAPIObj;

 

  /// The declaration of the Objective-C NSNumber class.

  ObjCInterfaceDecl *NSNumberDecl;

 

  /// The declaration of the Objective-C NSValue class.

  ObjCInterfaceDecl *NSValueDecl;

 

  /// Pointer to NSNumber type (NSNumber *).

  QualType NSNumberPointer;

 

  /// Pointer to NSValue type (NSValue *).

  QualType NSValuePointer;

 

  /// The Objective-C NSNumber methods used to create NSNumber literals.

  ObjCMethodDecl *NSNumberLiteralMethods[NSAPI::NumNSNumberLiteralMethods];

 

  /// The declaration of the Objective-C NSString class.

  ObjCInterfaceDecl *NSStringDecl;

 

  /// Pointer to NSString type (NSString *).

  QualType NSStringPointer;

 

  /// The declaration of the stringWithUTF8String: method.

  ObjCMethodDecl *StringWithUTF8StringMethod;

 

  /// The declaration of the valueWithBytes:objCType: method.

  ObjCMethodDecl *ValueWithBytesObjCTypeMethod;

 

  /// The declaration of the Objective-C NSArray class.

  ObjCInterfaceDecl *NSArrayDecl;

 

  /// The declaration of the arrayWithObjects:count: method.

  ObjCMethodDecl *ArrayWithObjectsMethod;

 

  /// The declaration of the Objective-C NSDictionary class.

  ObjCInterfaceDecl *NSDictionaryDecl;

 

  /// The declaration of the dictionaryWithObjects:forKeys:count: method.

  ObjCMethodDecl *DictionaryWithObjectsMethod;

 

  /// id<NSCopying> type.

  QualType QIDNSCopying;

 

  /// will hold 'respondsToSelector:'

  Selector RespondsToSelectorSel;

 

  /// A flag to remember whether the implicit forms of operator new and delete

  /// have been declared.

  bool GlobalNewDeleteDeclared;

 

  /// Describes how the expressions currently being parsed are

  /// evaluated at run-time, if at all.

  enum class ExpressionEvaluationContext {

    /// The current expression and its subexpressions occur within an

    /// unevaluated operand (C++11 [expr]p7), such as the subexpression of

    /// \c sizeof, where the type of the expression may be significant but

    /// no code will be generated to evaluate the value of the expression at

    /// run time.

    Unevaluated,

 

    /// The current expression occurs within a braced-init-list within

    /// an unevaluated operand. This is mostly like a regular unevaluated

    /// context, except that we still instantiate constexpr functions that are

    /// referenced here so that we can perform narrowing checks correctly.

    UnevaluatedList,

 

    /// The current expression occurs within a discarded statement.

    /// This behaves largely similarly to an unevaluated operand in preventing

    /// definitions from being required, but not in other ways.

    DiscardedStatement,

 

    /// The current expression occurs within an unevaluated

    /// operand that unconditionally permits abstract references to

    /// fields, such as a SIZE operator in MS-style inline assembly.

    UnevaluatedAbstract,

 

    /// The current context is "potentially evaluated" in C++11 terms,

    /// but the expression is evaluated at compile-time (like the values of

    /// cases in a switch statement).

    ConstantEvaluated,

 

    /// In addition of being constant evaluated, the current expression

    /// occurs in an immediate function context - either a consteval function

    /// or a consteval if function.

    ImmediateFunctionContext,

 

    /// The current expression is potentially evaluated at run time,

    /// which means that code may be generated to evaluate the value of the

    /// expression at run time.

    PotentiallyEvaluated,

 

    /// The current expression is potentially evaluated, but any

    /// declarations referenced inside that expression are only used if

    /// in fact the current expression is used.

    ///

    /// This value is used when parsing default function arguments, for which

    /// we would like to provide diagnostics (e.g., passing non-POD arguments

    /// through varargs) but do not want to mark declarations as "referenced"

    /// until the default argument is used.

    PotentiallyEvaluatedIfUsed

  };

 

  using ImmediateInvocationCandidate = llvm::PointerIntPair<ConstantExpr *, 1>;

 

  /// Data structure used to record current or nested

  /// expression evaluation contexts.

  struct ExpressionEvaluationContextRecord {

    /// The expression evaluation context.

    ExpressionEvaluationContext Context;

 

    /// Whether the enclosing context needed a cleanup.

    CleanupInfo ParentCleanup;

 

    /// The number of active cleanup objects when we entered

    /// this expression evaluation context.

    unsigned NumCleanupObjects;

 

    /// The number of typos encountered during this expression evaluation

    /// context (i.e. the number of TypoExprs created).

    unsigned NumTypos;

 

    MaybeODRUseExprSet SavedMaybeODRUseExprs;

 

    /// The lambdas that are present within this context, if it

    /// is indeed an unevaluated context.

    SmallVector<LambdaExpr *, 2> Lambdas;

 

    /// The declaration that provides context for lambda expressions

    /// and block literals if the normal declaration context does not

    /// suffice, e.g., in a default function argument.

    Decl *ManglingContextDecl;

 

    /// If we are processing a decltype type, a set of call expressions

    /// for which we have deferred checking the completeness of the return type.

    SmallVector<CallExpr *, 8> DelayedDecltypeCalls;

 

    /// If we are processing a decltype type, a set of temporary binding

    /// expressions for which we have deferred checking the destructor.

    SmallVector<CXXBindTemporaryExpr *, 8> DelayedDecltypeBinds;

 

    llvm::SmallPtrSet<const Expr *, 8> PossibleDerefs;

 

    /// Expressions appearing as the LHS of a volatile assignment in this

    /// context. We produce a warning for these when popping the context if

    /// they are not discarded-value expressions nor unevaluated operands.

    SmallVector<Expr*, 2> VolatileAssignmentLHSs;

 

    /// Set of candidates for starting an immediate invocation.

    llvm::SmallVector<ImmediateInvocationCandidate, 4> ImmediateInvocationCandidates;

 

    /// Set of DeclRefExprs referencing a consteval function when used in a

    /// context not already known to be immediately invoked.

    llvm::SmallPtrSet<DeclRefExpr *, 4> ReferenceToConsteval;

 

    /// \brief Describes whether we are in an expression constext which we have

    /// to handle differently.

    enum ExpressionKind {

      EK_Decltype, EK_TemplateArgument, EK_Other

    } ExprContext;

 

    // A context can be nested in both a discarded statement context and

    // an immediate function context, so they need to be tracked independently.

    bool InDiscardedStatement;

    bool InImmediateFunctionContext;

 

    bool IsCurrentlyCheckingDefaultArgumentOrInitializer = false;

 

    // When evaluating immediate functions in the initializer of a default

    // argument or default member initializer, this is the declaration whose

    // default initializer is being evaluated and the location of the call

    // or constructor definition.

    struct InitializationContext {

      InitializationContext(SourceLocation Loc, ValueDecl *Decl,

                            DeclContext *Context)

          : Loc(Loc), Decl(Decl), Context(Context) {

        assert(Decl && Context && "invalid initialization context");

      }

 

      SourceLocation Loc;

      ValueDecl *Decl = nullptr;

      DeclContext *Context = nullptr;

    };

    std::optional<InitializationContext> DelayedDefaultInitializationContext;

 

    ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,

                                      unsigned NumCleanupObjects,

                                      CleanupInfo ParentCleanup,

                                      Decl *ManglingContextDecl,

                                      ExpressionKind ExprContext)

        : Context(Context), ParentCleanup(ParentCleanup),

          NumCleanupObjects(NumCleanupObjects), NumTypos(0),

          ManglingContextDecl(ManglingContextDecl), ExprContext(ExprContext),

          InDiscardedStatement(false), InImmediateFunctionContext(false) {}

 

    bool isUnevaluated() const {

      return Context == ExpressionEvaluationContext::Unevaluated ||

             Context == ExpressionEvaluationContext::UnevaluatedAbstract ||

             Context == ExpressionEvaluationContext::UnevaluatedList;

    }

 

    bool isConstantEvaluated() const {

      return Context == ExpressionEvaluationContext::ConstantEvaluated ||

             Context == ExpressionEvaluationContext::ImmediateFunctionContext;

    }

 

    bool isImmediateFunctionContext() const {

      return Context == ExpressionEvaluationContext::ImmediateFunctionContext ||

             (Context == ExpressionEvaluationContext::DiscardedStatement &&

              InImmediateFunctionContext) ||

             // C++2b [expr.const]p14:

             // An expression or conversion is in an immediate function

             // context if it is potentially evaluated and either:

             //   * its innermost enclosing non-block scope is a function

             //     parameter scope of an immediate function, or

             //   * its enclosing statement is enclosed by the compound-

             //     statement of a consteval if statement.

             (Context == ExpressionEvaluationContext::PotentiallyEvaluated &&

              InImmediateFunctionContext);

    }

 

    bool isDiscardedStatementContext() const {

      return Context == ExpressionEvaluationContext::DiscardedStatement ||

             (Context ==

                  ExpressionEvaluationContext::ImmediateFunctionContext &&

              InDiscardedStatement);

    }

  };

 

  /// A stack of expression evaluation contexts.

  SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;

 

  // Set of failed immediate invocations to avoid double diagnosing.

  llvm::SmallPtrSet<ConstantExpr *, 4> FailedImmediateInvocations;

 

  /// Emit a warning for all pending noderef expressions that we recorded.

  void WarnOnPendingNoDerefs(ExpressionEvaluationContextRecord &Rec);

 

  /// Compute the mangling number context for a lambda expression or

  /// block literal. Also return the extra mangling decl if any.

  ///

  /// \param DC - The DeclContext containing the lambda expression or

  /// block literal.

  std::tuple<MangleNumberingContext *, Decl *>

  getCurrentMangleNumberContext(const DeclContext *DC);

 

 

  /// SpecialMemberOverloadResult - The overloading result for a special member

  /// function.

  ///

  /// This is basically a wrapper around PointerIntPair. The lowest bits of the

  /// integer are used to determine whether overload resolution succeeded.

  class SpecialMemberOverloadResult {

  public:

    enum Kind {

      NoMemberOrDeleted,

      Ambiguous,

      Success

    };

 

  private:

    llvm::PointerIntPair<CXXMethodDecl *, 2> Pair;

 

  public:

    SpecialMemberOverloadResult() {}

    SpecialMemberOverloadResult(CXXMethodDecl *MD)

        : Pair(MD, MD->isDeleted() ? NoMemberOrDeleted : Success) {}

 

    CXXMethodDecl *getMethod() const { return Pair.getPointer(); }

    void setMethod(CXXMethodDecl *MD) { Pair.setPointer(MD); }

 

    Kind getKind() const { return static_cast<Kind>(Pair.getInt()); }

    void setKind(Kind K) { Pair.setInt(K); }

  };

 

  class SpecialMemberOverloadResultEntry

      : public llvm::FastFoldingSetNode,

        public SpecialMemberOverloadResult {

  public:

    SpecialMemberOverloadResultEntry(const llvm::FoldingSetNodeID &ID)

      : FastFoldingSetNode(ID)

    {}

  };

 

  /// A cache of special member function overload resolution results

  /// for C++ records.

  llvm::FoldingSet<SpecialMemberOverloadResultEntry> SpecialMemberCache;

 

  /// A cache of the flags available in enumerations with the flag_bits

  /// attribute.

  mutable llvm::DenseMap<const EnumDecl*, llvm::APInt> FlagBitsCache;

 

  /// The kind of translation unit we are processing.

  ///

  /// When we're processing a complete translation unit, Sema will perform

  /// end-of-translation-unit semantic tasks (such as creating

  /// initializers for tentative definitions in C) once parsing has

  /// completed. Modules and precompiled headers perform different kinds of

  /// checks.

  const TranslationUnitKind TUKind;

 

  llvm::BumpPtrAllocator BumpAlloc;

 

  /// The number of SFINAE diagnostics that have been trapped.

  unsigned NumSFINAEErrors;

 

  typedef llvm::DenseMap<ParmVarDecl *, llvm::TinyPtrVector<ParmVarDecl *>>

    UnparsedDefaultArgInstantiationsMap;

 

  /// A mapping from parameters with unparsed default arguments to the

  /// set of instantiations of each parameter.

  ///

  /// This mapping is a temporary data structure used when parsing

  /// nested class templates or nested classes of class templates,

  /// where we might end up instantiating an inner class before the

  /// default arguments of its methods have been parsed.

  UnparsedDefaultArgInstantiationsMap UnparsedDefaultArgInstantiations;

 

  // Contains the locations of the beginning of unparsed default

  // argument locations.

  llvm::DenseMap<ParmVarDecl *, SourceLocation> UnparsedDefaultArgLocs;

 

  /// UndefinedInternals - all the used, undefined objects which require a

  /// definition in this translation unit.

  llvm::MapVector<NamedDecl *, SourceLocation> UndefinedButUsed;

 

  /// Determine if VD, which must be a variable or function, is an external

  /// symbol that nonetheless can't be referenced from outside this translation

  /// unit because its type has no linkage and it's not extern "C".

  bool isExternalWithNoLinkageType(ValueDecl *VD);

 

  /// Obtain a sorted list of functions that are undefined but ODR-used.

  void getUndefinedButUsed(

      SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined);

 

  /// Retrieves list of suspicious delete-expressions that will be checked at

  /// the end of translation unit.

  const llvm::MapVector<FieldDecl *, DeleteLocs> &

  getMismatchingDeleteExpressions() const;

 

  class GlobalMethodPool {

  public:

    using Lists = std::pair<ObjCMethodList, ObjCMethodList>;

    using iterator = llvm::DenseMap<Selector, Lists>::iterator;

    iterator begin() { return Methods.begin(); }

    iterator end() { return Methods.end(); }

    iterator find(Selector Sel) { return Methods.find(Sel); }

    std::pair<iterator, bool> insert(std::pair<Selector, Lists> &&Val) {

      return Methods.insert(Val);

    }

    int count(Selector Sel) const { return Methods.count(Sel); }

    bool empty() const { return Methods.empty(); }

 

  private:

    llvm::DenseMap<Selector, Lists> Methods;

  };

 

  /// Method Pool - allows efficient lookup when typechecking messages to "id".

  /// We need to maintain a list, since selectors can have differing signatures

  /// across classes. In Cocoa, this happens to be extremely uncommon (only 1%

  /// of selectors are "overloaded").

  /// At the head of the list it is recorded whether there were 0, 1, or >= 2

  /// methods inside categories with a particular selector.

  GlobalMethodPool MethodPool;

 

  /// Method selectors used in a \@selector expression. Used for implementation

  /// of -Wselector.

  llvm::MapVector<Selector, SourceLocation> ReferencedSelectors;

 

  /// List of SourceLocations where 'self' is implicitly retained inside a

  /// block.

  llvm::SmallVector<std::pair<SourceLocation, const BlockDecl *>, 1>

      ImplicitlyRetainedSelfLocs;

 

  /// Kinds of C++ special members.

  enum CXXSpecialMember {

    CXXDefaultConstructor,

    CXXCopyConstructor,

    CXXMoveConstructor,

    CXXCopyAssignment,

    CXXMoveAssignment,

    CXXDestructor,

    CXXInvalid

  };

 

  typedef llvm::PointerIntPair<CXXRecordDecl *, 3, CXXSpecialMember>

      SpecialMemberDecl;

 

  /// The C++ special members which we are currently in the process of

  /// declaring. If this process recursively triggers the declaration of the

  /// same special member, we should act as if it is not yet declared.

  llvm::SmallPtrSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;

 

  /// Kinds of defaulted comparison operator functions.

  enum class DefaultedComparisonKind : unsigned char {

    /// This is not a defaultable comparison operator.

    None,

    /// This is an operator== that should be implemented as a series of

    /// subobject comparisons.

    Equal,

    /// This is an operator<=> that should be implemented as a series of

    /// subobject comparisons.

    ThreeWay,

    /// This is an operator!= that should be implemented as a rewrite in terms

    /// of a == comparison.

    NotEqual,

    /// This is an <, <=, >, or >= that should be implemented as a rewrite in

    /// terms of a <=> comparison.

    Relational,

  };

 

  /// The function definitions which were renamed as part of typo-correction

  /// to match their respective declarations. We want to keep track of them

  /// to ensure that we don't emit a "redefinition" error if we encounter a

  /// correctly named definition after the renamed definition.

  llvm::SmallPtrSet<const NamedDecl *, 4> TypoCorrectedFunctionDefinitions;

 

  /// Stack of types that correspond to the parameter entities that are

  /// currently being copy-initialized. Can be empty.

  llvm::SmallVector<QualType, 4> CurrentParameterCopyTypes;

 

  void ReadMethodPool(Selector Sel);

  void updateOutOfDateSelector(Selector Sel);

 

  /// Private Helper predicate to check for 'self'.

  bool isSelfExpr(Expr *RExpr);

  bool isSelfExpr(Expr *RExpr, const ObjCMethodDecl *Method);

 

  /// Cause the active diagnostic on the DiagosticsEngine to be

  /// emitted. This is closely coupled to the SemaDiagnosticBuilder class and

  /// should not be used elsewhere.

  void EmitCurrentDiagnostic(unsigned DiagID);

 

  /// Records and restores the CurFPFeatures state on entry/exit of compound

  /// statements.

  class FPFeaturesStateRAII {

  public:

    FPFeaturesStateRAII(Sema &S);

    ~FPFeaturesStateRAII();

    FPOptionsOverride getOverrides() { return OldOverrides; }

 

  private:

    Sema& S;

    FPOptions OldFPFeaturesState;

    FPOptionsOverride OldOverrides;

    LangOptions::FPEvalMethodKind OldEvalMethod;

    SourceLocation OldFPPragmaLocation;

  };

 

  void addImplicitTypedef(StringRef Name, QualType T);

 

  bool WarnedStackExhausted = false;

 

  /// Increment when we find a reference; decrement when we find an ignored

  /// assignment.  Ultimately the value is 0 if every reference is an ignored

  /// assignment.

  llvm::DenseMap<const VarDecl *, int> RefsMinusAssignments;

 

  /// Indicate RISC-V vector builtin functions enabled or not.

  bool DeclareRISCVVBuiltins = false;

 

  std::unique_ptr<sema::RISCVIntrinsicManager> RVIntrinsicManager;

 

  std::optional<std::unique_ptr<DarwinSDKInfo>> CachedDarwinSDKInfo;

 

  bool WarnedDarwinSDKInfoMissing = false;

 

  Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,

       TranslationUnitKind TUKind = TU_Complete,

       CodeCompleteConsumer *CompletionConsumer = nullptr);

  ~Sema();

 

  /// Perform initialization that occurs after the parser has been

  /// initialized but before it parses anything.

  void Initialize();

 

  /// This virtual key function only exists to limit the emission of debug info

  /// describing the Sema class. GCC and Clang only emit debug info for a class

  /// with a vtable when the vtable is emitted. Sema is final and not

  /// polymorphic, but the debug info size savings are so significant that it is

  /// worth adding a vtable just to take advantage of this optimization.

  virtual void anchor();

 

  const LangOptions &getLangOpts() const { return LangOpts; }

  OpenCLOptions &getOpenCLOptions() { return OpenCLFeatures; }

  FPOptions     &getCurFPFeatures() { return CurFPFeatures; }

 

  DiagnosticsEngine &getDiagnostics() const { return Diags; }

  SourceManager &getSourceManager() const { return SourceMgr; }

  Preprocessor &getPreprocessor() const { return PP; }

  ASTContext &getASTContext() const { return Context; }

  ASTConsumer &getASTConsumer() const { return Consumer; }

  ASTMutationListener *getASTMutationListener() const;

  ExternalSemaSource *getExternalSource() const { return ExternalSource.get(); }

 

  DarwinSDKInfo *getDarwinSDKInfoForAvailabilityChecking(SourceLocation Loc,

                                                         StringRef Platform);

  DarwinSDKInfo *getDarwinSDKInfoForAvailabilityChecking();

 

  ///Registers an external source. If an external source already exists,

  /// creates a multiplex external source and appends to it.

  ///

  ///\param[in] E - A non-null external sema source.

  ///

  void addExternalSource(ExternalSemaSource *E);

 

  void PrintStats() const;

 

  /// Warn that the stack is nearly exhausted.

  void warnStackExhausted(SourceLocation Loc);

 

  /// Run some code with "sufficient" stack space. (Currently, at least 256K is

  /// guaranteed). Produces a warning if we're low on stack space and allocates

  /// more in that case. Use this in code that may recurse deeply (for example,

  /// in template instantiation) to avoid stack overflow.

  void runWithSufficientStackSpace(SourceLocation Loc,

                                   llvm::function_ref<void()> Fn);

 

  /// Helper class that creates diagnostics with optional

  /// template instantiation stacks.

  ///

  /// This class provides a wrapper around the basic DiagnosticBuilder

  /// class that emits diagnostics. ImmediateDiagBuilder is

  /// responsible for emitting the diagnostic (as DiagnosticBuilder

  /// does) and, if the diagnostic comes from inside a template

  /// instantiation, printing the template instantiation stack as

  /// well.

  class ImmediateDiagBuilder : public DiagnosticBuilder {

    Sema &SemaRef;

    unsigned DiagID;

 

  public:

    ImmediateDiagBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)

        : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}

    ImmediateDiagBuilder(DiagnosticBuilder &&DB, Sema &SemaRef, unsigned DiagID)

        : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) {}

 

    // This is a cunning lie. DiagnosticBuilder actually performs move

    // construction in its copy constructor (but due to varied uses, it's not

    // possible to conveniently express this as actual move construction). So

    // the default copy ctor here is fine, because the base class disables the

    // source anyway, so the user-defined ~ImmediateDiagBuilder is a safe no-op

    // in that case anwyay.

    ImmediateDiagBuilder(const ImmediateDiagBuilder &) = default;

 

    ~ImmediateDiagBuilder() {

      // If we aren't active, there is nothing to do.

      if (!isActive()) return;

 

      // Otherwise, we need to emit the diagnostic. First clear the diagnostic

      // builder itself so it won't emit the diagnostic in its own destructor.

      //

      // This seems wasteful, in that as written the DiagnosticBuilder dtor will

      // do its own needless checks to see if the diagnostic needs to be

      // emitted. However, because we take care to ensure that the builder

      // objects never escape, a sufficiently smart compiler will be able to

      // eliminate that code.

      Clear();

 

      // Dispatch to Sema to emit the diagnostic.

      SemaRef.EmitCurrentDiagnostic(DiagID);

    }

 

    /// Teach operator<< to produce an object of the correct type.

    template <typename T>

    friend const ImmediateDiagBuilder &

    operator<<(const ImmediateDiagBuilder &Diag, const T &Value) {

      const DiagnosticBuilder &BaseDiag = Diag;

      BaseDiag << Value;

      return Diag;

    }

 

    // It is necessary to limit this to rvalue reference to avoid calling this

    // function with a bitfield lvalue argument since non-const reference to

    // bitfield is not allowed.

    template <typename T,

              typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>

    const ImmediateDiagBuilder &operator<<(T &&V) const {

      const DiagnosticBuilder &BaseDiag = *this;

      BaseDiag << std::move(V);

      return *this;

    }

  };

 

  /// A generic diagnostic builder for errors which may or may not be deferred.

  ///

  /// In CUDA, there exist constructs (e.g. variable-length arrays, try/catch)

  /// which are not allowed to appear inside __device__ functions and are

  /// allowed to appear in __host__ __device__ functions only if the host+device

  /// function is never codegen'ed.

  ///

  /// To handle this, we use the notion of "deferred diagnostics", where we

  /// attach a diagnostic to a FunctionDecl that's emitted iff it's codegen'ed.

  ///

  /// This class lets you emit either a regular diagnostic, a deferred

  /// diagnostic, or no diagnostic at all, according to an argument you pass to

  /// its constructor, thus simplifying the process of creating these "maybe

  /// deferred" diagnostics.

  class SemaDiagnosticBuilder {

  public:

    enum Kind {

      /// Emit no diagnostics.

      K_Nop,

      /// Emit the diagnostic immediately (i.e., behave like Sema::Diag()).

      K_Immediate,

      /// Emit the diagnostic immediately, and, if it's a warning or error, also

      /// emit a call stack showing how this function can be reached by an a

      /// priori known-emitted function.

      K_ImmediateWithCallStack,

      /// Create a deferred diagnostic, which is emitted only if the function

      /// it's attached to is codegen'ed.  Also emit a call stack as with

      /// K_ImmediateWithCallStack.

      K_Deferred

    };

 

    SemaDiagnosticBuilder(Kind K, SourceLocation Loc, unsigned DiagID,

                          FunctionDecl *Fn, Sema &S);

    SemaDiagnosticBuilder(SemaDiagnosticBuilder &&D);

    SemaDiagnosticBuilder(const SemaDiagnosticBuilder &) = default;

    ~SemaDiagnosticBuilder();

 

    bool isImmediate() const { return ImmediateDiag.has_value(); }

 

    /// Convertible to bool: True if we immediately emitted an error, false if

    /// we didn't emit an error or we created a deferred error.

    ///

    /// Example usage:

    ///

    ///   if (SemaDiagnosticBuilder(...) << foo << bar)

    ///     return ExprError();

    ///

    /// But see CUDADiagIfDeviceCode() and CUDADiagIfHostCode() -- you probably

    /// want to use these instead of creating a SemaDiagnosticBuilder yourself.

    operator bool() const { return isImmediate(); }

 

    template <typename T>

    friend const SemaDiagnosticBuilder &

    operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) {

      if (Diag.ImmediateDiag)

        *Diag.ImmediateDiag << Value;

      else if (Diag.PartialDiagId)

        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second

            << Value;

      return Diag;

    }

 

    // It is necessary to limit this to rvalue reference to avoid calling this

    // function with a bitfield lvalue argument since non-const reference to

    // bitfield is not allowed.

    template <typename T,

              typename = std::enable_if_t<!std::is_lvalue_reference<T>::value>>

    const SemaDiagnosticBuilder &operator<<(T &&V) const {

      if (ImmediateDiag)

        *ImmediateDiag << std::move(V);

      else if (PartialDiagId)

        S.DeviceDeferredDiags[Fn][*PartialDiagId].second << std::move(V);

      return *this;

    }

 

    friend const SemaDiagnosticBuilder &

    operator<<(const SemaDiagnosticBuilder &Diag, const PartialDiagnostic &PD) {

      if (Diag.ImmediateDiag)

        PD.Emit(*Diag.ImmediateDiag);

      else if (Diag.PartialDiagId)

        Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second = PD;

      return Diag;

    }

 

    void AddFixItHint(const FixItHint &Hint) const {

      if (ImmediateDiag)

        ImmediateDiag->AddFixItHint(Hint);

      else if (PartialDiagId)

        S.DeviceDeferredDiags[Fn][*PartialDiagId].second.AddFixItHint(Hint);

    }

 

    friend ExprResult ExprError(const SemaDiagnosticBuilder &) {

      return ExprError();

    }

    friend StmtResult StmtError(const SemaDiagnosticBuilder &) {

      return StmtError();

    }

    operator ExprResult() const { return ExprError(); }

    operator StmtResult() const { return StmtError(); }

    operator TypeResult() const { return TypeError(); }

    operator DeclResult() const { return DeclResult(true); }

    operator MemInitResult() const { return MemInitResult(true); }

 

  private:

    Sema &S;

    SourceLocation Loc;

    unsigned DiagID;

    FunctionDecl *Fn;

    bool ShowCallStack;

 

    // Invariant: At most one of these Optionals has a value.

    // FIXME: Switch these to a Variant once that exists.

    std::optional<ImmediateDiagBuilder> ImmediateDiag;

    std::optional<unsigned> PartialDiagId;

  };

 

  /// Is the last error level diagnostic immediate. This is used to determined

  /// whether the next info diagnostic should be immediate.

  bool IsLastErrorImmediate = true;

 

  /// Emit a diagnostic.

  SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID,

                             bool DeferHint = false);

 

  /// Emit a partial diagnostic.

  SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic &PD,

                             bool DeferHint = false);

 

  /// Build a partial diagnostic.

  PartialDiagnostic PDiag(unsigned DiagID = 0); // in SemaInternal.h

 

  /// Whether deferrable diagnostics should be deferred.

  bool DeferDiags = false;

 

  /// RAII class to control scope of DeferDiags.

  class DeferDiagsRAII {

    Sema &S;

    bool SavedDeferDiags = false;

 

  public:

    DeferDiagsRAII(Sema &S, bool DeferDiags)

        : S(S), SavedDeferDiags(S.DeferDiags) {

      S.DeferDiags = DeferDiags;

    }

    ~DeferDiagsRAII() { S.DeferDiags = SavedDeferDiags; }