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