1 //===-- DeclarationName.cpp - Declaration names implementation --*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the DeclarationName and DeclarationNameTable
11 // classes.
12 //
13 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/Decl.h"
16 #include "clang/AST/DeclarationName.h"
17 #include "clang/AST/Type.h"
18 #include "clang/AST/TypeLoc.h"
19 #include "clang/AST/TypeOrdering.h"
20 #include "clang/Basic/IdentifierTable.h"
21 #include "llvm/ADT/DenseMap.h"
22 #include "llvm/ADT/FoldingSet.h"
23 #include "llvm/Support/ErrorHandling.h"
24 #include "llvm/Support/raw_ostream.h"
25 using namespace clang;
26
27 namespace clang {
28 /// CXXSpecialName - Records the type associated with one of the
29 /// "special" kinds of declaration names in C++, e.g., constructors,
30 /// destructors, and conversion functions.
31 class CXXSpecialName
32 : public DeclarationNameExtra, public llvm::FoldingSetNode {
33 public:
34 /// Type - The type associated with this declaration name.
35 QualType Type;
36
37 /// FETokenInfo - Extra information associated with this declaration
38 /// name that can be used by the front end.
39 void *FETokenInfo;
40
Profile(llvm::FoldingSetNodeID & ID)41 void Profile(llvm::FoldingSetNodeID &ID) {
42 ID.AddInteger(ExtraKindOrNumArgs);
43 ID.AddPointer(Type.getAsOpaquePtr());
44 }
45 };
46
47 /// CXXOperatorIdName - Contains extra information for the name of an
48 /// overloaded operator in C++, such as "operator+.
49 class CXXOperatorIdName : public DeclarationNameExtra {
50 public:
51 /// FETokenInfo - Extra information associated with this operator
52 /// name that can be used by the front end.
53 void *FETokenInfo;
54 };
55
56 /// CXXLiteralOperatorName - Contains the actual identifier that makes up the
57 /// name.
58 ///
59 /// This identifier is stored here rather than directly in DeclarationName so as
60 /// to allow Objective-C selectors, which are about a million times more common,
61 /// to consume minimal memory.
62 class CXXLiteralOperatorIdName
63 : public DeclarationNameExtra, public llvm::FoldingSetNode {
64 public:
65 IdentifierInfo *ID;
66
67 /// FETokenInfo - Extra information associated with this operator
68 /// name that can be used by the front end.
69 void *FETokenInfo;
70
Profile(llvm::FoldingSetNodeID & FSID)71 void Profile(llvm::FoldingSetNodeID &FSID) {
72 FSID.AddPointer(ID);
73 }
74 };
75
compareInt(unsigned A,unsigned B)76 static int compareInt(unsigned A, unsigned B) {
77 return (A < B ? -1 : (A > B ? 1 : 0));
78 }
79
compare(DeclarationName LHS,DeclarationName RHS)80 int DeclarationName::compare(DeclarationName LHS, DeclarationName RHS) {
81 if (LHS.getNameKind() != RHS.getNameKind())
82 return (LHS.getNameKind() < RHS.getNameKind() ? -1 : 1);
83
84 switch (LHS.getNameKind()) {
85 case DeclarationName::Identifier: {
86 IdentifierInfo *LII = LHS.getAsIdentifierInfo();
87 IdentifierInfo *RII = RHS.getAsIdentifierInfo();
88 if (!LII) return RII ? -1 : 0;
89 if (!RII) return 1;
90
91 return LII->getName().compare(RII->getName());
92 }
93
94 case DeclarationName::ObjCZeroArgSelector:
95 case DeclarationName::ObjCOneArgSelector:
96 case DeclarationName::ObjCMultiArgSelector: {
97 Selector LHSSelector = LHS.getObjCSelector();
98 Selector RHSSelector = RHS.getObjCSelector();
99 unsigned LN = LHSSelector.getNumArgs(), RN = RHSSelector.getNumArgs();
100 for (unsigned I = 0, N = std::min(LN, RN); I != N; ++I) {
101 switch (LHSSelector.getNameForSlot(I).compare(
102 RHSSelector.getNameForSlot(I))) {
103 case -1: return true;
104 case 1: return false;
105 default: break;
106 }
107 }
108
109 return compareInt(LN, RN);
110 }
111
112 case DeclarationName::CXXConstructorName:
113 case DeclarationName::CXXDestructorName:
114 case DeclarationName::CXXConversionFunctionName:
115 if (QualTypeOrdering()(LHS.getCXXNameType(), RHS.getCXXNameType()))
116 return -1;
117 if (QualTypeOrdering()(RHS.getCXXNameType(), LHS.getCXXNameType()))
118 return 1;
119 return 0;
120
121 case DeclarationName::CXXOperatorName:
122 return compareInt(LHS.getCXXOverloadedOperator(),
123 RHS.getCXXOverloadedOperator());
124
125 case DeclarationName::CXXLiteralOperatorName:
126 return LHS.getCXXLiteralIdentifier()->getName().compare(
127 RHS.getCXXLiteralIdentifier()->getName());
128
129 case DeclarationName::CXXUsingDirective:
130 return 0;
131 }
132
133 llvm_unreachable("Invalid DeclarationName Kind!");
134 }
135
operator <<(raw_ostream & OS,DeclarationName N)136 raw_ostream &operator<<(raw_ostream &OS, DeclarationName N) {
137 switch (N.getNameKind()) {
138 case DeclarationName::Identifier:
139 if (const IdentifierInfo *II = N.getAsIdentifierInfo())
140 OS << II->getName();
141 return OS;
142
143 case DeclarationName::ObjCZeroArgSelector:
144 case DeclarationName::ObjCOneArgSelector:
145 case DeclarationName::ObjCMultiArgSelector:
146 return OS << N.getObjCSelector().getAsString();
147
148 case DeclarationName::CXXConstructorName: {
149 QualType ClassType = N.getCXXNameType();
150 if (const RecordType *ClassRec = ClassType->getAs<RecordType>())
151 return OS << *ClassRec->getDecl();
152 return OS << ClassType.getAsString();
153 }
154
155 case DeclarationName::CXXDestructorName: {
156 OS << '~';
157 QualType Type = N.getCXXNameType();
158 if (const RecordType *Rec = Type->getAs<RecordType>())
159 return OS << *Rec->getDecl();
160 return OS << Type.getAsString();
161 }
162
163 case DeclarationName::CXXOperatorName: {
164 static const char* const OperatorNames[NUM_OVERLOADED_OPERATORS] = {
165 0,
166 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
167 Spelling,
168 #include "clang/Basic/OperatorKinds.def"
169 };
170 const char *OpName = OperatorNames[N.getCXXOverloadedOperator()];
171 assert(OpName && "not an overloaded operator");
172
173 OS << "operator";
174 if (OpName[0] >= 'a' && OpName[0] <= 'z')
175 OS << ' ';
176 return OS << OpName;
177 }
178
179 case DeclarationName::CXXLiteralOperatorName:
180 return OS << "operator \"\" " << N.getCXXLiteralIdentifier()->getName();
181
182 case DeclarationName::CXXConversionFunctionName: {
183 OS << "operator ";
184 QualType Type = N.getCXXNameType();
185 if (const RecordType *Rec = Type->getAs<RecordType>())
186 return OS << *Rec->getDecl();
187 return OS << Type.getAsString();
188 }
189 case DeclarationName::CXXUsingDirective:
190 return OS << "<using-directive>";
191 }
192
193 llvm_unreachable("Unexpected declaration name kind");
194 }
195
196 } // end namespace clang
197
getNameKind() const198 DeclarationName::NameKind DeclarationName::getNameKind() const {
199 switch (getStoredNameKind()) {
200 case StoredIdentifier: return Identifier;
201 case StoredObjCZeroArgSelector: return ObjCZeroArgSelector;
202 case StoredObjCOneArgSelector: return ObjCOneArgSelector;
203
204 case StoredDeclarationNameExtra:
205 switch (getExtra()->ExtraKindOrNumArgs) {
206 case DeclarationNameExtra::CXXConstructor:
207 return CXXConstructorName;
208
209 case DeclarationNameExtra::CXXDestructor:
210 return CXXDestructorName;
211
212 case DeclarationNameExtra::CXXConversionFunction:
213 return CXXConversionFunctionName;
214
215 case DeclarationNameExtra::CXXLiteralOperator:
216 return CXXLiteralOperatorName;
217
218 case DeclarationNameExtra::CXXUsingDirective:
219 return CXXUsingDirective;
220
221 default:
222 // Check if we have one of the CXXOperator* enumeration values.
223 if (getExtra()->ExtraKindOrNumArgs <
224 DeclarationNameExtra::CXXUsingDirective)
225 return CXXOperatorName;
226
227 return ObjCMultiArgSelector;
228 }
229 }
230
231 // Can't actually get here.
232 llvm_unreachable("This should be unreachable!");
233 }
234
isDependentName() const235 bool DeclarationName::isDependentName() const {
236 QualType T = getCXXNameType();
237 return !T.isNull() && T->isDependentType();
238 }
239
getAsString() const240 std::string DeclarationName::getAsString() const {
241 std::string Result;
242 llvm::raw_string_ostream OS(Result);
243 OS << *this;
244 return OS.str();
245 }
246
getCXXNameType() const247 QualType DeclarationName::getCXXNameType() const {
248 if (CXXSpecialName *CXXName = getAsCXXSpecialName())
249 return CXXName->Type;
250 else
251 return QualType();
252 }
253
getCXXOverloadedOperator() const254 OverloadedOperatorKind DeclarationName::getCXXOverloadedOperator() const {
255 if (CXXOperatorIdName *CXXOp = getAsCXXOperatorIdName()) {
256 unsigned value
257 = CXXOp->ExtraKindOrNumArgs - DeclarationNameExtra::CXXConversionFunction;
258 return static_cast<OverloadedOperatorKind>(value);
259 } else {
260 return OO_None;
261 }
262 }
263
getCXXLiteralIdentifier() const264 IdentifierInfo *DeclarationName::getCXXLiteralIdentifier() const {
265 if (CXXLiteralOperatorIdName *CXXLit = getAsCXXLiteralOperatorIdName())
266 return CXXLit->ID;
267 else
268 return 0;
269 }
270
getFETokenInfoAsVoidSlow() const271 void *DeclarationName::getFETokenInfoAsVoidSlow() const {
272 switch (getNameKind()) {
273 case Identifier:
274 llvm_unreachable("Handled by getFETokenInfo()");
275
276 case CXXConstructorName:
277 case CXXDestructorName:
278 case CXXConversionFunctionName:
279 return getAsCXXSpecialName()->FETokenInfo;
280
281 case CXXOperatorName:
282 return getAsCXXOperatorIdName()->FETokenInfo;
283
284 case CXXLiteralOperatorName:
285 return getAsCXXLiteralOperatorIdName()->FETokenInfo;
286
287 default:
288 llvm_unreachable("Declaration name has no FETokenInfo");
289 }
290 }
291
setFETokenInfo(void * T)292 void DeclarationName::setFETokenInfo(void *T) {
293 switch (getNameKind()) {
294 case Identifier:
295 getAsIdentifierInfo()->setFETokenInfo(T);
296 break;
297
298 case CXXConstructorName:
299 case CXXDestructorName:
300 case CXXConversionFunctionName:
301 getAsCXXSpecialName()->FETokenInfo = T;
302 break;
303
304 case CXXOperatorName:
305 getAsCXXOperatorIdName()->FETokenInfo = T;
306 break;
307
308 case CXXLiteralOperatorName:
309 getAsCXXLiteralOperatorIdName()->FETokenInfo = T;
310 break;
311
312 default:
313 llvm_unreachable("Declaration name has no FETokenInfo");
314 }
315 }
316
getUsingDirectiveName()317 DeclarationName DeclarationName::getUsingDirectiveName() {
318 // Single instance of DeclarationNameExtra for using-directive
319 static const DeclarationNameExtra UDirExtra =
320 { DeclarationNameExtra::CXXUsingDirective };
321
322 uintptr_t Ptr = reinterpret_cast<uintptr_t>(&UDirExtra);
323 Ptr |= StoredDeclarationNameExtra;
324
325 return DeclarationName(Ptr);
326 }
327
dump() const328 void DeclarationName::dump() const {
329 llvm::errs() << *this << '\n';
330 }
331
DeclarationNameTable(const ASTContext & C)332 DeclarationNameTable::DeclarationNameTable(const ASTContext &C) : Ctx(C) {
333 CXXSpecialNamesImpl = new llvm::FoldingSet<CXXSpecialName>;
334 CXXLiteralOperatorNames = new llvm::FoldingSet<CXXLiteralOperatorIdName>;
335
336 // Initialize the overloaded operator names.
337 CXXOperatorNames = new (Ctx) CXXOperatorIdName[NUM_OVERLOADED_OPERATORS];
338 for (unsigned Op = 0; Op < NUM_OVERLOADED_OPERATORS; ++Op) {
339 CXXOperatorNames[Op].ExtraKindOrNumArgs
340 = Op + DeclarationNameExtra::CXXConversionFunction;
341 CXXOperatorNames[Op].FETokenInfo = 0;
342 }
343 }
344
~DeclarationNameTable()345 DeclarationNameTable::~DeclarationNameTable() {
346 llvm::FoldingSet<CXXSpecialName> *SpecialNames =
347 static_cast<llvm::FoldingSet<CXXSpecialName>*>(CXXSpecialNamesImpl);
348 llvm::FoldingSet<CXXLiteralOperatorIdName> *LiteralNames
349 = static_cast<llvm::FoldingSet<CXXLiteralOperatorIdName>*>
350 (CXXLiteralOperatorNames);
351
352 delete SpecialNames;
353 delete LiteralNames;
354 }
355
getCXXConstructorName(CanQualType Ty)356 DeclarationName DeclarationNameTable::getCXXConstructorName(CanQualType Ty) {
357 return getCXXSpecialName(DeclarationName::CXXConstructorName,
358 Ty.getUnqualifiedType());
359 }
360
getCXXDestructorName(CanQualType Ty)361 DeclarationName DeclarationNameTable::getCXXDestructorName(CanQualType Ty) {
362 return getCXXSpecialName(DeclarationName::CXXDestructorName,
363 Ty.getUnqualifiedType());
364 }
365
366 DeclarationName
getCXXConversionFunctionName(CanQualType Ty)367 DeclarationNameTable::getCXXConversionFunctionName(CanQualType Ty) {
368 return getCXXSpecialName(DeclarationName::CXXConversionFunctionName, Ty);
369 }
370
371 DeclarationName
getCXXSpecialName(DeclarationName::NameKind Kind,CanQualType Ty)372 DeclarationNameTable::getCXXSpecialName(DeclarationName::NameKind Kind,
373 CanQualType Ty) {
374 assert(Kind >= DeclarationName::CXXConstructorName &&
375 Kind <= DeclarationName::CXXConversionFunctionName &&
376 "Kind must be a C++ special name kind");
377 llvm::FoldingSet<CXXSpecialName> *SpecialNames
378 = static_cast<llvm::FoldingSet<CXXSpecialName>*>(CXXSpecialNamesImpl);
379
380 DeclarationNameExtra::ExtraKind EKind;
381 switch (Kind) {
382 case DeclarationName::CXXConstructorName:
383 EKind = DeclarationNameExtra::CXXConstructor;
384 assert(!Ty.hasQualifiers() &&"Constructor type must be unqualified");
385 break;
386 case DeclarationName::CXXDestructorName:
387 EKind = DeclarationNameExtra::CXXDestructor;
388 assert(!Ty.hasQualifiers() && "Destructor type must be unqualified");
389 break;
390 case DeclarationName::CXXConversionFunctionName:
391 EKind = DeclarationNameExtra::CXXConversionFunction;
392 break;
393 default:
394 return DeclarationName();
395 }
396
397 // Unique selector, to guarantee there is one per name.
398 llvm::FoldingSetNodeID ID;
399 ID.AddInteger(EKind);
400 ID.AddPointer(Ty.getAsOpaquePtr());
401
402 void *InsertPos = 0;
403 if (CXXSpecialName *Name = SpecialNames->FindNodeOrInsertPos(ID, InsertPos))
404 return DeclarationName(Name);
405
406 CXXSpecialName *SpecialName = new (Ctx) CXXSpecialName;
407 SpecialName->ExtraKindOrNumArgs = EKind;
408 SpecialName->Type = Ty;
409 SpecialName->FETokenInfo = 0;
410
411 SpecialNames->InsertNode(SpecialName, InsertPos);
412 return DeclarationName(SpecialName);
413 }
414
415 DeclarationName
getCXXOperatorName(OverloadedOperatorKind Op)416 DeclarationNameTable::getCXXOperatorName(OverloadedOperatorKind Op) {
417 return DeclarationName(&CXXOperatorNames[(unsigned)Op]);
418 }
419
420 DeclarationName
getCXXLiteralOperatorName(IdentifierInfo * II)421 DeclarationNameTable::getCXXLiteralOperatorName(IdentifierInfo *II) {
422 llvm::FoldingSet<CXXLiteralOperatorIdName> *LiteralNames
423 = static_cast<llvm::FoldingSet<CXXLiteralOperatorIdName>*>
424 (CXXLiteralOperatorNames);
425
426 llvm::FoldingSetNodeID ID;
427 ID.AddPointer(II);
428
429 void *InsertPos = 0;
430 if (CXXLiteralOperatorIdName *Name =
431 LiteralNames->FindNodeOrInsertPos(ID, InsertPos))
432 return DeclarationName (Name);
433
434 CXXLiteralOperatorIdName *LiteralName = new (Ctx) CXXLiteralOperatorIdName;
435 LiteralName->ExtraKindOrNumArgs = DeclarationNameExtra::CXXLiteralOperator;
436 LiteralName->ID = II;
437 LiteralName->FETokenInfo = 0;
438
439 LiteralNames->InsertNode(LiteralName, InsertPos);
440 return DeclarationName(LiteralName);
441 }
442
DeclarationNameLoc(DeclarationName Name)443 DeclarationNameLoc::DeclarationNameLoc(DeclarationName Name) {
444 switch (Name.getNameKind()) {
445 case DeclarationName::Identifier:
446 break;
447 case DeclarationName::CXXConstructorName:
448 case DeclarationName::CXXDestructorName:
449 case DeclarationName::CXXConversionFunctionName:
450 NamedType.TInfo = 0;
451 break;
452 case DeclarationName::CXXOperatorName:
453 CXXOperatorName.BeginOpNameLoc = SourceLocation().getRawEncoding();
454 CXXOperatorName.EndOpNameLoc = SourceLocation().getRawEncoding();
455 break;
456 case DeclarationName::CXXLiteralOperatorName:
457 CXXLiteralOperatorName.OpNameLoc = SourceLocation().getRawEncoding();
458 break;
459 case DeclarationName::ObjCZeroArgSelector:
460 case DeclarationName::ObjCOneArgSelector:
461 case DeclarationName::ObjCMultiArgSelector:
462 // FIXME: ?
463 break;
464 case DeclarationName::CXXUsingDirective:
465 break;
466 }
467 }
468
containsUnexpandedParameterPack() const469 bool DeclarationNameInfo::containsUnexpandedParameterPack() const {
470 switch (Name.getNameKind()) {
471 case DeclarationName::Identifier:
472 case DeclarationName::ObjCZeroArgSelector:
473 case DeclarationName::ObjCOneArgSelector:
474 case DeclarationName::ObjCMultiArgSelector:
475 case DeclarationName::CXXOperatorName:
476 case DeclarationName::CXXLiteralOperatorName:
477 case DeclarationName::CXXUsingDirective:
478 return false;
479
480 case DeclarationName::CXXConstructorName:
481 case DeclarationName::CXXDestructorName:
482 case DeclarationName::CXXConversionFunctionName:
483 if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
484 return TInfo->getType()->containsUnexpandedParameterPack();
485
486 return Name.getCXXNameType()->containsUnexpandedParameterPack();
487 }
488 llvm_unreachable("All name kinds handled.");
489 }
490
isInstantiationDependent() const491 bool DeclarationNameInfo::isInstantiationDependent() const {
492 switch (Name.getNameKind()) {
493 case DeclarationName::Identifier:
494 case DeclarationName::ObjCZeroArgSelector:
495 case DeclarationName::ObjCOneArgSelector:
496 case DeclarationName::ObjCMultiArgSelector:
497 case DeclarationName::CXXOperatorName:
498 case DeclarationName::CXXLiteralOperatorName:
499 case DeclarationName::CXXUsingDirective:
500 return false;
501
502 case DeclarationName::CXXConstructorName:
503 case DeclarationName::CXXDestructorName:
504 case DeclarationName::CXXConversionFunctionName:
505 if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
506 return TInfo->getType()->isInstantiationDependentType();
507
508 return Name.getCXXNameType()->isInstantiationDependentType();
509 }
510 llvm_unreachable("All name kinds handled.");
511 }
512
getAsString() const513 std::string DeclarationNameInfo::getAsString() const {
514 std::string Result;
515 llvm::raw_string_ostream OS(Result);
516 printName(OS);
517 return OS.str();
518 }
519
printName(raw_ostream & OS) const520 void DeclarationNameInfo::printName(raw_ostream &OS) const {
521 switch (Name.getNameKind()) {
522 case DeclarationName::Identifier:
523 case DeclarationName::ObjCZeroArgSelector:
524 case DeclarationName::ObjCOneArgSelector:
525 case DeclarationName::ObjCMultiArgSelector:
526 case DeclarationName::CXXOperatorName:
527 case DeclarationName::CXXLiteralOperatorName:
528 case DeclarationName::CXXUsingDirective:
529 OS << Name;
530 return;
531
532 case DeclarationName::CXXConstructorName:
533 case DeclarationName::CXXDestructorName:
534 case DeclarationName::CXXConversionFunctionName:
535 if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo) {
536 if (Name.getNameKind() == DeclarationName::CXXDestructorName)
537 OS << '~';
538 else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName)
539 OS << "operator ";
540 OS << TInfo->getType().getAsString();
541 } else
542 OS << Name;
543 return;
544 }
545 llvm_unreachable("Unexpected declaration name kind");
546 }
547
getEndLoc() const548 SourceLocation DeclarationNameInfo::getEndLoc() const {
549 switch (Name.getNameKind()) {
550 case DeclarationName::Identifier:
551 return NameLoc;
552
553 case DeclarationName::CXXOperatorName: {
554 unsigned raw = LocInfo.CXXOperatorName.EndOpNameLoc;
555 return SourceLocation::getFromRawEncoding(raw);
556 }
557
558 case DeclarationName::CXXLiteralOperatorName: {
559 unsigned raw = LocInfo.CXXLiteralOperatorName.OpNameLoc;
560 return SourceLocation::getFromRawEncoding(raw);
561 }
562
563 case DeclarationName::CXXConstructorName:
564 case DeclarationName::CXXDestructorName:
565 case DeclarationName::CXXConversionFunctionName:
566 if (TypeSourceInfo *TInfo = LocInfo.NamedType.TInfo)
567 return TInfo->getTypeLoc().getEndLoc();
568 else
569 return NameLoc;
570
571 // DNInfo work in progress: FIXME.
572 case DeclarationName::ObjCZeroArgSelector:
573 case DeclarationName::ObjCOneArgSelector:
574 case DeclarationName::ObjCMultiArgSelector:
575 case DeclarationName::CXXUsingDirective:
576 return NameLoc;
577 }
578 llvm_unreachable("Unexpected declaration name kind");
579 }
580