/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/AST/DeclarationName.cpp

Source (jump to first uncovered line)
//===- DeclarationName.cpp - Declaration names implementation -------------===//
//
// 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 implements the DeclarationName and DeclarationNameTable
// classes.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/DeclarationName.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h"
#include "clang/AST/DeclBase.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/OpenMPClause.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/AST/TypeOrdering.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/OperatorKinds.h"
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <string>

using namespace clang;

static int compareInt(unsigned A, unsigned B) {
  return (A < B ? -111.0k : (7.11kA > B7.11k ? 17.03k : 078));
}

int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
  if (LHS.getNameKind() != RHS.getNameKind())
    return (LHS.getNameKind() < RHS.getNameKind() ? -1132k : 179.6k);

  switch (LHS.getNameKind()) {
  case DeclarationName::Identifier: {
    IdentifierInfo *LII = LHS.castAsIdentifierInfo();
    IdentifierInfo *RII = RHS.castAsIdentifierInfo();
    if (!LII)
      return RII ? -1 : 0;
    if (!RII)
      return 1;

    return LII->getName().compare(RII->getName());
  }

  case DeclarationName::ObjCZeroArgSelector:
  case DeclarationName::ObjCOneArgSelector:
  case DeclarationName::ObjCMultiArgSelector: {
    Selector LHSSelector = LHS.getObjCSelector();
    Selector RHSSelector = RHS.getObjCSelector();
    // getNumArgs for ZeroArgSelector returns 0, but we still need to compare.
    if (LHS.getNameKind() == DeclarationName::ObjCZeroArgSelector &&
        RHS.getNameKind() == DeclarationName::ObjCZeroArgSelector85.4k) {
      return LHSSelector.getAsIdentifierInfo()->getName().compare(
          RHSSelector.getAsIdentifierInfo()->getName());
    }
    unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
    for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I8.31k) {
      if (int Compare = LHSSelector.getNameForSlot(I).compare(
              RHSSelector.getNameForSlot(I)))
        return Compare;
    }

    return compareInt(LN, RN);
  }

  case DeclarationName::CXXConstructorName:
  case DeclarationName::CXXDestructorName:
  case DeclarationName::CXXConversionFunctionName:
    if (QualTypeOrdering()(LHS.getCXXNameType(), RHS.getCXXNameType()))
      return -1;
    if (QualTypeOrdering()(RHS.getCXXNameType(), LHS.getCXXNameType()))
      return 1;
    return 0;

  case DeclarationName::CXXDeductionGuideName:
    // We never want to compare deduction guide names for templates from
    // different scopes, so just compare the template-name.
    return compare(LHS.getCXXDeductionGuideTemplate()->getDeclName(),
                   RHS.getCXXDeductionGuideTemplate()->getDeclName());

  case DeclarationName::CXXOperatorName:
    return compareInt(LHS.getCXXOverloadedOperator(),
                      RHS.getCXXOverloadedOperator());

  case DeclarationName::CXXLiteralOperatorName:
    return LHS.getCXXLiteralIdentifier()->getName().compare(
        RHS.getCXXLiteralIdentifier()->getName());

  case DeclarationName::CXXUsingDirective:
    return 0;
  }

  llvm_unreachable("Invalid DeclarationName Kind!");
}

static void printCXXConstructorDestructorName(QualType ClassType,
                                              raw_ostream &OS,
                                              PrintingPolicy Policy) {
  // We know we're printing C++ here. Ensure we print types properly.
  Policy.adjustForCPlusPlus();

  if (const RecordType *ClassRec = ClassType->getAs<RecordType>()) {
    ClassRec->getDecl()->printName(OS, Policy);
    return;
  }
  if (Policy.SuppressTemplateArgsInCXXConstructors) {
    if (auto *InjTy = ClassType->getAs<InjectedClassNameType>()) {
      InjTy->getDecl()->printName(OS, Policy);
      return;
    }
  }
  ClassType.print(OS, Policy);
}

void DeclarationName::print(raw_ostream &OS,
                            const PrintingPolicy &Policy) const {
  switch (getNameKind()) {
  case DeclarationName::Identifier:
    if (const IdentifierInfo *II = getAsIdentifierInfo()) {
      StringRef Name = II->getName();
      // If this is a mangled OpenMP variant name we strip off the mangling for
      // printing. It should not be visible to the user at all.
      if (II->isMangledOpenMPVariantName()) {
        std::pair<StringRef, StringRef> NameContextPair =
            Name.split(getOpenMPVariantManglingSeparatorStr());
        OS << NameContextPair.first << "["
           << OMPTraitInfo(NameContextPair.second) << "]";
      } else {
        OS << Name;
      }
    }
    return;

  case DeclarationName::ObjCZeroArgSelector:
  case DeclarationName::ObjCOneArgSelector:
  case DeclarationName::ObjCMultiArgSelector:
    getObjCSelector().print(OS);
    return;

  case DeclarationName::CXXConstructorName:
    return printCXXConstructorDestructorName(getCXXNameType(), OS, Policy);

  case DeclarationName::CXXDestructorName:
    OS << '~';
    return printCXXConstructorDestructorName(getCXXNameType(), OS, Policy);

  case DeclarationName::CXXDeductionGuideName:
    OS << "<deduction guide for ";
    getCXXDeductionGuideTemplate()->getDeclName().print(OS, Policy);
    OS << '>';
    return;

  case DeclarationName::CXXOperatorName: {
    const char *OpName = getOperatorSpelling(getCXXOverloadedOperator());
    assert(OpName && "not an overloaded operator");

    OS << "operator";
    if (OpName[0] >= 'a' && OpName[0] <= 'z'18.1k)
      OS << ' ';
    OS << OpName;
    return;
  }

  case DeclarationName::CXXLiteralOperatorName:
    OS << "operator\"\"" << getCXXLiteralIdentifier()->getName();
    return;

  case DeclarationName::CXXConversionFunctionName: {
    OS << "operator ";
    QualType Type = getCXXNameType();
    if (const RecordType *Rec = Type->getAs<RecordType>()) {
      OS << *Rec->getDecl();
      return;
    }
    // We know we're printing C++ here, ensure we print 'bool' properly.
    PrintingPolicy CXXPolicy = Policy;
    CXXPolicy.adjustForCPlusPlus();
    Type.print(OS, CXXPolicy);
    return;
  }
  case DeclarationName::CXXUsingDirective:
    OS << "<using-directive>";
    return;
  }

  llvm_unreachable("Unexpected declaration name kind");
}

namespace clang {

raw_ostream &operator<<(raw_ostream &OS, DeclarationName N) {
  LangOptions LO;
  N.print(OS, PrintingPolicy(LO));
  return OS;
}

} // namespace clang

bool DeclarationName::isDependentName() const {
  QualType T = getCXXNameType();
  if (!T.isNull() && T->isDependentType()802)
    return true;

  // A class-scope deduction guide in a dependent context has a dependent name.
  auto *TD = getCXXDeductionGuideTemplate();
  if (TD && TD->getDeclContext()->isDependentContext()0)
    return true;

  return false;
}

std::string DeclarationName::getAsString() const {
  std::string Result;
  llvm::raw_string_ostream OS(Result);
  OS << *this;
  return Result;
}

void *DeclarationName::getFETokenInfoSlow() const {
  switch (getNameKind()) {
  case Identifier:
    llvm_unreachable("case Identifier already handled by getFETokenInfo!");
  case CXXConstructorName:
  case CXXDestructorName:
  case CXXConversionFunctionName:
    return castAsCXXSpecialNameExtra()->FETokenInfo;
  case CXXOperatorName:
    return castAsCXXOperatorIdName()->FETokenInfo;
  case CXXDeductionGuideName:
    return castAsCXXDeductionGuideNameExtra()->FETokenInfo;
  case CXXLiteralOperatorName:
    return castAsCXXLiteralOperatorIdName()->FETokenInfo;
  default:
    llvm_unreachable("DeclarationName has no FETokenInfo!");
  }
}

void DeclarationName::setFETokenInfoSlow(void *T) {
  switch (getNameKind()) {
  case Identifier:
    llvm_unreachable("case Identifier already handled by setFETokenInfo!");
  case CXXConstructorName:
  case CXXDestructorName:
  case CXXConversionFunctionName:
    castAsCXXSpecialNameExtra()->FETokenInfo = T;
    break;
  case CXXOperatorName:
    castAsCXXOperatorIdName()->FETokenInfo = T;
    break;
  case CXXDeductionGuideName:
    castAsCXXDeductionGuideNameExtra()->FETokenInfo = T;
    break;
  case CXXLiteralOperatorName:
    castAsCXXLiteralOperatorIdName()->FETokenInfo = T;
    break;
  default:
    llvm_unreachable("DeclarationName has no FETokenInfo!");
  }
}

LLVM_DUMP_METHOD void DeclarationName::dump() const {
  llvm::errs() << *this << '\n';
}

DeclarationNameTable::DeclarationNameTable(const ASTContext &C) : Ctx(C) {
  // Initialize the overloaded operator names.
  for (unsigned Op = 0; Op < NUM_OVERLOADED_OPERATORS; ++Op4.29M)
    CXXOperatorNames[Op].Kind = static_cast<OverloadedOperatorKind>(Op);
}

DeclarationName
DeclarationNameTable::getCXXDeductionGuideName(TemplateDecl *Template) {
  Template = cast<TemplateDecl>(Template->getCanonicalDecl());

  llvm::FoldingSetNodeID ID;
  ID.AddPointer(Template);

  void *InsertPos = nullptr;
  if (auto *Name = CXXDeductionGuideNames.FindNodeOrInsertPos(ID, InsertPos))
    return DeclarationName(Name);

  auto *Name = new (Ctx) detail::CXXDeductionGuideNameExtra(Template);
  CXXDeductionGuideNames.InsertNode(Name, InsertPos);
  return DeclarationName(Name);
}

DeclarationName DeclarationNameTable::getCXXConstructorName(CanQualType Ty) {
  // The type of constructors is unqualified.
  Ty = Ty.getUnqualifiedType();
  // Do we already have this C++ constructor name ?
  llvm::FoldingSetNodeID ID;
  ID.AddPointer(Ty.getAsOpaquePtr());
  void *InsertPos = nullptr;
  if (auto *Name = CXXConstructorNames.FindNodeOrInsertPos(ID, InsertPos))
    return {Name, DeclarationName::StoredCXXConstructorName};

  // We have to create it.
  auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
  CXXConstructorNames.InsertNode(SpecialName, InsertPos);
  return {SpecialName, DeclarationName::StoredCXXConstructorName};
}

DeclarationName DeclarationNameTable::getCXXDestructorName(CanQualType Ty) {
  // The type of destructors is unqualified.
  Ty = Ty.getUnqualifiedType();
  // Do we already have this C++ destructor name ?
  llvm::FoldingSetNodeID ID;
  ID.AddPointer(Ty.getAsOpaquePtr());
  void *InsertPos = nullptr;
  if (auto *Name = CXXDestructorNames.FindNodeOrInsertPos(ID, InsertPos))
    return {Name, DeclarationName::StoredCXXDestructorName};

  // We have to create it.
  auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
  CXXDestructorNames.InsertNode(SpecialName, InsertPos);
  return {SpecialName, DeclarationName::StoredCXXDestructorName};
}

DeclarationName
DeclarationNameTable::getCXXConversionFunctionName(CanQualType Ty) {
  // Do we already have this C++ conversion function name ?
  llvm::FoldingSetNodeID ID;
  ID.AddPointer(Ty.getAsOpaquePtr());
  void *InsertPos = nullptr;
  if (auto *Name =
          CXXConversionFunctionNames.FindNodeOrInsertPos(ID, InsertPos))
    return {Name, DeclarationName::StoredCXXConversionFunctionName};

  // We have to create it.
  auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
  CXXConversionFunctionNames.InsertNode(SpecialName, InsertPos);
  return {SpecialName, DeclarationName::StoredCXXConversionFunctionName};
}

DeclarationName
DeclarationNameTable::getCXXSpecialName(DeclarationName::NameKind Kind,
                                        CanQualType Ty) {
  switch (Kind) {
  case DeclarationName::CXXConstructorName:
    return getCXXConstructorName(Ty);
  case DeclarationName::CXXDestructorName:
    return getCXXDestructorName(Ty);
  case DeclarationName::CXXConversionFunctionName:
    return getCXXConversionFunctionName(Ty);
  default:
    llvm_unreachable("Invalid kind in getCXXSpecialName!");
  }
}

DeclarationName
DeclarationNameTable::getCXXLiteralOperatorName(const IdentifierInfo *II) {
  llvm::FoldingSetNodeID ID;
  ID.AddPointer(II);

  void *InsertPos = nullptr;
  if (auto *Name = CXXLiteralOperatorNames.FindNodeOrInsertPos(ID, InsertPos))
    return DeclarationName(Name);

  auto *LiteralName = new (Ctx) detail::CXXLiteralOperatorIdName(II);
  CXXLiteralOperatorNames.InsertNode(LiteralName, InsertPos);
  return DeclarationName(LiteralName);
}

DeclarationNameLoc::DeclarationNameLoc(DeclarationName Name) {
  switch (Name.getNameKind()) {
  case DeclarationName::Identifier:
  case DeclarationName::CXXDeductionGuideName:
    break;
  case DeclarationName::CXXConstructorName:
  case DeclarationName::CXXDestructorName:
  case DeclarationName::CXXConversionFunctionName:
    setNamedTypeLoc(nullptr);
    break;
  case DeclarationName::CXXOperatorName:
    setCXXOperatorNameRange(SourceRange());
    break;
  case DeclarationName::CXXLiteralOperatorName:
    setCXXLiteralOperatorNameLoc(SourceLocation());
    break;
  case DeclarationName::ObjCZeroArgSelector:
  case DeclarationName::ObjCOneArgSelector:
  case DeclarationName::ObjCMultiArgSelector:
    // FIXME: ?
    break;
  case DeclarationName::CXXUsingDirective:
    break;
  }
}

bool DeclarationNameInfo::containsUnexpandedParameterPack() const {
  switch (Name.getNameKind()) {
  case DeclarationName::Identifier:
  case DeclarationName::ObjCZeroArgSelector:
  case DeclarationName::ObjCOneArgSelector:
  case DeclarationName::ObjCMultiArgSelector:
  case DeclarationName::CXXOperatorName:
  case DeclarationName::CXXLiteralOperatorName:
  case DeclarationName::CXXUsingDirective:
  case DeclarationName::CXXDeductionGuideName:
    return false;

  case DeclarationName::CXXConstructorName:
  case DeclarationName::CXXDestructorName:
  case DeclarationName::CXXConversionFunctionName:
    if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo())
      return TInfo->getType()->containsUnexpandedParameterPack();

    return Name.getCXXNameType()->containsUnexpandedParameterPack();
  }
  llvm_unreachable("All name kinds handled.");
}

bool DeclarationNameInfo::isInstantiationDependent() const {
  switch (Name.getNameKind()) {
  case DeclarationName::Identifier:
  case DeclarationName::ObjCZeroArgSelector:
  case DeclarationName::ObjCOneArgSelector:
  case DeclarationName::ObjCMultiArgSelector:
  case DeclarationName::CXXOperatorName:
  case DeclarationName::CXXLiteralOperatorName:
  case DeclarationName::CXXUsingDirective:
  case DeclarationName::CXXDeductionGuideName:
    return false;

  case DeclarationName::CXXConstructorName:
  case DeclarationName::CXXDestructorName:
  case DeclarationName::CXXConversionFunctionName:
    if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo())
      return TInfo->getType()->isInstantiationDependentType();

    return Name.getCXXNameType()->isInstantiationDependentType();
  }
  llvm_unreachable("All name kinds handled.");
}

std::string DeclarationNameInfo::getAsString() const {
  std::string Result;
  llvm::raw_string_ostream OS(Result);
  OS << *this;
  return Result;
}

raw_ostream &clang::operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo) {
  LangOptions LO;
  DNInfo.printName(OS, PrintingPolicy(LangOptions()));
  return OS;
}

void DeclarationNameInfo::printName(raw_ostream &OS, PrintingPolicy Policy) const {
  switch (Name.getNameKind()) {
  case DeclarationName::Identifier:
  case DeclarationName::ObjCZeroArgSelector:
  case DeclarationName::ObjCOneArgSelector:
  case DeclarationName::ObjCMultiArgSelector:
  case DeclarationName::CXXOperatorName:
  case DeclarationName::CXXLiteralOperatorName:
  case DeclarationName::CXXUsingDirective:
  case DeclarationName::CXXDeductionGuideName:
    Name.print(OS, Policy);
    return;

  case DeclarationName::CXXConstructorName:
  case DeclarationName::CXXDestructorName:
  case DeclarationName::CXXConversionFunctionName:
    if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo()) {
      if (Name.getNameKind() == DeclarationName::CXXDestructorName)
        OS << '~';
      else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
        OS << "operator ";
      LangOptions LO;
      Policy.adjustForCPlusPlus();
      Policy.SuppressScope = true;
      OS << TInfo->getType().getAsString(Policy);
    } else
      Name.print(OS, Policy);
    return;
  }
  llvm_unreachable("Unexpected declaration name kind");
}

SourceLocation DeclarationNameInfo::getEndLocPrivate() const {
  switch (Name.getNameKind()) {
  case DeclarationName::Identifier:
  case DeclarationName::CXXDeductionGuideName:
    return NameLoc;

  case DeclarationName::CXXOperatorName:
    return LocInfo.getCXXOperatorNameEndLoc();

  case DeclarationName::CXXLiteralOperatorName:
    return LocInfo.getCXXLiteralOperatorNameLoc();

  case DeclarationName::CXXConstructorName:
  case DeclarationName::CXXDestructorName:
  case DeclarationName::CXXConversionFunctionName:
    if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo())
      return TInfo->getTypeLoc().getEndLoc();
    else
      return NameLoc;

    // DNInfo work in progress: FIXME.
  case DeclarationName::ObjCZeroArgSelector:
  case DeclarationName::ObjCOneArgSelector:
  case DeclarationName::ObjCMultiArgSelector:
  case DeclarationName::CXXUsingDirective:
    return NameLoc;
  }
  llvm_unreachable("Unexpected declaration name kind");
}

Coverage Report

Created: 2023-05-31 04:38

Line	Count	Source (jump to first uncovered line)
1		//===- DeclarationName.cpp - Declaration names implementation -------------===//
2		//
3		// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4		// See https://llvm.org/LICENSE.txt for license information.
5		// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6		//
7		//===----------------------------------------------------------------------===//
8		//
9		// This file implements the DeclarationName and DeclarationNameTable
10		// classes.
11		//
12		//===----------------------------------------------------------------------===//
13
14		#include "clang/AST/DeclarationName.h"
15		#include "clang/AST/ASTContext.h"
16		#include "clang/AST/Decl.h"
17		#include "clang/AST/DeclBase.h"
18		#include "clang/AST/DeclCXX.h"
19		#include "clang/AST/DeclTemplate.h"
20		#include "clang/AST/OpenMPClause.h"
21		#include "clang/AST/PrettyPrinter.h"
22		#include "clang/AST/Type.h"
23		#include "clang/AST/TypeLoc.h"
24		#include "clang/AST/TypeOrdering.h"
25		#include "clang/Basic/IdentifierTable.h"
26		#include "clang/Basic/LLVM.h"
27		#include "clang/Basic/LangOptions.h"
28		#include "clang/Basic/OperatorKinds.h"
29		#include "clang/Basic/SourceLocation.h"
30		#include "llvm/ADT/FoldingSet.h"
31		#include "llvm/Support/Casting.h"
32		#include "llvm/Support/Compiler.h"
33		#include "llvm/Support/ErrorHandling.h"
34		#include "llvm/Support/raw_ostream.h"
35		#include <algorithm>
36		#include <cassert>
37		#include <cstdint>
38		#include <string>
39
40		using namespace clang;
41
42	18.1k	static int compareInt(unsigned A, unsigned B) {
43	18.1k	return (A < B ? -111.0k : (7.11k A > B7.11k ? 17.03k : 078 ));
44	18.1k	}
45
46	5.61M	int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
47	5.61M	if (LHS.getNameKind() != RHS.getNameKind())
48	211k	return (LHS.getNameKind() < RHS.getNameKind() ? -1132k : 179.6k );
49
50	5.40M	switch (LHS.getNameKind()) {
51	5.19M	case DeclarationName::Identifier: {
52	5.19M	IdentifierInfo *LII = LHS.castAsIdentifierInfo();
53	5.19M	IdentifierInfo *RII = RHS.castAsIdentifierInfo();
54	5.19M	if (!LII)
55	0	return RII ? -1 : 0;
56	5.19M	if (!RII)
57	0	return 1;
58
59	5.19M	return LII->getName().compare(RII->getName());
60	5.19M	}
61
62	85.4k	case DeclarationName::ObjCZeroArgSelector:
63	158k	case DeclarationName::ObjCOneArgSelector:
64	187k	case DeclarationName::ObjCMultiArgSelector: {
65	187k	Selector LHSSelector = LHS.getObjCSelector();
66	187k	Selector RHSSelector = RHS.getObjCSelector();
67		// getNumArgs for ZeroArgSelector returns 0, but we still need to compare.
68	187k	if (LHS.getNameKind() == DeclarationName::ObjCZeroArgSelector &&
69	187k	RHS.getNameKind() == DeclarationName::ObjCZeroArgSelector85.4k ) {
70	85.4k	return LHSSelector.getAsIdentifierInfo()->getName().compare(
71	85.4k	RHSSelector.getAsIdentifierInfo()->getName());
72	85.4k	}
73	101k	unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
74	110k	for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I8.31k ) {
75	109k	if (int Compare = LHSSelector.getNameForSlot(I).compare(
76	109k	RHSSelector.getNameForSlot(I)))
77	101k	return Compare;
78	109k	}
79
80	601	return compareInt(LN, RN);
81	101k	}
82
83	428	case DeclarationName::CXXConstructorName:
84	834	case DeclarationName::CXXDestructorName:
85	836	case DeclarationName::CXXConversionFunctionName:
86	836	if (QualTypeOrdering()(LHS.getCXXNameType(), RHS.getCXXNameType()))
87	452	return -1;
88	384	if (QualTypeOrdering()(RHS.getCXXNameType(), LHS.getCXXNameType()))
89	326	return 1;
90	58	return 0;
91
92	521	case DeclarationName::CXXDeductionGuideName:
93		// We never want to compare deduction guide names for templates from
94		// different scopes, so just compare the template-name.
95	521	return compare(LHS.getCXXDeductionGuideTemplate()->getDeclName(),
96	521	RHS.getCXXDeductionGuideTemplate()->getDeclName());
97
98	17.5k	case DeclarationName::CXXOperatorName:
99	17.5k	return compareInt(LHS.getCXXOverloadedOperator(),
100	17.5k	RHS.getCXXOverloadedOperator());
101
102	223	case DeclarationName::CXXLiteralOperatorName:
103	223	return LHS.getCXXLiteralIdentifier()->getName().compare(
104	223	RHS.getCXXLiteralIdentifier()->getName());
105
106	0	case DeclarationName::CXXUsingDirective:
107	0	return 0;
108	5.40M	}
109
110	0	llvm_unreachable("Invalid DeclarationName Kind!");
111	0	}
112
113		static void printCXXConstructorDestructorName(QualType ClassType,
114		raw_ostream &OS,
115	560k	PrintingPolicy Policy) {
116		// We know we're printing C++ here. Ensure we print types properly.
117	560k	Policy.adjustForCPlusPlus();
118
119	560k	if (const RecordType *ClassRec = ClassType->getAs<RecordType>()) {
120	450k	ClassRec->getDecl()->printName(OS, Policy);
121	450k	return;
122	450k	}
123	109k	if (Policy.SuppressTemplateArgsInCXXConstructors) {
124	35	if (auto *InjTy = ClassType->getAs<InjectedClassNameType>()) {
125	35	InjTy->getDecl()->printName(OS, Policy);
126	35	return;
127	35	}
128	35	}
129	109k	ClassType.print(OS, Policy);
130	109k	}
131
132		void DeclarationName::print(raw_ostream &OS,
133	5.60M	const PrintingPolicy &Policy) const {
134	5.60M	switch (getNameKind()) {
135	3.34M	case DeclarationName::Identifier:
136	3.34M	if (const IdentifierInfo *II = getAsIdentifierInfo()) {
137	3.33M	StringRef Name = II->getName();
138		// If this is a mangled OpenMP variant name we strip off the mangling for
139		// printing. It should not be visible to the user at all.
140	3.33M	if (II->isMangledOpenMPVariantName()) {
141	430	std::pair<StringRef, StringRef> NameContextPair =
142	430	Name.split(getOpenMPVariantManglingSeparatorStr());
143	430	OS << NameContextPair.first << "["
144	430	<< OMPTraitInfo(NameContextPair.second) << "]";
145	3.33M	} else {
146	3.33M	OS << Name;
147	3.33M	}
148	3.33M	}
149	3.34M	return;
150
151	5.42k	case DeclarationName::ObjCZeroArgSelector:
152	8.27k	case DeclarationName::ObjCOneArgSelector:
153	8.84k	case DeclarationName::ObjCMultiArgSelector:
154	8.84k	getObjCSelector().print(OS);
155	8.84k	return;
156
157	536k	case DeclarationName::CXXConstructorName:
158	536k	return printCXXConstructorDestructorName(getCXXNameType(), OS, Policy);
159
160	23.7k	case DeclarationName::CXXDestructorName:
161	23.7k	OS << '~';
162	23.7k	return printCXXConstructorDestructorName(getCXXNameType(), OS, Policy);
163
164	203	case DeclarationName::CXXDeductionGuideName:
165	203	OS << "<deduction guide for ";
166	203	getCXXDeductionGuideTemplate()->getDeclName().print(OS, Policy);
167	203	OS << '>';
168	203	return;
169
170	1.66M	case DeclarationName::CXXOperatorName: {
171	1.66M	const char *OpName = getOperatorSpelling(getCXXOverloadedOperator());
172	1.66M	assert(OpName && "not an overloaded operator");
173
174	1.66M	OS << "operator";
175	1.66M	if (OpName[0] >= 'a' && OpName[0] <= 'z'18.1k )
176	16.4k	OS << ' ';
177	1.66M	OS << OpName;
178	1.66M	return;
179	1.66M	}
180
181	141	case DeclarationName::CXXLiteralOperatorName:
182	141	OS << "operator\"\"" << getCXXLiteralIdentifier()->getName();
183	141	return;
184
185	8.26k	case DeclarationName::CXXConversionFunctionName: {
186	8.26k	OS << "operator ";
187	8.26k	QualType Type = getCXXNameType();
188	8.26k	if (const RecordType *Rec = Type->getAs<RecordType>()) {
189	716	OS << *Rec->getDecl();
190	716	return;
191	716	}
192		// We know we're printing C++ here, ensure we print 'bool' properly.
193	7.55k	PrintingPolicy CXXPolicy = Policy;
194	7.55k	CXXPolicy.adjustForCPlusPlus();
195	7.55k	Type.print(OS, CXXPolicy);
196	7.55k	return;
197	8.26k	}
198	11.9k	case DeclarationName::CXXUsingDirective:
199	11.9k	OS << "<using-directive>";
200	11.9k	return;
201	5.60M	}
202
203	0	llvm_unreachable("Unexpected declaration name kind");
204	0	}
205
206		namespace clang {
207
208	2.60M	raw_ostream &operator<<(raw_ostream &OS, DeclarationName N) {
209	2.60M	LangOptions LO;
210	2.60M	N.print(OS, PrintingPolicy(LO));
211	2.60M	return OS;
212	2.60M	}
213
214		} // namespace clang
215
216	2.09M	bool DeclarationName::isDependentName() const {
217	2.09M	QualType T = getCXXNameType();
218	2.09M	if (!T.isNull() && T->isDependentType()802 )
219	17	return true;
220
221		// A class-scope deduction guide in a dependent context has a dependent name.
222	2.09M	auto *TD = getCXXDeductionGuideTemplate();
223	2.09M	if (TD && TD->getDeclContext()->isDependentContext()0 )
224	0	return true;
225
226	2.09M	return false;
227	2.09M	}
228
229	2.51M	std::string DeclarationName::getAsString() const {
230	2.51M	std::string Result;
231	2.51M	llvm::raw_string_ostream OS(Result);
232	2.51M	OS << *this;
233	2.51M	return Result;
234	2.51M	}
235
236	10.2M	void *DeclarationName::getFETokenInfoSlow() const {
237	10.2M	switch (getNameKind()) {
238	0	case Identifier:
239	0	llvm_unreachable("case Identifier already handled by getFETokenInfo!");
240	3.55M	case CXXConstructorName:
241	3.82M	case CXXDestructorName:
242	3.88M	case CXXConversionFunctionName:
243	3.88M	return castAsCXXSpecialNameExtra()->FETokenInfo;
244	6.38M	case CXXOperatorName:
245	6.38M	return castAsCXXOperatorIdName()->FETokenInfo;
246	8.49k	case CXXDeductionGuideName:
247	8.49k	return castAsCXXDeductionGuideNameExtra()->FETokenInfo;
248	6.40k	case CXXLiteralOperatorName:
249	6.40k	return castAsCXXLiteralOperatorIdName()->FETokenInfo;
250	0	default:
251	0	llvm_unreachable("DeclarationName has no FETokenInfo!");
252	10.2M	}
253	10.2M	}
254
255	735k	void DeclarationName::setFETokenInfoSlow(void *T) {
256	735k	switch (getNameKind()) {
257	0	case Identifier:
258	0	llvm_unreachable("case Identifier already handled by setFETokenInfo!");
259	367k	case CXXConstructorName:
260	507k	case CXXDestructorName:
261	538k	case CXXConversionFunctionName:
262	538k	castAsCXXSpecialNameExtra()->FETokenInfo = T;
263	538k	break;
264	194k	case CXXOperatorName:
265	194k	castAsCXXOperatorIdName()->FETokenInfo = T;
266	194k	break;
267	1.97k	case CXXDeductionGuideName:
268	1.97k	castAsCXXDeductionGuideNameExtra()->FETokenInfo = T;
269	1.97k	break;
270	1.12k	case CXXLiteralOperatorName:
271	1.12k	castAsCXXLiteralOperatorIdName()->FETokenInfo = T;
272	1.12k	break;
273	0	default:
274	0	llvm_unreachable("DeclarationName has no FETokenInfo!");
275	735k	}
276	735k	}
277
278	0	LLVM_DUMP_METHOD void DeclarationName::dump() const {
279	0	llvm::errs() << *this << '\n';
280	0	}
281
282	93.4k	DeclarationNameTable::DeclarationNameTable(const ASTContext &C) : Ctx(C) {
283		// Initialize the overloaded operator names.
284	4.39M	for (unsigned Op = 0; Op < NUM_OVERLOADED_OPERATORS; ++Op4.29M )
285	4.29M	CXXOperatorNames[Op].Kind = static_cast<OverloadedOperatorKind>(Op);
286	93.4k	}
287
288		DeclarationName
289	8.53k	DeclarationNameTable::getCXXDeductionGuideName(TemplateDecl *Template) {
290	8.53k	Template = cast<TemplateDecl>(Template->getCanonicalDecl());
291
292	8.53k	llvm::FoldingSetNodeID ID;
293	8.53k	ID.AddPointer(Template);
294
295	8.53k	void *InsertPos = nullptr;
296	8.53k	if (auto *Name = CXXDeductionGuideNames.FindNodeOrInsertPos(ID, InsertPos))
297	7.43k	return DeclarationName(Name);
298
299	1.10k	auto *Name = new (Ctx) detail::CXXDeductionGuideNameExtra(Template);
300	1.10k	CXXDeductionGuideNames.InsertNode(Name, InsertPos);
301	1.10k	return DeclarationName(Name);
302	8.53k	}
303
304	3.44M	DeclarationName DeclarationNameTable::getCXXConstructorName(CanQualType Ty) {
305		// The type of constructors is unqualified.
306	3.44M	Ty = Ty.getUnqualifiedType();
307		// Do we already have this C++ constructor name ?
308	3.44M	llvm::FoldingSetNodeID ID;
309	3.44M	ID.AddPointer(Ty.getAsOpaquePtr());
310	3.44M	void *InsertPos = nullptr;
311	3.44M	if (auto *Name = CXXConstructorNames.FindNodeOrInsertPos(ID, InsertPos))
312	3.07M	return {Name, DeclarationName::StoredCXXConstructorName};
313
314		// We have to create it.
315	365k	auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
316	365k	CXXConstructorNames.InsertNode(SpecialName, InsertPos);
317	365k	return {SpecialName, DeclarationName::StoredCXXConstructorName};
318	3.44M	}
319
320	7.71M	DeclarationName DeclarationNameTable::getCXXDestructorName(CanQualType Ty) {
321		// The type of destructors is unqualified.
322	7.71M	Ty = Ty.getUnqualifiedType();
323		// Do we already have this C++ destructor name ?
324	7.71M	llvm::FoldingSetNodeID ID;
325	7.71M	ID.AddPointer(Ty.getAsOpaquePtr());
326	7.71M	void *InsertPos = nullptr;
327	7.71M	if (auto *Name = CXXDestructorNames.FindNodeOrInsertPos(ID, InsertPos))
328	6.23M	return {Name, DeclarationName::StoredCXXDestructorName};
329
330		// We have to create it.
331	1.48M	auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
332	1.48M	CXXDestructorNames.InsertNode(SpecialName, InsertPos);
333	1.48M	return {SpecialName, DeclarationName::StoredCXXDestructorName};
334	7.71M	}
335
336		DeclarationName
337	93.8k	DeclarationNameTable::getCXXConversionFunctionName(CanQualType Ty) {
338		// Do we already have this C++ conversion function name ?
339	93.8k	llvm::FoldingSetNodeID ID;
340	93.8k	ID.AddPointer(Ty.getAsOpaquePtr());
341	93.8k	void *InsertPos = nullptr;
342	93.8k	if (auto *Name =
343	93.8k	CXXConversionFunctionNames.FindNodeOrInsertPos(ID, InsertPos))
344	75.7k	return {Name, DeclarationName::StoredCXXConversionFunctionName};
345
346		// We have to create it.
347	18.1k	auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
348	18.1k	CXXConversionFunctionNames.InsertNode(SpecialName, InsertPos);
349	18.1k	return {SpecialName, DeclarationName::StoredCXXConversionFunctionName};
350	93.8k	}
351
352		DeclarationName
353		DeclarationNameTable::getCXXSpecialName(DeclarationName::NameKind Kind,
354	405k	CanQualType Ty) {
355	405k	switch (Kind) {
356	362k	case DeclarationName::CXXConstructorName:
357	362k	return getCXXConstructorName(Ty);
358	27.5k	case DeclarationName::CXXDestructorName:
359	27.5k	return getCXXDestructorName(Ty);
360	14.9k	case DeclarationName::CXXConversionFunctionName:
361	14.9k	return getCXXConversionFunctionName(Ty);
362	0	default:
363	0	llvm_unreachable("Invalid kind in getCXXSpecialName!");
364	405k	}
365	405k	}
366
367		DeclarationName
368	3.48k	DeclarationNameTable::getCXXLiteralOperatorName(const IdentifierInfo *II) {
369	3.48k	llvm::FoldingSetNodeID ID;
370	3.48k	ID.AddPointer(II);
371
372	3.48k	void *InsertPos = nullptr;
373	3.48k	if (auto *Name = CXXLiteralOperatorNames.FindNodeOrInsertPos(ID, InsertPos))
374	2.93k	return DeclarationName(Name);
375
376	556	auto *LiteralName = new (Ctx) detail::CXXLiteralOperatorIdName(II);
377	556	CXXLiteralOperatorNames.InsertNode(LiteralName, InsertPos);
378	556	return DeclarationName(LiteralName);
379	3.48k	}
380
381	220M	DeclarationNameLoc::DeclarationNameLoc(DeclarationName Name) {
382	220M	switch (Name.getNameKind()) {
383	212M	case DeclarationName::Identifier:
384	212M	case DeclarationName::CXXDeductionGuideName:
385	212M	break;
386	806k	case DeclarationName::CXXConstructorName:
387	1.05M	case DeclarationName::CXXDestructorName:
388	1.06M	case DeclarationName::CXXConversionFunctionName:
389	1.06M	setNamedTypeLoc(nullptr);
390	1.06M	break;
391	6.59M	case DeclarationName::CXXOperatorName:
392	6.59M	setCXXOperatorNameRange(SourceRange());
393	6.59M	break;
394	827	case DeclarationName::CXXLiteralOperatorName:
395	827	setCXXLiteralOperatorNameLoc(SourceLocation());
396	827	break;
397	0	case DeclarationName::ObjCZeroArgSelector:
398	0	case DeclarationName::ObjCOneArgSelector:
399	0	case DeclarationName::ObjCMultiArgSelector:
400		// FIXME: ?
401	0	break;
402	0	case DeclarationName::CXXUsingDirective:
403	0	break;
404	220M	}
405	220M	}
406
407	8.88M	bool DeclarationNameInfo::containsUnexpandedParameterPack() const {
408	8.88M	switch (Name.getNameKind()) {
409	7.43M	case DeclarationName::Identifier:
410	7.43M	case DeclarationName::ObjCZeroArgSelector:
411	7.43M	case DeclarationName::ObjCOneArgSelector:
412	7.43M	case DeclarationName::ObjCMultiArgSelector:
413	8.88M	case DeclarationName::CXXOperatorName:
414	8.88M	case DeclarationName::CXXLiteralOperatorName:
415	8.88M	case DeclarationName::CXXUsingDirective:
416	8.88M	case DeclarationName::CXXDeductionGuideName:
417	8.88M	return false;
418
419	14	case DeclarationName::CXXConstructorName:
420	19	case DeclarationName::CXXDestructorName:
421	72	case DeclarationName::CXXConversionFunctionName:
422	72	if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo())
423	57	return TInfo->getType()->containsUnexpandedParameterPack();
424
425	15	return Name.getCXXNameType()->containsUnexpandedParameterPack();
426	8.88M	}
427	0	llvm_unreachable("All name kinds handled.");
428	0	}
429
430	8.88M	bool DeclarationNameInfo::isInstantiationDependent() const {
431	8.88M	switch (Name.getNameKind()) {
432	7.43M	case DeclarationName::Identifier:
433	7.43M	case DeclarationName::ObjCZeroArgSelector:
434	7.43M	case DeclarationName::ObjCOneArgSelector:
435	7.43M	case DeclarationName::ObjCMultiArgSelector:
436	8.88M	case DeclarationName::CXXOperatorName:
437	8.88M	case DeclarationName::CXXLiteralOperatorName:
438	8.88M	case DeclarationName::CXXUsingDirective:
439	8.88M	case DeclarationName::CXXDeductionGuideName:
440	8.88M	return false;
441
442	14	case DeclarationName::CXXConstructorName:
443	19	case DeclarationName::CXXDestructorName:
444	71	case DeclarationName::CXXConversionFunctionName:
445	71	if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo())
446	56	return TInfo->getType()->isInstantiationDependentType();
447
448	15	return Name.getCXXNameType()->isInstantiationDependentType();
449	8.88M	}
450	0	llvm_unreachable("All name kinds handled.");
451	0	}
452
453	426k	std::string DeclarationNameInfo::getAsString() const {
454	426k	std::string Result;
455	426k	llvm::raw_string_ostream OS(Result);
456	426k	OS << *this;
457	426k	return Result;
458	426k	}
459
460	440k	raw_ostream &clang::operator<<(raw_ostream &OS, DeclarationNameInfo DNInfo) {
461	440k	LangOptions LO;
462	440k	DNInfo.printName(OS, PrintingPolicy(LangOptions()));
463	440k	return OS;
464	440k	}
465
466	549k	void DeclarationNameInfo::printName(raw_ostream &OS, PrintingPolicy Policy) const {
467	549k	switch (Name.getNameKind()) {
468	399k	case DeclarationName::Identifier:
469	399k	case DeclarationName::ObjCZeroArgSelector:
470	399k	case DeclarationName::ObjCOneArgSelector:
471	399k	case DeclarationName::ObjCMultiArgSelector:
472	496k	case DeclarationName::CXXOperatorName:
473	496k	case DeclarationName::CXXLiteralOperatorName:
474	496k	case DeclarationName::CXXUsingDirective:
475	496k	case DeclarationName::CXXDeductionGuideName:
476	496k	Name.print(OS, Policy);
477	496k	return;
478
479	48.1k	case DeclarationName::CXXConstructorName:
480	51.0k	case DeclarationName::CXXDestructorName:
481	52.5k	case DeclarationName::CXXConversionFunctionName:
482	52.5k	if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo()) {
483	4.23k	if (Name.getNameKind() == DeclarationName::CXXDestructorName)
484	2.89k	OS << '~';
485	1.34k	else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
486	1.34k	OS << "operator ";
487	4.23k	LangOptions LO;
488	4.23k	Policy.adjustForCPlusPlus();
489	4.23k	Policy.SuppressScope = true;
490	4.23k	OS << TInfo->getType().getAsString(Policy);
491	4.23k	} else
492	48.3k	Name.print(OS, Policy);
493	52.5k	return;
494	549k	}
495	0	llvm_unreachable("Unexpected declaration name kind");
496	0	}
497
498	52.0M	SourceLocation DeclarationNameInfo::getEndLocPrivate() const {
499	52.0M	switch (Name.getNameKind()) {
500	49.4M	case DeclarationName::Identifier:
501	49.4M	case DeclarationName::CXXDeductionGuideName:
502	49.4M	return NameLoc;
503
504	1.06M	case DeclarationName::CXXOperatorName:
505	1.06M	return LocInfo.getCXXOperatorNameEndLoc();
506
507	1.45k	case DeclarationName::CXXLiteralOperatorName:
508	1.45k	return LocInfo.getCXXLiteralOperatorNameLoc();
509
510	1.21M	case DeclarationName::CXXConstructorName:
511	1.44M	case DeclarationName::CXXDestructorName:
512	1.49M	case DeclarationName::CXXConversionFunctionName:
513	1.49M	if (TypeSourceInfo *TInfo = LocInfo.getNamedTypeInfo())
514	140k	return TInfo->getTypeLoc().getEndLoc();
515	1.35M	else
516	1.35M	return NameLoc;
517
518		// DNInfo work in progress: FIXME.
519	0	case DeclarationName::ObjCZeroArgSelector:
520	0	case DeclarationName::ObjCOneArgSelector:
521	0	case DeclarationName::ObjCMultiArgSelector:
522	0	case DeclarationName::CXXUsingDirective:
523	0	return NameLoc;
524	52.0M	}
525	0	llvm_unreachable("Unexpected declaration name kind");
526	0	}