//===- DeclarationName.h - Representation of declaration names --*- 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 declares the DeclarationName and DeclarationNameTable classes.

//

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

#ifndef LLVM_CLANG_AST_DECLARATIONNAME_H

#define LLVM_CLANG_AST_DECLARATIONNAME_H

#include "clang/AST/Type.h"

#include "clang/Basic/Diagnostic.h"

#include "clang/Basic/IdentifierTable.h"

#include "clang/Basic/OperatorKinds.h"

#include "clang/Basic/PartialDiagnostic.h"

#include "clang/Basic/SourceLocation.h"

#include "llvm/ADT/DenseMapInfo.h"

#include "llvm/ADT/FoldingSet.h"

#include "llvm/ADT/STLExtras.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/type_traits.h"

#include <cassert>

#include <cstdint>

#include <cstring>

#include <string>

namespace clang {

class ASTContext;

template <typename> class CanQual;

class DeclarationName;

class DeclarationNameTable;

struct PrintingPolicy;

class TemplateDecl;

class TypeSourceInfo;

using CanQualType = CanQual<Type>;

namespace detail {

/// CXXSpecialNameExtra records the type associated with one of the "special"

/// kinds of declaration names in C++, e.g., constructors, destructors, and

/// conversion functions. Note that CXXSpecialName is used for C++ constructor,

/// destructor and conversion functions, but the actual kind is not stored in

/// CXXSpecialName. Instead we use three different FoldingSet<CXXSpecialName>

/// in DeclarationNameTable.

class alignas(IdentifierInfoAlignment) CXXSpecialNameExtra

    : public llvm::FoldingSetNode {

  friend class clang::DeclarationName;

  friend class clang::DeclarationNameTable;

  /// The type associated with this declaration name.

  QualType Type;

  /// Extra information associated with this declaration name that

  /// can be used by the front end. All bits are really needed

  /// so it is not possible to stash something in the low order bits.

  void *FETokenInfo;

  CXXSpecialNameExtra(QualType QT) : Type(QT), FETokenInfo(nullptr) {}

public:

  void Profile(llvm::FoldingSetNodeID &ID) {

    ID.AddPointer(Type.getAsOpaquePtr());

  }

};

/// Contains extra information for the name of a C++ deduction guide.

class alignas(IdentifierInfoAlignment) CXXDeductionGuideNameExtra

    : public detail::DeclarationNameExtra,

      public llvm::FoldingSetNode {

  friend class clang::DeclarationName;

  friend class clang::DeclarationNameTable;

  /// The template named by the deduction guide.

  TemplateDecl *Template;

  /// Extra information associated with this operator name that

  /// can be used by the front end. All bits are really needed

  /// so it is not possible to stash something in the low order bits.

  void *FETokenInfo;

  CXXDeductionGuideNameExtra(TemplateDecl *TD)

      : DeclarationNameExtra(CXXDeductionGuideName), Template(TD),

        FETokenInfo(nullptr) {}

public:

  void Profile(llvm::FoldingSetNodeID &ID) { ID.AddPointer(Template); }

};

/// Contains extra information for the name of an overloaded operator

/// in C++, such as "operator+. This do not includes literal or conversion

/// operators. For literal operators see CXXLiteralOperatorIdName and for

/// conversion operators see CXXSpecialNameExtra.

class alignas(IdentifierInfoAlignment) CXXOperatorIdName {

  friend class clang::DeclarationName;

  friend class clang::DeclarationNameTable;

  /// The kind of this operator.

  OverloadedOperatorKind Kind = OO_None;

  /// Extra information associated with this operator name that

  /// can be used by the front end. All bits are really needed

  /// so it is not possible to stash something in the low order bits.

  void *FETokenInfo = nullptr;

};

/// Contains the actual identifier that makes up the

/// name of a C++ literal operator.

class alignas(IdentifierInfoAlignment) CXXLiteralOperatorIdName

    : public detail::DeclarationNameExtra,

      public llvm::FoldingSetNode {

  friend class clang::DeclarationName;

  friend class clang::DeclarationNameTable;

  IdentifierInfo *ID;

  /// Extra information associated with this operator name that

  /// can be used by the front end. All bits are really needed

  /// so it is not possible to stash something in the low order bits.

  void *FETokenInfo;

  CXXLiteralOperatorIdName(IdentifierInfo *II)

      : DeclarationNameExtra(CXXLiteralOperatorName), ID(II),

        FETokenInfo(nullptr) {}

public:

  void Profile(llvm::FoldingSetNodeID &FSID) { FSID.AddPointer(ID); }

};

} // namespace detail

/// The name of a declaration. In the common case, this just stores

/// an IdentifierInfo pointer to a normal name. However, it also provides

/// encodings for Objective-C selectors (optimizing zero- and one-argument

/// selectors, which make up 78% percent of all selectors in Cocoa.h),

/// special C++ names for constructors, destructors, and conversion functions,

/// and C++ overloaded operators.

class DeclarationName {

  friend class DeclarationNameTable;

  friend class NamedDecl;

  /// StoredNameKind represent the kind of name that is actually stored in the

  /// upper bits of the Ptr field. This is only used internally.

  ///

  /// NameKind, StoredNameKind, and DeclarationNameExtra::ExtraKind

  /// must satisfy the following properties. These properties enable

  /// efficient conversion between the various kinds.

  ///

  /// * The first seven enumerators of StoredNameKind must have the same

  ///   numerical value as the first seven enumerators of NameKind.

  ///   This enable efficient conversion between the two enumerations

  ///   in the usual case.

  ///

  /// * The enumerations values of DeclarationNameExtra::ExtraKind must start

  ///   at zero, and correspond to the numerical value of the first non-inline

  ///   enumeration values of NameKind minus an offset. This makes conversion

  ///   between DeclarationNameExtra::ExtraKind and NameKind possible with

  ///   a single addition/substraction.

  ///

  /// * The enumeration values of Selector::IdentifierInfoFlag must correspond

  ///   to the relevant enumeration values of StoredNameKind.

  ///   More specifically:

  ///    * ZeroArg == StoredObjCZeroArgSelector,

  ///    * OneArg == StoredObjCOneArgSelector,

  ///    * MultiArg == StoredDeclarationNameExtra

  ///

  /// * PtrMask must mask the low 3 bits of Ptr.

  enum StoredNameKind {

    StoredIdentifier = 0,

    StoredObjCZeroArgSelector = Selector::ZeroArg,

    StoredObjCOneArgSelector = Selector::OneArg,

    StoredCXXConstructorName = 3,

    StoredCXXDestructorName = 4,

    StoredCXXConversionFunctionName = 5,

    StoredCXXOperatorName = 6,

    StoredDeclarationNameExtra = Selector::MultiArg,

    PtrMask = 7,

    UncommonNameKindOffset = 8

  };

  static_assert(alignof(IdentifierInfo) >= 8 &&

                    alignof(detail::DeclarationNameExtra) >= 8 &&

                    alignof(detail::CXXSpecialNameExtra) >= 8 &&

                    alignof(detail::CXXOperatorIdName) >= 8 &&

                    alignof(detail::CXXDeductionGuideNameExtra) >= 8 &&

                    alignof(detail::CXXLiteralOperatorIdName) >= 8,

                "The various classes that DeclarationName::Ptr can point to"

                " must be at least aligned to 8 bytes!");

  static_assert(

      std::is_same<std::underlying_type_t<StoredNameKind>,

                   std::underlying_type_t<

                       detail::DeclarationNameExtra::ExtraKind>>::value,

      "The various enums used to compute values for NameKind should "

      "all have the same underlying type");

public:

  /// The kind of the name stored in this DeclarationName.

  /// The first 7 enumeration values are stored inline and correspond

  /// to frequently used kinds. The rest is stored in DeclarationNameExtra

  /// and correspond to infrequently used kinds.

  enum NameKind {

    Identifier = StoredIdentifier,

    ObjCZeroArgSelector = StoredObjCZeroArgSelector,

    ObjCOneArgSelector = StoredObjCOneArgSelector,

    CXXConstructorName = StoredCXXConstructorName,

    CXXDestructorName = StoredCXXDestructorName,

    CXXConversionFunctionName = StoredCXXConversionFunctionName,

    CXXOperatorName = StoredCXXOperatorName,

    CXXDeductionGuideName = llvm::addEnumValues(

        UncommonNameKindOffset,

        detail::DeclarationNameExtra::CXXDeductionGuideName),

    CXXLiteralOperatorName = llvm::addEnumValues(

        UncommonNameKindOffset,

        detail::DeclarationNameExtra::CXXLiteralOperatorName),

    CXXUsingDirective =

        llvm::addEnumValues(UncommonNameKindOffset,

                            detail::DeclarationNameExtra::CXXUsingDirective),

    ObjCMultiArgSelector =

        llvm::addEnumValues(UncommonNameKindOffset,

                            detail::DeclarationNameExtra::ObjCMultiArgSelector),

  };

private:

  /// The lowest three bits of Ptr are used to express what kind of name

  /// we're actually storing, using the values of StoredNameKind. Depending

  /// on the kind of name this is, the upper bits of Ptr may have one

  /// of several different meanings:

  ///

  ///   StoredIdentifier - The name is a normal identifier, and Ptr is

  ///   a normal IdentifierInfo pointer.

  ///

  ///   StoredObjCZeroArgSelector - The name is an Objective-C

  ///   selector with zero arguments, and Ptr is an IdentifierInfo

  ///   pointer pointing to the selector name.

  ///

  ///   StoredObjCOneArgSelector - The name is an Objective-C selector

  ///   with one argument, and Ptr is an IdentifierInfo pointer

  ///   pointing to the selector name.

  ///

  ///   StoredCXXConstructorName - The name of a C++ constructor,

  ///   Ptr points to a CXXSpecialNameExtra.

  ///

  ///   StoredCXXDestructorName - The name of a C++ destructor,

  ///   Ptr points to a CXXSpecialNameExtra.

  ///

  ///   StoredCXXConversionFunctionName - The name of a C++ conversion function,

  ///   Ptr points to a CXXSpecialNameExtra.

  ///

  ///   StoredCXXOperatorName - The name of an overloaded C++ operator,

  ///   Ptr points to a CXXOperatorIdName.

  ///

  ///   StoredDeclarationNameExtra - Ptr is actually a pointer to a

  ///   DeclarationNameExtra structure, whose first value will tell us

  ///   whether this is an Objective-C selector, C++ deduction guide,

  ///   C++ literal operator, or C++ using directive.

  uintptr_t Ptr = 0;

  StoredNameKind getStoredNameKind() const {

    return static_cast<StoredNameKind>(Ptr & PtrMask);

  }

  void *getPtr() const { return reinterpret_cast<void *>(Ptr & ~PtrMask); }

  void setPtrAndKind(const void *P, StoredNameKind Kind) {

    uintptr_t PAsInteger = reinterpret_cast<uintptr_t>(P);

    assert((Kind & ~PtrMask) == 0 &&

           "Invalid StoredNameKind in setPtrAndKind!");

    assert((PAsInteger & PtrMask) == 0 &&

           "Improperly aligned pointer in setPtrAndKind!");

    Ptr = PAsInteger | Kind;

  }

  /// Construct a declaration name from a DeclarationNameExtra.

  DeclarationName(detail::DeclarationNameExtra *Name) {

    setPtrAndKind(Name, StoredDeclarationNameExtra);

  }

  /// Construct a declaration name from a CXXSpecialNameExtra.

  DeclarationName(detail::CXXSpecialNameExtra *Name,

                  StoredNameKind StoredKind) {

    assert((StoredKind == StoredCXXConstructorName ||

           StoredKind == StoredCXXDestructorName ||

           StoredKind == StoredCXXConversionFunctionName) &&

               "Invalid StoredNameKind when constructing a DeclarationName"

               " from a CXXSpecialNameExtra!");

    setPtrAndKind(Name, StoredKind);

  }

  /// Construct a DeclarationName from a CXXOperatorIdName.

  DeclarationName(detail::CXXOperatorIdName *Name) {

    setPtrAndKind(Name, StoredCXXOperatorName);

  }

  /// Assert that the stored pointer points to an IdentifierInfo and return it.

  IdentifierInfo *castAsIdentifierInfo() const {

    assert((getStoredNameKind() == StoredIdentifier) &&

           "DeclarationName does not store an IdentifierInfo!");

    return static_cast<IdentifierInfo *>(getPtr());

  }

  /// Assert that the stored pointer points to a DeclarationNameExtra

  /// and return it.

  detail::DeclarationNameExtra *castAsExtra() const {

    assert((getStoredNameKind() == StoredDeclarationNameExtra) &&

           "DeclarationName does not store an Extra structure!");

    return static_cast<detail::DeclarationNameExtra *>(getPtr());

  }

  /// Assert that the stored pointer points to a CXXSpecialNameExtra

  /// and return it.

  detail::CXXSpecialNameExtra *castAsCXXSpecialNameExtra() const {

    assert((getStoredNameKind() == StoredCXXConstructorName ||

           getStoredNameKind() == StoredCXXDestructorName ||

           getStoredNameKind() == StoredCXXConversionFunctionName) &&

               "DeclarationName does not store a CXXSpecialNameExtra!");

    return static_cast<detail::CXXSpecialNameExtra *>(getPtr());

  }

  /// Assert that the stored pointer points to a CXXOperatorIdName

  /// and return it.

  detail::CXXOperatorIdName *castAsCXXOperatorIdName() const {

    assert((getStoredNameKind() == StoredCXXOperatorName) &&

           "DeclarationName does not store a CXXOperatorIdName!");

    return static_cast<detail::CXXOperatorIdName *>(getPtr());

  }

  /// Assert that the stored pointer points to a CXXDeductionGuideNameExtra

  /// and return it.

  detail::CXXDeductionGuideNameExtra *castAsCXXDeductionGuideNameExtra() const {

    assert(getNameKind() == CXXDeductionGuideName &&

           "DeclarationName does not store a CXXDeductionGuideNameExtra!");

    return static_cast<detail::CXXDeductionGuideNameExtra *>(getPtr());

  }

  /// Assert that the stored pointer points to a CXXLiteralOperatorIdName

  /// and return it.

  detail::CXXLiteralOperatorIdName *castAsCXXLiteralOperatorIdName() const {

    assert(getNameKind() == CXXLiteralOperatorName &&

           "DeclarationName does not store a CXXLiteralOperatorIdName!");

    return static_cast<detail::CXXLiteralOperatorIdName *>(getPtr());

  }

  /// Get and set the FETokenInfo in the less common cases where the

  /// declaration name do not point to an identifier.

  void *getFETokenInfoSlow() const;

  void setFETokenInfoSlow(void *T);

public:

  /// Construct an empty declaration name.

  DeclarationName() { setPtrAndKind(nullptr, StoredIdentifier); }

  /// Construct a declaration name from an IdentifierInfo *.

  DeclarationName(const IdentifierInfo *II) {

    setPtrAndKind(II, StoredIdentifier);

  }

  /// Construct a declaration name from an Objective-C selector.

  DeclarationName(Selector Sel) : Ptr(Sel.InfoPtr) {}

  /// Returns the name for all C++ using-directives.

  static DeclarationName getUsingDirectiveName() {

    // Single instance of DeclarationNameExtra for using-directive

    static detail::DeclarationNameExtra UDirExtra(

        detail::DeclarationNameExtra::CXXUsingDirective);

    return DeclarationName(&UDirExtra);

  }

  /// Evaluates true when this declaration name is non-empty.

  explicit operator bool() const {

    return getPtr() || 
(getStoredNameKind() != StoredIdentifier)112M
;

  }

  /// Evaluates true when this declaration name is empty.

  bool isEmpty() const { return !*this; }

  /// Predicate functions for querying what type of name this is.

  bool isIdentifier() const { return getStoredNameKind() == StoredIdentifier; }

  bool isObjCZeroArgSelector() const {

    return getStoredNameKind() == StoredObjCZeroArgSelector;

  }

  bool isObjCOneArgSelector() const {

    return getStoredNameKind() == StoredObjCOneArgSelector;

  }

  /// Determine what kind of name this is.

  NameKind getNameKind() const {

    // We rely on the fact that the first 7 NameKind and StoredNameKind

    // have the same numerical value. This makes the usual case efficient.

    StoredNameKind StoredKind = getStoredNameKind();

    if (StoredKind != StoredDeclarationNameExtra)

      return static_cast<NameKind>(StoredKind);

    // We have to consult DeclarationNameExtra. We rely on the fact that the

    // enumeration values of ExtraKind correspond to the enumeration values of

    // NameKind minus an offset of UncommonNameKindOffset.

    unsigned ExtraKind = castAsExtra()->getKind();

    return static_cast<NameKind>(UncommonNameKindOffset + ExtraKind);

  }

  /// Determines whether the name itself is dependent, e.g., because it

  /// involves a C++ type that is itself dependent.

  ///

  /// Note that this does not capture all of the notions of "dependent name",

  /// because an identifier can be a dependent name if it is used as the

  /// callee in a call expression with dependent arguments.

  bool isDependentName() const;

  /// Retrieve the human-readable string for this name.

  std::string getAsString() const;

  /// Retrieve the IdentifierInfo * stored in this declaration name,

  /// or null if this declaration name isn't a simple identifier.

  IdentifierInfo *getAsIdentifierInfo() const {

    if (isIdentifier())

      return castAsIdentifierInfo();

    return nullptr;

  }

  /// Get the representation of this declaration name as an opaque integer.

  uintptr_t getAsOpaqueInteger() const { return Ptr; }

  /// Get the representation of this declaration name as an opaque pointer.

  void *getAsOpaquePtr() const { return reinterpret_cast<void *>(Ptr); }

  /// Get a declaration name from an opaque pointer returned by getAsOpaquePtr.

  static DeclarationName getFromOpaquePtr(void *P) {

    DeclarationName N;

    N.Ptr = reinterpret_cast<uintptr_t>(P);

    return N;

  }

  /// Get a declaration name from an opaque integer

  /// returned by getAsOpaqueInteger.

  static DeclarationName getFromOpaqueInteger(uintptr_t P) {

    DeclarationName N;

    N.Ptr = P;

    return N;

  }

  /// If this name is one of the C++ names (of a constructor, destructor,

  /// or conversion function), return the type associated with that name.

  QualType getCXXNameType() const {

    if (getStoredNameKind() == StoredCXXConstructorName ||

        
getStoredNameKind() == StoredCXXDestructorName1.15M
 ||

        
getStoredNameKind() == StoredCXXConversionFunctionName1.07M
) {

      assert(getPtr() && "getCXXNameType on a null DeclarationName!");

      return castAsCXXSpecialNameExtra()->Type;

    }

    return QualType();

  }

  /// If this name is the name of a C++ deduction guide, return the

  /// template associated with that name.

  TemplateDecl *getCXXDeductionGuideTemplate() const {

    if (getNameKind() == CXXDeductionGuideName) {

      assert(getPtr() &&

             "getCXXDeductionGuideTemplate on a null DeclarationName!");

      return castAsCXXDeductionGuideNameExtra()->Template;

    }

    return nullptr;

  }

  /// If this name is the name of an overloadable operator in C++

  /// (e.g., @c operator+), retrieve the kind of overloaded operator.

  OverloadedOperatorKind getCXXOverloadedOperator() const {

    if (getStoredNameKind() == StoredCXXOperatorName) {

      assert(getPtr() && "getCXXOverloadedOperator on a null DeclarationName!");

      return castAsCXXOperatorIdName()->Kind;

    }

    return OO_None;

  }

  /// If this name is the name of a literal operator,

  /// retrieve the identifier associated with it.

  IdentifierInfo *getCXXLiteralIdentifier() const {

    if (getNameKind() == CXXLiteralOperatorName) {

      assert(getPtr() && "getCXXLiteralIdentifier on a null DeclarationName!");

      return castAsCXXLiteralOperatorIdName()->ID;

    }

    return nullptr;

  }

  /// Get the Objective-C selector stored in this declaration name.

  Selector getObjCSelector() const {

    assert((getNameKind() == ObjCZeroArgSelector ||

            getNameKind() == ObjCOneArgSelector ||

            getNameKind() == ObjCMultiArgSelector || !getPtr()) &&

           "Not a selector!");

    return Selector(Ptr);

  }

  /// Get and set FETokenInfo. The language front-end is allowed to associate

  /// arbitrary metadata with some kinds of declaration names, including normal

  /// identifiers and C++ constructors, destructors, and conversion functions.

  void *getFETokenInfo() const {

    assert(getPtr() && "getFETokenInfo on an empty DeclarationName!");

    if (getStoredNameKind() == StoredIdentifier)

      return castAsIdentifierInfo()->getFETokenInfo();

    return getFETokenInfoSlow();

  }

  void setFETokenInfo(void *T) {

    assert(getPtr() && "setFETokenInfo on an empty DeclarationName!");

    if (getStoredNameKind() == StoredIdentifier)

      castAsIdentifierInfo()->setFETokenInfo(T);

    else

      setFETokenInfoSlow(T);

  }

  /// Determine whether the specified names are identical.

  friend bool operator==(DeclarationName LHS, DeclarationName RHS) {

    return LHS.Ptr == RHS.Ptr;

  }

  /// Determine whether the specified names are different.

  friend bool operator!=(DeclarationName LHS, DeclarationName RHS) {

    return LHS.Ptr != RHS.Ptr;

  }

  static DeclarationName getEmptyMarker() {

    DeclarationName Name;

    Name.Ptr = uintptr_t(-1);

    return Name;

  }

  static DeclarationName getTombstoneMarker() {

    DeclarationName Name;

    Name.Ptr = uintptr_t(-2);

    return Name;

  }

  static int compare(DeclarationName LHS, DeclarationName RHS);

  void print(raw_ostream &OS, const PrintingPolicy &Policy) const;

  void dump() const;

};

raw_ostream &operator<<(raw_ostream &OS, DeclarationName N);

/// Ordering on two declaration names. If both names are identifiers,

/// this provides a lexicographical ordering.

inline bool operator<(DeclarationName LHS, DeclarationName RHS) {

  return DeclarationName::compare(LHS, RHS) < 0;

}

/// Ordering on two declaration names. If both names are identifiers,

/// this provides a lexicographical ordering.

inline bool operator>(DeclarationName LHS, DeclarationName RHS) {

  return DeclarationName::compare(LHS, RHS) > 0;

}

/// Ordering on two declaration names. If both names are identifiers,

/// this provides a lexicographical ordering.

inline bool operator<=(DeclarationName LHS, DeclarationName RHS) {

  return DeclarationName::compare(LHS, RHS) <= 0;

}

/// Ordering on two declaration names. If both names are identifiers,

/// this provides a lexicographical ordering.

inline bool operator>=(DeclarationName LHS, DeclarationName RHS) {

  return DeclarationName::compare(LHS, RHS) >= 0;

}

/// DeclarationNameTable is used to store and retrieve DeclarationName

/// instances for the various kinds of declaration names, e.g., normal

/// identifiers, C++ constructor names, etc. This class contains

/// uniqued versions of each of the C++ special names, which can be

/// retrieved using its member functions (e.g., getCXXConstructorName).

class DeclarationNameTable {

  /// Used to allocate elements in the FoldingSets below.

  const ASTContext &Ctx;

  /// Manage the uniqued CXXSpecialNameExtra representing C++ constructors.

  /// getCXXConstructorName and getCXXSpecialName can be used to obtain

  /// a DeclarationName from the corresponding type of the constructor.

  llvm::FoldingSet<detail::CXXSpecialNameExtra> CXXConstructorNames;

  /// Manage the uniqued CXXSpecialNameExtra representing C++ destructors.

  /// getCXXDestructorName and getCXXSpecialName can be used to obtain

  /// a DeclarationName from the corresponding type of the destructor.

  llvm::FoldingSet<detail::CXXSpecialNameExtra> CXXDestructorNames;

  /// Manage the uniqued CXXSpecialNameExtra representing C++ conversion

  /// functions. getCXXConversionFunctionName and getCXXSpecialName can be

  /// used to obtain a DeclarationName from the corresponding type of the

  /// conversion function.

  llvm::FoldingSet<detail::CXXSpecialNameExtra> CXXConversionFunctionNames;

  /// Manage the uniqued CXXOperatorIdName, which contain extra information

  /// for the name of overloaded C++ operators. getCXXOperatorName

  /// can be used to obtain a DeclarationName from the operator kind.

  detail::CXXOperatorIdName CXXOperatorNames[NUM_OVERLOADED_OPERATORS];

  /// Manage the uniqued CXXLiteralOperatorIdName, which contain extra

  /// information for the name of C++ literal operators.

  /// getCXXLiteralOperatorName can be used to obtain a DeclarationName

  /// from the corresponding IdentifierInfo.

  llvm::FoldingSet<detail::CXXLiteralOperatorIdName> CXXLiteralOperatorNames;

  /// Manage the uniqued CXXDeductionGuideNameExtra, which contain

  /// extra information for the name of a C++ deduction guide.

  /// getCXXDeductionGuideName can be used to obtain a DeclarationName

  /// from the corresponding template declaration.

  llvm::FoldingSet<detail::CXXDeductionGuideNameExtra> CXXDeductionGuideNames;

public:

  DeclarationNameTable(const ASTContext &C);

  DeclarationNameTable(const DeclarationNameTable &) = delete;

  DeclarationNameTable &operator=(const DeclarationNameTable &) = delete;

  DeclarationNameTable(DeclarationNameTable &&) = delete;

  DeclarationNameTable &operator=(DeclarationNameTable &&) = delete;

  ~DeclarationNameTable() = default;

  /// Create a declaration name that is a simple identifier.

  DeclarationName getIdentifier(const IdentifierInfo *ID) {

    return DeclarationName(ID);

  }

  /// Returns the name of a C++ constructor for the given Type.

  DeclarationName getCXXConstructorName(CanQualType Ty);

  /// Returns the name of a C++ destructor for the given Type.

  DeclarationName getCXXDestructorName(CanQualType Ty);

  /// Returns the name of a C++ deduction guide for the given template.

  DeclarationName getCXXDeductionGuideName(TemplateDecl *TD);

  /// Returns the name of a C++ conversion function for the given Type.

  DeclarationName getCXXConversionFunctionName(CanQualType Ty);

  /// Returns a declaration name for special kind of C++ name,

  /// e.g., for a constructor, destructor, or conversion function.

  /// Kind must be one of:

  ///   * DeclarationName::CXXConstructorName,

  ///   * DeclarationName::CXXDestructorName or

  ///   * DeclarationName::CXXConversionFunctionName

  DeclarationName getCXXSpecialName(DeclarationName::NameKind Kind,

                                    CanQualType Ty);

  /// Get the name of the overloadable C++ operator corresponding to Op.

  DeclarationName getCXXOperatorName(OverloadedOperatorKind Op) {

    return DeclarationName(&CXXOperatorNames[Op]);

  }

  /// Get the name of the literal operator function with II as the identifier.

  DeclarationName getCXXLiteralOperatorName(IdentifierInfo *II);

};

/// DeclarationNameLoc - Additional source/type location info

/// for a declaration name. Needs a DeclarationName in order

/// to be interpreted correctly.

class DeclarationNameLoc {

  // The source location for identifier stored elsewhere.

  // struct {} Identifier;

  // Type info for constructors, destructors and conversion functions.

  // Locations (if any) for the tilde (destructor) or operator keyword

  // (conversion) are stored elsewhere.

  struct NT {

    TypeSourceInfo *TInfo;

  };

  // The location (if any) of the operator keyword is stored elsewhere.

  struct CXXOpName {

    SourceLocation::UIntTy BeginOpNameLoc;

    SourceLocation::UIntTy EndOpNameLoc;

  };

  // The location (if any) of the operator keyword is stored elsewhere.

  struct CXXLitOpName {

    SourceLocation::UIntTy OpNameLoc;

  };

  // struct {} CXXUsingDirective;

  // struct {} ObjCZeroArgSelector;

  // struct {} ObjCOneArgSelector;

  // struct {} ObjCMultiArgSelector;

  union {

    struct NT NamedType;

    struct CXXOpName CXXOperatorName;

    struct CXXLitOpName CXXLiteralOperatorName;

  };

  void setNamedTypeLoc(TypeSourceInfo *TInfo) { NamedType.TInfo = TInfo; }

  void setCXXOperatorNameRange(SourceRange Range) {

    CXXOperatorName.BeginOpNameLoc = Range.getBegin().getRawEncoding();

    CXXOperatorName.EndOpNameLoc = Range.getEnd().getRawEncoding();

  }

  void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {

    CXXLiteralOperatorName.OpNameLoc = Loc.getRawEncoding();

  }

public:

  DeclarationNameLoc(DeclarationName Name);

  // FIXME: this should go away once all DNLocs are properly initialized.

  DeclarationNameLoc() { memset((void*) this, 0, sizeof(*this)); }

  /// Returns the source type info. Assumes that the object stores location

  /// information of a constructor, destructor or conversion operator.

  TypeSourceInfo *getNamedTypeInfo() const { return NamedType.TInfo; }

  /// Return the beginning location of the getCXXOperatorNameRange() range.

  SourceLocation getCXXOperatorNameBeginLoc() const {

    return SourceLocation::getFromRawEncoding(CXXOperatorName.BeginOpNameLoc);

  }

  /// Return the end location of the getCXXOperatorNameRange() range.

  SourceLocation getCXXOperatorNameEndLoc() const {

    return SourceLocation::getFromRawEncoding(CXXOperatorName.EndOpNameLoc);

  }

  /// Return the range of the operator name (without the operator keyword).

  /// Assumes that the object stores location information of a (non-literal)

  /// operator.

  SourceRange getCXXOperatorNameRange() const {

    return SourceRange(getCXXOperatorNameBeginLoc(),

                       getCXXOperatorNameEndLoc());

  }

  /// Return the location of the literal operator name (without the operator

  /// keyword). Assumes that the object stores location information of a literal

  /// operator.

  SourceLocation getCXXLiteralOperatorNameLoc() const {

    return SourceLocation::getFromRawEncoding(CXXLiteralOperatorName.OpNameLoc);

  }

  /// Construct location information for a constructor, destructor or conversion

  /// operator.

  static DeclarationNameLoc makeNamedTypeLoc(TypeSourceInfo *TInfo) {

    DeclarationNameLoc DNL;

    DNL.setNamedTypeLoc(TInfo);

    return DNL;

  }

  /// Construct location information for a non-literal C++ operator.

  static DeclarationNameLoc makeCXXOperatorNameLoc(SourceLocation BeginLoc,

                                                   SourceLocation EndLoc) {

    return makeCXXOperatorNameLoc(SourceRange(BeginLoc, EndLoc));

  }

  /// Construct location information for a non-literal C++ operator.

  static DeclarationNameLoc makeCXXOperatorNameLoc(SourceRange Range) {

    DeclarationNameLoc DNL;

    DNL.setCXXOperatorNameRange(Range);

    return DNL;

  }

  /// Construct location information for a literal C++ operator.

  static DeclarationNameLoc makeCXXLiteralOperatorNameLoc(SourceLocation Loc) {

    DeclarationNameLoc DNL;

    DNL.setCXXLiteralOperatorNameLoc(Loc);

    return DNL;

  }

};

/// DeclarationNameInfo - A collector data type for bundling together

/// a DeclarationName and the correspnding source/type location info.

struct DeclarationNameInfo {

private:

  /// Name - The declaration name, also encoding name kind.

  DeclarationName Name;

  /// Loc - The main source location for the declaration name.

  SourceLocation NameLoc;

  /// Info - Further source/type location info for special kinds of names.

  DeclarationNameLoc LocInfo;

public:

  // FIXME: remove it.

  DeclarationNameInfo() = default;

  DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc)

      : Name(Name), NameLoc(NameLoc), LocInfo(Name) {}

  DeclarationNameInfo(DeclarationName Name, SourceLocation NameLoc,

                      DeclarationNameLoc LocInfo)

      : Name(Name), NameLoc(NameLoc), LocInfo(LocInfo) {}

  /// getName - Returns the embedded declaration name.

  DeclarationName getName() const { return Name; }

  /// setName - Sets the embedded declaration name.

  void setName(DeclarationName N) { Name = N; }

  /// getLoc - Returns the main location of the declaration name.

  SourceLocation getLoc() const { return NameLoc; }

  /// setLoc - Sets the main location of the declaration name.

  void setLoc(SourceLocation L) { NameLoc = L; }

  const DeclarationNameLoc &getInfo() const { return LocInfo; }

  void setInfo(const DeclarationNameLoc &Info) { LocInfo = Info; }

  /// getNamedTypeInfo - Returns the source type info associated to

  /// the name. Assumes it is a constructor, destructor or conversion.

  TypeSourceInfo *getNamedTypeInfo() const {

    if (Name.getNameKind() != DeclarationName::CXXConstructorName &&

        
Name.getNameKind() != DeclarationName::CXXDestructorName136k
 &&

        
Name.getNameKind() != DeclarationName::CXXConversionFunctionName36.8k
)

      return nullptr;

    return LocInfo.getNamedTypeInfo();

  }

  /// setNamedTypeInfo - Sets the source type info associated to

  /// the name. Assumes it is a constructor, destructor or conversion.

  void setNamedTypeInfo(TypeSourceInfo *TInfo) {

    assert(Name.getNameKind() == DeclarationName::CXXConstructorName ||

           Name.getNameKind() == DeclarationName::CXXDestructorName ||

           Name.getNameKind() == DeclarationName::CXXConversionFunctionName);

    LocInfo = DeclarationNameLoc::makeNamedTypeLoc(TInfo);

  }

  /// getCXXOperatorNameRange - Gets the range of the operator name

  /// (without the operator keyword). Assumes it is a (non-literal) operator.

  SourceRange getCXXOperatorNameRange() const {

    if (Name.getNameKind() != DeclarationName::CXXOperatorName)

      return SourceRange();

    return LocInfo.getCXXOperatorNameRange();

  }

  /// setCXXOperatorNameRange - Sets the range of the operator name

  /// (without the operator keyword). Assumes it is a C++ operator.

  void setCXXOperatorNameRange(SourceRange R) {

    assert(Name.getNameKind() == DeclarationName::CXXOperatorName);

    LocInfo = DeclarationNameLoc::makeCXXOperatorNameLoc(R);

  }

  /// getCXXLiteralOperatorNameLoc - Returns the location of the literal

  /// operator name (not the operator keyword).

  /// Assumes it is a literal operator.

  SourceLocation getCXXLiteralOperatorNameLoc() const {

    if (Name.getNameKind() != DeclarationName::CXXLiteralOperatorName)

      return SourceLocation();

    return LocInfo.getCXXLiteralOperatorNameLoc();

  }

  /// setCXXLiteralOperatorNameLoc - Sets the location of the literal

  /// operator name (not the operator keyword).

  /// Assumes it is a literal operator.

  void setCXXLiteralOperatorNameLoc(SourceLocation Loc) {

    assert(Name.getNameKind() == DeclarationName::CXXLiteralOperatorName);

    LocInfo = DeclarationNameLoc::makeCXXLiteralOperatorNameLoc(Loc);

  }

  /// Determine whether this name involves a template parameter.

  bool isInstantiationDependent() const;

  /// Determine whether this name contains an unexpanded

  /// parameter pack.

  bool containsUnexpandedParameterPack() const;

  /// getAsString - Retrieve the human-readable string for this name.

  std::string getAsString() const;

  /// printName - Print the human-readable name to a stream.

  void printName(raw_ostream &OS, PrintingPolicy Policy) const;

  /// getBeginLoc - Retrieve the location of the first token.

  SourceLocation getBeginLoc() const { return NameLoc; }

  /// getSourceRange - The range of the declaration name.

  SourceRange getSourceRange() const LLVM_READONLY {

    return SourceRange(getBeginLoc(), getEndLoc());

  }

  SourceLocation getEndLoc() const LLVM_READONLY {

    SourceLocation EndLoc = getEndLocPrivate();

    return EndLoc.isValid() ? 
EndLoc41.7M
 : 
getBeginLoc()1.98M
;

  }

private:

  SourceLocation getEndLocPrivate() const;

};

/// Insertion operator for partial diagnostics.  This allows binding

/// DeclarationName's into a partial diagnostic with <<.

inline const StreamingDiagnostic &operator<<(const StreamingDiagnostic &PD,

                                             DeclarationName N) {

  PD.AddTaggedVal(N.getAsOpaqueInteger(),

                  DiagnosticsEngine::ak_declarationname);

  return PD;

}

raw_ostream &operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo);

} // namespace clang

namespace llvm {

/// Define DenseMapInfo so that DeclarationNames can be used as keys

/// in DenseMap and DenseSets.

template<>

struct DenseMapInfo<clang::DeclarationName> {

  static inline clang::DeclarationName getEmptyKey() {

    return clang::DeclarationName::getEmptyMarker();

  }

  static inline clang::DeclarationName getTombstoneKey() {

    return clang::DeclarationName::getTombstoneMarker();

  }

  static unsigned getHashValue(clang::DeclarationName Name) {

    return DenseMapInfo<void*>::getHashValue(Name.getAsOpaquePtr());

  }

  static inline bool

  isEqual(clang::DeclarationName LHS, clang::DeclarationName RHS) {

    return LHS == RHS;

  }

};

template <> struct PointerLikeTypeTraits<clang::DeclarationName> {

  static inline void *getAsVoidPointer(clang::DeclarationName P) {

    return P.getAsOpaquePtr();

  }

  static inline clang::DeclarationName getFromVoidPointer(void *P) {

    return clang::DeclarationName::getFromOpaquePtr(P);

  }

  static constexpr int NumLowBitsAvailable = 0;

};

} // namespace llvm

// The definition of AssumedTemplateStorage is factored out of TemplateName to

// resolve a cyclic dependency between it and DeclarationName (via Type).

namespace clang {

/// A structure for storing the information associated with a name that has

/// been assumed to be a template name (despite finding no TemplateDecls).

class AssumedTemplateStorage : public UncommonTemplateNameStorage {

  friend class ASTContext;

  AssumedTemplateStorage(DeclarationName Name)

      : UncommonTemplateNameStorage(Assumed, 0), Name(Name) {}

  DeclarationName Name;

public:

  /// Get the name of the template.

  DeclarationName getDeclName() const { return Name; }

};

} // namespace clang

#endif // LLVM_CLANG_AST_DECLARATIONNAME_H