DeclarationName.cpp 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520
  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. #include "clang/AST/DeclarationName.h"
  14. #include "clang/AST/ASTContext.h"
  15. #include "clang/AST/Decl.h"
  16. #include "clang/AST/DeclBase.h"
  17. #include "clang/AST/DeclCXX.h"
  18. #include "clang/AST/DeclTemplate.h"
  19. #include "clang/AST/PrettyPrinter.h"
  20. #include "clang/AST/Type.h"
  21. #include "clang/AST/TypeLoc.h"
  22. #include "clang/AST/TypeOrdering.h"
  23. #include "clang/Basic/IdentifierTable.h"
  24. #include "clang/Basic/LLVM.h"
  25. #include "clang/Basic/LangOptions.h"
  26. #include "clang/Basic/OperatorKinds.h"
  27. #include "clang/Basic/SourceLocation.h"
  28. #include "llvm/ADT/FoldingSet.h"
  29. #include "llvm/Support/Casting.h"
  30. #include "llvm/Support/Compiler.h"
  31. #include "llvm/Support/ErrorHandling.h"
  32. #include "llvm/Support/raw_ostream.h"
  33. #include <algorithm>
  34. #include <cassert>
  35. #include <cstdint>
  36. #include <string>
  37. using namespace clang;
  38. static int compareInt(unsigned A, unsigned B) {
  39. return (A < B ? -1 : (A > B ? 1 : 0));
  40. }
  41. int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
  42. if (LHS.getNameKind() != RHS.getNameKind())
  43. return (LHS.getNameKind() < RHS.getNameKind() ? -1 : 1);
  44. switch (LHS.getNameKind()) {
  45. case DeclarationName::Identifier: {
  46. IdentifierInfo *LII = LHS.castAsIdentifierInfo();
  47. IdentifierInfo *RII = RHS.castAsIdentifierInfo();
  48. if (!LII)
  49. return RII ? -1 : 0;
  50. if (!RII)
  51. return 1;
  52. return LII->getName().compare(RII->getName());
  53. }
  54. case DeclarationName::ObjCZeroArgSelector:
  55. case DeclarationName::ObjCOneArgSelector:
  56. case DeclarationName::ObjCMultiArgSelector: {
  57. Selector LHSSelector = LHS.getObjCSelector();
  58. Selector RHSSelector = RHS.getObjCSelector();
  59. // getNumArgs for ZeroArgSelector returns 0, but we still need to compare.
  60. if (LHS.getNameKind() == DeclarationName::ObjCZeroArgSelector &&
  61. RHS.getNameKind() == DeclarationName::ObjCZeroArgSelector) {
  62. return LHSSelector.getAsIdentifierInfo()->getName().compare(
  63. RHSSelector.getAsIdentifierInfo()->getName());
  64. }
  65. unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
  66. for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I) {
  67. switch (LHSSelector.getNameForSlot(I).compare(
  68. RHSSelector.getNameForSlot(I))) {
  69. case -1:
  70. return -1;
  71. case 1:
  72. return 1;
  73. default:
  74. break;
  75. }
  76. }
  77. return compareInt(LN, RN);
  78. }
  79. case DeclarationName::CXXConstructorName:
  80. case DeclarationName::CXXDestructorName:
  81. case DeclarationName::CXXConversionFunctionName:
  82. if (QualTypeOrdering()(LHS.getCXXNameType(), RHS.getCXXNameType()))
  83. return -1;
  84. if (QualTypeOrdering()(RHS.getCXXNameType(), LHS.getCXXNameType()))
  85. return 1;
  86. return 0;
  87. case DeclarationName::CXXDeductionGuideName:
  88. // We never want to compare deduction guide names for templates from
  89. // different scopes, so just compare the template-name.
  90. return compare(LHS.getCXXDeductionGuideTemplate()->getDeclName(),
  91. RHS.getCXXDeductionGuideTemplate()->getDeclName());
  92. case DeclarationName::CXXOperatorName:
  93. return compareInt(LHS.getCXXOverloadedOperator(),
  94. RHS.getCXXOverloadedOperator());
  95. case DeclarationName::CXXLiteralOperatorName:
  96. return LHS.getCXXLiteralIdentifier()->getName().compare(
  97. RHS.getCXXLiteralIdentifier()->getName());
  98. case DeclarationName::CXXUsingDirective:
  99. return 0;
  100. }
  101. llvm_unreachable("Invalid DeclarationName Kind!");
  102. }
  103. static void printCXXConstructorDestructorName(QualType ClassType,
  104. raw_ostream &OS,
  105. PrintingPolicy Policy) {
  106. // We know we're printing C++ here. Ensure we print types properly.
  107. Policy.adjustForCPlusPlus();
  108. if (const RecordType *ClassRec = ClassType->getAs<RecordType>()) {
  109. OS << *ClassRec->getDecl();
  110. return;
  111. }
  112. if (Policy.SuppressTemplateArgsInCXXConstructors) {
  113. if (auto *InjTy = ClassType->getAs<InjectedClassNameType>()) {
  114. OS << *InjTy->getDecl();
  115. return;
  116. }
  117. }
  118. ClassType.print(OS, Policy);
  119. }
  120. void DeclarationName::print(raw_ostream &OS, const PrintingPolicy &Policy) {
  121. switch (getNameKind()) {
  122. case DeclarationName::Identifier:
  123. if (const IdentifierInfo *II = getAsIdentifierInfo())
  124. OS << II->getName();
  125. return;
  126. case DeclarationName::ObjCZeroArgSelector:
  127. case DeclarationName::ObjCOneArgSelector:
  128. case DeclarationName::ObjCMultiArgSelector:
  129. getObjCSelector().print(OS);
  130. return;
  131. case DeclarationName::CXXConstructorName:
  132. return printCXXConstructorDestructorName(getCXXNameType(), OS, Policy);
  133. case DeclarationName::CXXDestructorName:
  134. OS << '~';
  135. return printCXXConstructorDestructorName(getCXXNameType(), OS, Policy);
  136. case DeclarationName::CXXDeductionGuideName:
  137. OS << "<deduction guide for ";
  138. getCXXDeductionGuideTemplate()->getDeclName().print(OS, Policy);
  139. OS << '>';
  140. return;
  141. case DeclarationName::CXXOperatorName: {
  142. const char *OpName = getOperatorSpelling(getCXXOverloadedOperator());
  143. assert(OpName && "not an overloaded operator");
  144. OS << "operator";
  145. if (OpName[0] >= 'a' && OpName[0] <= 'z')
  146. OS << ' ';
  147. OS << OpName;
  148. return;
  149. }
  150. case DeclarationName::CXXLiteralOperatorName:
  151. OS << "operator\"\"" << getCXXLiteralIdentifier()->getName();
  152. return;
  153. case DeclarationName::CXXConversionFunctionName: {
  154. OS << "operator ";
  155. QualType Type = getCXXNameType();
  156. if (const RecordType *Rec = Type->getAs<RecordType>()) {
  157. OS << *Rec->getDecl();
  158. return;
  159. }
  160. // We know we're printing C++ here, ensure we print 'bool' properly.
  161. PrintingPolicy CXXPolicy = Policy;
  162. CXXPolicy.adjustForCPlusPlus();
  163. Type.print(OS, CXXPolicy);
  164. return;
  165. }
  166. case DeclarationName::CXXUsingDirective:
  167. OS << "<using-directive>";
  168. return;
  169. }
  170. llvm_unreachable("Unexpected declaration name kind");
  171. }
  172. namespace clang {
  173. raw_ostream &operator<<(raw_ostream &OS, DeclarationName N) {
  174. LangOptions LO;
  175. N.print(OS, PrintingPolicy(LO));
  176. return OS;
  177. }
  178. } // namespace clang
  179. bool DeclarationName::isDependentName() const {
  180. QualType T = getCXXNameType();
  181. if (!T.isNull() && T->isDependentType())
  182. return true;
  183. // A class-scope deduction guide in a dependent context has a dependent name.
  184. auto *TD = getCXXDeductionGuideTemplate();
  185. if (TD && TD->getDeclContext()->isDependentContext())
  186. return true;
  187. return false;
  188. }
  189. std::string DeclarationName::getAsString() const {
  190. std::string Result;
  191. llvm::raw_string_ostream OS(Result);
  192. OS << *this;
  193. return OS.str();
  194. }
  195. void *DeclarationName::getFETokenInfoSlow() const {
  196. switch (getNameKind()) {
  197. case Identifier:
  198. llvm_unreachable("case Identifier already handled by getFETokenInfo!");
  199. case CXXConstructorName:
  200. case CXXDestructorName:
  201. case CXXConversionFunctionName:
  202. return castAsCXXSpecialNameExtra()->FETokenInfo;
  203. case CXXOperatorName:
  204. return castAsCXXOperatorIdName()->FETokenInfo;
  205. case CXXDeductionGuideName:
  206. return castAsCXXDeductionGuideNameExtra()->FETokenInfo;
  207. case CXXLiteralOperatorName:
  208. return castAsCXXLiteralOperatorIdName()->FETokenInfo;
  209. default:
  210. llvm_unreachable("DeclarationName has no FETokenInfo!");
  211. }
  212. }
  213. void DeclarationName::setFETokenInfoSlow(void *T) {
  214. switch (getNameKind()) {
  215. case Identifier:
  216. llvm_unreachable("case Identifier already handled by setFETokenInfo!");
  217. case CXXConstructorName:
  218. case CXXDestructorName:
  219. case CXXConversionFunctionName:
  220. castAsCXXSpecialNameExtra()->FETokenInfo = T;
  221. break;
  222. case CXXOperatorName:
  223. castAsCXXOperatorIdName()->FETokenInfo = T;
  224. break;
  225. case CXXDeductionGuideName:
  226. castAsCXXDeductionGuideNameExtra()->FETokenInfo = T;
  227. break;
  228. case CXXLiteralOperatorName:
  229. castAsCXXLiteralOperatorIdName()->FETokenInfo = T;
  230. break;
  231. default:
  232. llvm_unreachable("DeclarationName has no FETokenInfo!");
  233. }
  234. }
  235. LLVM_DUMP_METHOD void DeclarationName::dump() const {
  236. llvm::errs() << *this << '\n';
  237. }
  238. DeclarationNameTable::DeclarationNameTable(const ASTContext &C) : Ctx(C) {
  239. // Initialize the overloaded operator names.
  240. for (unsigned Op = 0; Op < NUM_OVERLOADED_OPERATORS; ++Op)
  241. CXXOperatorNames[Op].Kind = static_cast<OverloadedOperatorKind>(Op);
  242. }
  243. DeclarationName
  244. DeclarationNameTable::getCXXDeductionGuideName(TemplateDecl *Template) {
  245. Template = cast<TemplateDecl>(Template->getCanonicalDecl());
  246. llvm::FoldingSetNodeID ID;
  247. ID.AddPointer(Template);
  248. void *InsertPos = nullptr;
  249. if (auto *Name = CXXDeductionGuideNames.FindNodeOrInsertPos(ID, InsertPos))
  250. return DeclarationName(Name);
  251. auto *Name = new (Ctx) detail::CXXDeductionGuideNameExtra(Template);
  252. CXXDeductionGuideNames.InsertNode(Name, InsertPos);
  253. return DeclarationName(Name);
  254. }
  255. DeclarationName DeclarationNameTable::getCXXConstructorName(CanQualType Ty) {
  256. // The type of constructors is unqualified.
  257. Ty = Ty.getUnqualifiedType();
  258. // Do we already have this C++ constructor name ?
  259. llvm::FoldingSetNodeID ID;
  260. ID.AddPointer(Ty.getAsOpaquePtr());
  261. void *InsertPos = nullptr;
  262. if (auto *Name = CXXConstructorNames.FindNodeOrInsertPos(ID, InsertPos))
  263. return {Name, DeclarationName::StoredCXXConstructorName};
  264. // We have to create it.
  265. auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
  266. CXXConstructorNames.InsertNode(SpecialName, InsertPos);
  267. return {SpecialName, DeclarationName::StoredCXXConstructorName};
  268. }
  269. DeclarationName DeclarationNameTable::getCXXDestructorName(CanQualType Ty) {
  270. // The type of destructors is unqualified.
  271. Ty = Ty.getUnqualifiedType();
  272. // Do we already have this C++ destructor name ?
  273. llvm::FoldingSetNodeID ID;
  274. ID.AddPointer(Ty.getAsOpaquePtr());
  275. void *InsertPos = nullptr;
  276. if (auto *Name = CXXDestructorNames.FindNodeOrInsertPos(ID, InsertPos))
  277. return {Name, DeclarationName::StoredCXXDestructorName};
  278. // We have to create it.
  279. auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
  280. CXXDestructorNames.InsertNode(SpecialName, InsertPos);
  281. return {SpecialName, DeclarationName::StoredCXXDestructorName};
  282. }
  283. DeclarationName
  284. DeclarationNameTable::getCXXConversionFunctionName(CanQualType Ty) {
  285. // Do we already have this C++ conversion function name ?
  286. llvm::FoldingSetNodeID ID;
  287. ID.AddPointer(Ty.getAsOpaquePtr());
  288. void *InsertPos = nullptr;
  289. if (auto *Name =
  290. CXXConversionFunctionNames.FindNodeOrInsertPos(ID, InsertPos))
  291. return {Name, DeclarationName::StoredCXXConversionFunctionName};
  292. // We have to create it.
  293. auto *SpecialName = new (Ctx) detail::CXXSpecialNameExtra(Ty);
  294. CXXConversionFunctionNames.InsertNode(SpecialName, InsertPos);
  295. return {SpecialName, DeclarationName::StoredCXXConversionFunctionName};
  296. }
  297. DeclarationName
  298. DeclarationNameTable::getCXXSpecialName(DeclarationName::NameKind Kind,
  299. CanQualType Ty) {
  300. switch (Kind) {
  301. case DeclarationName::CXXConstructorName:
  302. return getCXXConstructorName(Ty);
  303. case DeclarationName::CXXDestructorName:
  304. return getCXXDestructorName(Ty);
  305. case DeclarationName::CXXConversionFunctionName:
  306. return getCXXConversionFunctionName(Ty);
  307. default:
  308. llvm_unreachable("Invalid kind in getCXXSpecialName!");
  309. }
  310. }
  311. DeclarationName
  312. DeclarationNameTable::getCXXLiteralOperatorName(IdentifierInfo *II) {
  313. llvm::FoldingSetNodeID ID;
  314. ID.AddPointer(II);
  315. void *InsertPos = nullptr;
  316. if (auto *Name = CXXLiteralOperatorNames.FindNodeOrInsertPos(ID, InsertPos))
  317. return DeclarationName(Name);
  318. auto *LiteralName = new (Ctx) detail::CXXLiteralOperatorIdName(II);
  319. CXXLiteralOperatorNames.InsertNode(LiteralName, InsertPos);
  320. return DeclarationName(LiteralName);
  321. }
  322. DeclarationNameLoc::DeclarationNameLoc(DeclarationName Name) {
  323. switch (Name.getNameKind()) {
  324. case DeclarationName::Identifier:
  325. case DeclarationName::CXXDeductionGuideName:
  326. break;
  327. case DeclarationName::CXXConstructorName:
  328. case DeclarationName::CXXDestructorName:
  329. case DeclarationName::CXXConversionFunctionName:
  330. NamedType.TInfo = nullptr;
  331. break;
  332. case DeclarationName::CXXOperatorName:
  333. CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
  334. CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
  335. break;
  336. case DeclarationName::CXXLiteralOperatorName:
  337. CXXLiteralOperatorName.OpNameLoc = SourceLocation().getRawEncoding();
  338. break;
  339. case DeclarationName::ObjCZeroArgSelector:
  340. case DeclarationName::ObjCOneArgSelector:
  341. case DeclarationName::ObjCMultiArgSelector:
  342. // FIXME: ?
  343. break;
  344. case DeclarationName::CXXUsingDirective:
  345. break;
  346. }
  347. }
  348. bool DeclarationNameInfo::containsUnexpandedParameterPack() const {
  349. switch (Name.getNameKind()) {
  350. case DeclarationName::Identifier:
  351. case DeclarationName::ObjCZeroArgSelector:
  352. case DeclarationName::ObjCOneArgSelector:
  353. case DeclarationName::ObjCMultiArgSelector:
  354. case DeclarationName::CXXOperatorName:
  355. case DeclarationName::CXXLiteralOperatorName:
  356. case DeclarationName::CXXUsingDirective:
  357. case DeclarationName::CXXDeductionGuideName:
  358. return false;
  359. case DeclarationName::CXXConstructorName:
  360. case DeclarationName::CXXDestructorName:
  361. case DeclarationName::CXXConversionFunctionName:
  362. if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
  363. return TInfo->getType()->containsUnexpandedParameterPack();
  364. return Name.getCXXNameType()->containsUnexpandedParameterPack();
  365. }
  366. llvm_unreachable("All name kinds handled.");
  367. }
  368. bool DeclarationNameInfo::isInstantiationDependent() const {
  369. switch (Name.getNameKind()) {
  370. case DeclarationName::Identifier:
  371. case DeclarationName::ObjCZeroArgSelector:
  372. case DeclarationName::ObjCOneArgSelector:
  373. case DeclarationName::ObjCMultiArgSelector:
  374. case DeclarationName::CXXOperatorName:
  375. case DeclarationName::CXXLiteralOperatorName:
  376. case DeclarationName::CXXUsingDirective:
  377. case DeclarationName::CXXDeductionGuideName:
  378. return false;
  379. case DeclarationName::CXXConstructorName:
  380. case DeclarationName::CXXDestructorName:
  381. case DeclarationName::CXXConversionFunctionName:
  382. if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
  383. return TInfo->getType()->isInstantiationDependentType();
  384. return Name.getCXXNameType()->isInstantiationDependentType();
  385. }
  386. llvm_unreachable("All name kinds handled.");
  387. }
  388. std::string DeclarationNameInfo::getAsString() const {
  389. std::string Result;
  390. llvm::raw_string_ostream OS(Result);
  391. printName(OS);
  392. return OS.str();
  393. }
  394. void DeclarationNameInfo::printName(raw_ostream &OS) const {
  395. switch (Name.getNameKind()) {
  396. case DeclarationName::Identifier:
  397. case DeclarationName::ObjCZeroArgSelector:
  398. case DeclarationName::ObjCOneArgSelector:
  399. case DeclarationName::ObjCMultiArgSelector:
  400. case DeclarationName::CXXOperatorName:
  401. case DeclarationName::CXXLiteralOperatorName:
  402. case DeclarationName::CXXUsingDirective:
  403. case DeclarationName::CXXDeductionGuideName:
  404. OS << Name;
  405. return;
  406. case DeclarationName::CXXConstructorName:
  407. case DeclarationName::CXXDestructorName:
  408. case DeclarationName::CXXConversionFunctionName:
  409. if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo) {
  410. if (Name.getNameKind() == DeclarationName::CXXDestructorName)
  411. OS << '~';
  412. else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
  413. OS << "operator ";
  414. LangOptions LO;
  415. LO.CPlusPlus = true;
  416. LO.Bool = true;
  417. PrintingPolicy PP(LO);
  418. PP.SuppressScope = true;
  419. OS << TInfo->getType().getAsString(PP);
  420. } else
  421. OS << Name;
  422. return;
  423. }
  424. llvm_unreachable("Unexpected declaration name kind");
  425. }
  426. SourceLocation DeclarationNameInfo::getEndLocPrivate() const {
  427. switch (Name.getNameKind()) {
  428. case DeclarationName::Identifier:
  429. case DeclarationName::CXXDeductionGuideName:
  430. return NameLoc;
  431. case DeclarationName::CXXOperatorName: {
  432. unsigned raw = LocInfo.CXXOperatorName.EndOpNameLoc;
  433. return SourceLocation::getFromRawEncoding(raw);
  434. }
  435. case DeclarationName::CXXLiteralOperatorName: {
  436. unsigned raw = LocInfo.CXXLiteralOperatorName.OpNameLoc;
  437. return SourceLocation::getFromRawEncoding(raw);
  438. }
  439. case DeclarationName::CXXConstructorName:
  440. case DeclarationName::CXXDestructorName:
  441. case DeclarationName::CXXConversionFunctionName:
  442. if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
  443. return TInfo->getTypeLoc().getEndLoc();
  444. else
  445. return NameLoc;
  446. // DNInfo work in progress: FIXME.
  447. case DeclarationName::ObjCZeroArgSelector:
  448. case DeclarationName::ObjCOneArgSelector:
  449. case DeclarationName::ObjCMultiArgSelector:
  450. case DeclarationName::CXXUsingDirective:
  451. return NameLoc;
  452. }
  453. llvm_unreachable("Unexpected declaration name kind");
  454. }