1 //===- NestedNameSpecifier.cpp - C++ nested name specifiers ---------------===//
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 defines the NestedNameSpecifier class, which represents
11 // a C++ nested-name-specifier.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #include "clang/AST/NestedNameSpecifier.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/Decl.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/PrettyPrinter.h"
21 #include "clang/AST/TemplateName.h"
22 #include "clang/AST/Type.h"
23 #include "clang/AST/TypeLoc.h"
24 #include "clang/Basic/LLVM.h"
25 #include "clang/Basic/LangOptions.h"
26 #include "clang/Basic/SourceLocation.h"
27 #include "llvm/ADT/FoldingSet.h"
28 #include "llvm/ADT/SmallVector.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 <cstdlib>
36 #include <cstring>
37
38 using namespace clang;
39
40 NestedNameSpecifier *
FindOrInsert(const ASTContext & Context,const NestedNameSpecifier & Mockup)41 NestedNameSpecifier::FindOrInsert(const ASTContext &Context,
42 const NestedNameSpecifier &Mockup) {
43 llvm::FoldingSetNodeID ID;
44 Mockup.Profile(ID);
45
46 void *InsertPos = nullptr;
47 NestedNameSpecifier *NNS
48 = Context.NestedNameSpecifiers.FindNodeOrInsertPos(ID, InsertPos);
49 if (!NNS) {
50 NNS =
51 new (Context, alignof(NestedNameSpecifier)) NestedNameSpecifier(Mockup);
52 Context.NestedNameSpecifiers.InsertNode(NNS, InsertPos);
53 }
54
55 return NNS;
56 }
57
58 NestedNameSpecifier *
Create(const ASTContext & Context,NestedNameSpecifier * Prefix,IdentifierInfo * II)59 NestedNameSpecifier::Create(const ASTContext &Context,
60 NestedNameSpecifier *Prefix, IdentifierInfo *II) {
61 assert(II && "Identifier cannot be NULL");
62 assert((!Prefix || Prefix->isDependent()) && "Prefix must be dependent");
63
64 NestedNameSpecifier Mockup;
65 Mockup.Prefix.setPointer(Prefix);
66 Mockup.Prefix.setInt(StoredIdentifier);
67 Mockup.Specifier = II;
68 return FindOrInsert(Context, Mockup);
69 }
70
71 NestedNameSpecifier *
Create(const ASTContext & Context,NestedNameSpecifier * Prefix,const NamespaceDecl * NS)72 NestedNameSpecifier::Create(const ASTContext &Context,
73 NestedNameSpecifier *Prefix,
74 const NamespaceDecl *NS) {
75 assert(NS && "Namespace cannot be NULL");
76 assert((!Prefix ||
77 (Prefix->getAsType() == nullptr &&
78 Prefix->getAsIdentifier() == nullptr)) &&
79 "Broken nested name specifier");
80 NestedNameSpecifier Mockup;
81 Mockup.Prefix.setPointer(Prefix);
82 Mockup.Prefix.setInt(StoredDecl);
83 Mockup.Specifier = const_cast<NamespaceDecl *>(NS);
84 return FindOrInsert(Context, Mockup);
85 }
86
87 NestedNameSpecifier *
Create(const ASTContext & Context,NestedNameSpecifier * Prefix,NamespaceAliasDecl * Alias)88 NestedNameSpecifier::Create(const ASTContext &Context,
89 NestedNameSpecifier *Prefix,
90 NamespaceAliasDecl *Alias) {
91 assert(Alias && "Namespace alias cannot be NULL");
92 assert((!Prefix ||
93 (Prefix->getAsType() == nullptr &&
94 Prefix->getAsIdentifier() == nullptr)) &&
95 "Broken nested name specifier");
96 NestedNameSpecifier Mockup;
97 Mockup.Prefix.setPointer(Prefix);
98 Mockup.Prefix.setInt(StoredDecl);
99 Mockup.Specifier = Alias;
100 return FindOrInsert(Context, Mockup);
101 }
102
103 NestedNameSpecifier *
Create(const ASTContext & Context,NestedNameSpecifier * Prefix,bool Template,const Type * T)104 NestedNameSpecifier::Create(const ASTContext &Context,
105 NestedNameSpecifier *Prefix,
106 bool Template, const Type *T) {
107 assert(T && "Type cannot be NULL");
108 NestedNameSpecifier Mockup;
109 Mockup.Prefix.setPointer(Prefix);
110 Mockup.Prefix.setInt(Template? StoredTypeSpecWithTemplate : StoredTypeSpec);
111 Mockup.Specifier = const_cast<Type*>(T);
112 return FindOrInsert(Context, Mockup);
113 }
114
115 NestedNameSpecifier *
Create(const ASTContext & Context,IdentifierInfo * II)116 NestedNameSpecifier::Create(const ASTContext &Context, IdentifierInfo *II) {
117 assert(II && "Identifier cannot be NULL");
118 NestedNameSpecifier Mockup;
119 Mockup.Prefix.setPointer(nullptr);
120 Mockup.Prefix.setInt(StoredIdentifier);
121 Mockup.Specifier = II;
122 return FindOrInsert(Context, Mockup);
123 }
124
125 NestedNameSpecifier *
GlobalSpecifier(const ASTContext & Context)126 NestedNameSpecifier::GlobalSpecifier(const ASTContext &Context) {
127 if (!Context.GlobalNestedNameSpecifier)
128 Context.GlobalNestedNameSpecifier =
129 new (Context, alignof(NestedNameSpecifier)) NestedNameSpecifier();
130 return Context.GlobalNestedNameSpecifier;
131 }
132
133 NestedNameSpecifier *
SuperSpecifier(const ASTContext & Context,CXXRecordDecl * RD)134 NestedNameSpecifier::SuperSpecifier(const ASTContext &Context,
135 CXXRecordDecl *RD) {
136 NestedNameSpecifier Mockup;
137 Mockup.Prefix.setPointer(nullptr);
138 Mockup.Prefix.setInt(StoredDecl);
139 Mockup.Specifier = RD;
140 return FindOrInsert(Context, Mockup);
141 }
142
getKind() const143 NestedNameSpecifier::SpecifierKind NestedNameSpecifier::getKind() const {
144 if (!Specifier)
145 return Global;
146
147 switch (Prefix.getInt()) {
148 case StoredIdentifier:
149 return Identifier;
150
151 case StoredDecl: {
152 NamedDecl *ND = static_cast<NamedDecl *>(Specifier);
153 if (isa<CXXRecordDecl>(ND))
154 return Super;
155 return isa<NamespaceDecl>(ND) ? Namespace : NamespaceAlias;
156 }
157
158 case StoredTypeSpec:
159 return TypeSpec;
160
161 case StoredTypeSpecWithTemplate:
162 return TypeSpecWithTemplate;
163 }
164
165 llvm_unreachable("Invalid NNS Kind!");
166 }
167
168 /// Retrieve the namespace stored in this nested name specifier.
getAsNamespace() const169 NamespaceDecl *NestedNameSpecifier::getAsNamespace() const {
170 if (Prefix.getInt() == StoredDecl)
171 return dyn_cast<NamespaceDecl>(static_cast<NamedDecl *>(Specifier));
172
173 return nullptr;
174 }
175
176 /// Retrieve the namespace alias stored in this nested name specifier.
getAsNamespaceAlias() const177 NamespaceAliasDecl *NestedNameSpecifier::getAsNamespaceAlias() const {
178 if (Prefix.getInt() == StoredDecl)
179 return dyn_cast<NamespaceAliasDecl>(static_cast<NamedDecl *>(Specifier));
180
181 return nullptr;
182 }
183
184 /// Retrieve the record declaration stored in this nested name specifier.
getAsRecordDecl() const185 CXXRecordDecl *NestedNameSpecifier::getAsRecordDecl() const {
186 switch (Prefix.getInt()) {
187 case StoredIdentifier:
188 return nullptr;
189
190 case StoredDecl:
191 return dyn_cast<CXXRecordDecl>(static_cast<NamedDecl *>(Specifier));
192
193 case StoredTypeSpec:
194 case StoredTypeSpecWithTemplate:
195 return getAsType()->getAsCXXRecordDecl();
196 }
197
198 llvm_unreachable("Invalid NNS Kind!");
199 }
200
201 /// Whether this nested name specifier refers to a dependent
202 /// type or not.
isDependent() const203 bool NestedNameSpecifier::isDependent() const {
204 switch (getKind()) {
205 case Identifier:
206 // Identifier specifiers always represent dependent types
207 return true;
208
209 case Namespace:
210 case NamespaceAlias:
211 case Global:
212 return false;
213
214 case Super: {
215 CXXRecordDecl *RD = static_cast<CXXRecordDecl *>(Specifier);
216 for (const auto &Base : RD->bases())
217 if (Base.getType()->isDependentType())
218 return true;
219
220 return false;
221 }
222
223 case TypeSpec:
224 case TypeSpecWithTemplate:
225 return getAsType()->isDependentType();
226 }
227
228 llvm_unreachable("Invalid NNS Kind!");
229 }
230
231 /// Whether this nested name specifier refers to a dependent
232 /// type or not.
isInstantiationDependent() const233 bool NestedNameSpecifier::isInstantiationDependent() const {
234 switch (getKind()) {
235 case Identifier:
236 // Identifier specifiers always represent dependent types
237 return true;
238
239 case Namespace:
240 case NamespaceAlias:
241 case Global:
242 case Super:
243 return false;
244
245 case TypeSpec:
246 case TypeSpecWithTemplate:
247 return getAsType()->isInstantiationDependentType();
248 }
249
250 llvm_unreachable("Invalid NNS Kind!");
251 }
252
containsUnexpandedParameterPack() const253 bool NestedNameSpecifier::containsUnexpandedParameterPack() const {
254 switch (getKind()) {
255 case Identifier:
256 return getPrefix() && getPrefix()->containsUnexpandedParameterPack();
257
258 case Namespace:
259 case NamespaceAlias:
260 case Global:
261 case Super:
262 return false;
263
264 case TypeSpec:
265 case TypeSpecWithTemplate:
266 return getAsType()->containsUnexpandedParameterPack();
267 }
268
269 llvm_unreachable("Invalid NNS Kind!");
270 }
271
272 /// Print this nested name specifier to the given output
273 /// stream.
print(raw_ostream & OS,const PrintingPolicy & Policy,bool ResolveTemplateArguments) const274 void NestedNameSpecifier::print(raw_ostream &OS, const PrintingPolicy &Policy,
275 bool ResolveTemplateArguments) const {
276 if (getPrefix())
277 getPrefix()->print(OS, Policy);
278
279 switch (getKind()) {
280 case Identifier:
281 OS << getAsIdentifier()->getName();
282 break;
283
284 case Namespace:
285 if (getAsNamespace()->isAnonymousNamespace())
286 return;
287
288 OS << getAsNamespace()->getName();
289 break;
290
291 case NamespaceAlias:
292 OS << getAsNamespaceAlias()->getName();
293 break;
294
295 case Global:
296 break;
297
298 case Super:
299 OS << "__super";
300 break;
301
302 case TypeSpecWithTemplate:
303 OS << "template ";
304 // Fall through to print the type.
305 LLVM_FALLTHROUGH;
306
307 case TypeSpec: {
308 const auto *Record =
309 dyn_cast_or_null<ClassTemplateSpecializationDecl>(getAsRecordDecl());
310 if (ResolveTemplateArguments && Record) {
311 // Print the type trait with resolved template parameters.
312 Record->printName(OS);
313 printTemplateArgumentList(OS, Record->getTemplateArgs().asArray(),
314 Policy);
315 break;
316 }
317 const Type *T = getAsType();
318
319 PrintingPolicy InnerPolicy(Policy);
320 InnerPolicy.SuppressScope = true;
321
322 // Nested-name-specifiers are intended to contain minimally-qualified
323 // types. An actual ElaboratedType will not occur, since we'll store
324 // just the type that is referred to in the nested-name-specifier (e.g.,
325 // a TypedefType, TagType, etc.). However, when we are dealing with
326 // dependent template-id types (e.g., Outer<T>::template Inner<U>),
327 // the type requires its own nested-name-specifier for uniqueness, so we
328 // suppress that nested-name-specifier during printing.
329 assert(!isa<ElaboratedType>(T) &&
330 "Elaborated type in nested-name-specifier");
331 if (const TemplateSpecializationType *SpecType
332 = dyn_cast<TemplateSpecializationType>(T)) {
333 // Print the template name without its corresponding
334 // nested-name-specifier.
335 SpecType->getTemplateName().print(OS, InnerPolicy, true);
336
337 // Print the template argument list.
338 printTemplateArgumentList(OS, SpecType->template_arguments(),
339 InnerPolicy);
340 } else {
341 // Print the type normally
342 QualType(T, 0).print(OS, InnerPolicy);
343 }
344 break;
345 }
346 }
347
348 OS << "::";
349 }
350
dump(const LangOptions & LO) const351 LLVM_DUMP_METHOD void NestedNameSpecifier::dump(const LangOptions &LO) const {
352 dump(llvm::errs(), LO);
353 }
354
dump() const355 LLVM_DUMP_METHOD void NestedNameSpecifier::dump() const { dump(llvm::errs()); }
356
dump(llvm::raw_ostream & OS) const357 LLVM_DUMP_METHOD void NestedNameSpecifier::dump(llvm::raw_ostream &OS) const {
358 LangOptions LO;
359 dump(OS, LO);
360 }
361
dump(llvm::raw_ostream & OS,const LangOptions & LO) const362 LLVM_DUMP_METHOD void NestedNameSpecifier::dump(llvm::raw_ostream &OS,
363 const LangOptions &LO) const {
364 print(OS, PrintingPolicy(LO));
365 }
366
367 unsigned
getLocalDataLength(NestedNameSpecifier * Qualifier)368 NestedNameSpecifierLoc::getLocalDataLength(NestedNameSpecifier *Qualifier) {
369 assert(Qualifier && "Expected a non-NULL qualifier");
370
371 // Location of the trailing '::'.
372 unsigned Length = sizeof(unsigned);
373
374 switch (Qualifier->getKind()) {
375 case NestedNameSpecifier::Global:
376 // Nothing more to add.
377 break;
378
379 case NestedNameSpecifier::Identifier:
380 case NestedNameSpecifier::Namespace:
381 case NestedNameSpecifier::NamespaceAlias:
382 case NestedNameSpecifier::Super:
383 // The location of the identifier or namespace name.
384 Length += sizeof(unsigned);
385 break;
386
387 case NestedNameSpecifier::TypeSpecWithTemplate:
388 case NestedNameSpecifier::TypeSpec:
389 // The "void*" that points at the TypeLoc data.
390 // Note: the 'template' keyword is part of the TypeLoc.
391 Length += sizeof(void *);
392 break;
393 }
394
395 return Length;
396 }
397
398 unsigned
getDataLength(NestedNameSpecifier * Qualifier)399 NestedNameSpecifierLoc::getDataLength(NestedNameSpecifier *Qualifier) {
400 unsigned Length = 0;
401 for (; Qualifier; Qualifier = Qualifier->getPrefix())
402 Length += getLocalDataLength(Qualifier);
403 return Length;
404 }
405
406 /// Load a (possibly unaligned) source location from a given address
407 /// and offset.
LoadSourceLocation(void * Data,unsigned Offset)408 static SourceLocation LoadSourceLocation(void *Data, unsigned Offset) {
409 unsigned Raw;
410 memcpy(&Raw, static_cast<char *>(Data) + Offset, sizeof(unsigned));
411 return SourceLocation::getFromRawEncoding(Raw);
412 }
413
414 /// Load a (possibly unaligned) pointer from a given address and
415 /// offset.
LoadPointer(void * Data,unsigned Offset)416 static void *LoadPointer(void *Data, unsigned Offset) {
417 void *Result;
418 memcpy(&Result, static_cast<char *>(Data) + Offset, sizeof(void*));
419 return Result;
420 }
421
getSourceRange() const422 SourceRange NestedNameSpecifierLoc::getSourceRange() const {
423 if (!Qualifier)
424 return SourceRange();
425
426 NestedNameSpecifierLoc First = *this;
427 while (NestedNameSpecifierLoc Prefix = First.getPrefix())
428 First = Prefix;
429
430 return SourceRange(First.getLocalSourceRange().getBegin(),
431 getLocalSourceRange().getEnd());
432 }
433
getLocalSourceRange() const434 SourceRange NestedNameSpecifierLoc::getLocalSourceRange() const {
435 if (!Qualifier)
436 return SourceRange();
437
438 unsigned Offset = getDataLength(Qualifier->getPrefix());
439 switch (Qualifier->getKind()) {
440 case NestedNameSpecifier::Global:
441 return LoadSourceLocation(Data, Offset);
442
443 case NestedNameSpecifier::Identifier:
444 case NestedNameSpecifier::Namespace:
445 case NestedNameSpecifier::NamespaceAlias:
446 case NestedNameSpecifier::Super:
447 return SourceRange(LoadSourceLocation(Data, Offset),
448 LoadSourceLocation(Data, Offset + sizeof(unsigned)));
449
450 case NestedNameSpecifier::TypeSpecWithTemplate:
451 case NestedNameSpecifier::TypeSpec: {
452 // The "void*" that points at the TypeLoc data.
453 // Note: the 'template' keyword is part of the TypeLoc.
454 void *TypeData = LoadPointer(Data, Offset);
455 TypeLoc TL(Qualifier->getAsType(), TypeData);
456 return SourceRange(TL.getBeginLoc(),
457 LoadSourceLocation(Data, Offset + sizeof(void*)));
458 }
459 }
460
461 llvm_unreachable("Invalid NNS Kind!");
462 }
463
getTypeLoc() const464 TypeLoc NestedNameSpecifierLoc::getTypeLoc() const {
465 if (Qualifier->getKind() != NestedNameSpecifier::TypeSpec &&
466 Qualifier->getKind() != NestedNameSpecifier::TypeSpecWithTemplate)
467 return TypeLoc();
468
469 // The "void*" that points at the TypeLoc data.
470 unsigned Offset = getDataLength(Qualifier->getPrefix());
471 void *TypeData = LoadPointer(Data, Offset);
472 return TypeLoc(Qualifier->getAsType(), TypeData);
473 }
474
Append(char * Start,char * End,char * & Buffer,unsigned & BufferSize,unsigned & BufferCapacity)475 static void Append(char *Start, char *End, char *&Buffer, unsigned &BufferSize,
476 unsigned &BufferCapacity) {
477 if (Start == End)
478 return;
479
480 if (BufferSize + (End - Start) > BufferCapacity) {
481 // Reallocate the buffer.
482 unsigned NewCapacity = std::max(
483 (unsigned)(BufferCapacity ? BufferCapacity * 2 : sizeof(void *) * 2),
484 (unsigned)(BufferSize + (End - Start)));
485 char *NewBuffer = static_cast<char *>(llvm::safe_malloc(NewCapacity));
486 if (BufferCapacity) {
487 memcpy(NewBuffer, Buffer, BufferSize);
488 free(Buffer);
489 }
490 Buffer = NewBuffer;
491 BufferCapacity = NewCapacity;
492 }
493
494 memcpy(Buffer + BufferSize, Start, End - Start);
495 BufferSize += End-Start;
496 }
497
498 /// Save a source location to the given buffer.
SaveSourceLocation(SourceLocation Loc,char * & Buffer,unsigned & BufferSize,unsigned & BufferCapacity)499 static void SaveSourceLocation(SourceLocation Loc, char *&Buffer,
500 unsigned &BufferSize, unsigned &BufferCapacity) {
501 unsigned Raw = Loc.getRawEncoding();
502 Append(reinterpret_cast<char *>(&Raw),
503 reinterpret_cast<char *>(&Raw) + sizeof(unsigned),
504 Buffer, BufferSize, BufferCapacity);
505 }
506
507 /// Save a pointer to the given buffer.
SavePointer(void * Ptr,char * & Buffer,unsigned & BufferSize,unsigned & BufferCapacity)508 static void SavePointer(void *Ptr, char *&Buffer, unsigned &BufferSize,
509 unsigned &BufferCapacity) {
510 Append(reinterpret_cast<char *>(&Ptr),
511 reinterpret_cast<char *>(&Ptr) + sizeof(void *),
512 Buffer, BufferSize, BufferCapacity);
513 }
514
515 NestedNameSpecifierLocBuilder::
NestedNameSpecifierLocBuilder(const NestedNameSpecifierLocBuilder & Other)516 NestedNameSpecifierLocBuilder(const NestedNameSpecifierLocBuilder &Other)
517 : Representation(Other.Representation) {
518 if (!Other.Buffer)
519 return;
520
521 if (Other.BufferCapacity == 0) {
522 // Shallow copy is okay.
523 Buffer = Other.Buffer;
524 BufferSize = Other.BufferSize;
525 return;
526 }
527
528 // Deep copy
529 Append(Other.Buffer, Other.Buffer + Other.BufferSize, Buffer, BufferSize,
530 BufferCapacity);
531 }
532
533 NestedNameSpecifierLocBuilder &
534 NestedNameSpecifierLocBuilder::
operator =(const NestedNameSpecifierLocBuilder & Other)535 operator=(const NestedNameSpecifierLocBuilder &Other) {
536 Representation = Other.Representation;
537
538 if (Buffer && Other.Buffer && BufferCapacity >= Other.BufferSize) {
539 // Re-use our storage.
540 BufferSize = Other.BufferSize;
541 memcpy(Buffer, Other.Buffer, BufferSize);
542 return *this;
543 }
544
545 // Free our storage, if we have any.
546 if (BufferCapacity) {
547 free(Buffer);
548 BufferCapacity = 0;
549 }
550
551 if (!Other.Buffer) {
552 // Empty.
553 Buffer = nullptr;
554 BufferSize = 0;
555 return *this;
556 }
557
558 if (Other.BufferCapacity == 0) {
559 // Shallow copy is okay.
560 Buffer = Other.Buffer;
561 BufferSize = Other.BufferSize;
562 return *this;
563 }
564
565 // Deep copy.
566 BufferSize = 0;
567 Append(Other.Buffer, Other.Buffer + Other.BufferSize, Buffer, BufferSize,
568 BufferCapacity);
569 return *this;
570 }
571
Extend(ASTContext & Context,SourceLocation TemplateKWLoc,TypeLoc TL,SourceLocation ColonColonLoc)572 void NestedNameSpecifierLocBuilder::Extend(ASTContext &Context,
573 SourceLocation TemplateKWLoc,
574 TypeLoc TL,
575 SourceLocation ColonColonLoc) {
576 Representation = NestedNameSpecifier::Create(Context, Representation,
577 TemplateKWLoc.isValid(),
578 TL.getTypePtr());
579
580 // Push source-location info into the buffer.
581 SavePointer(TL.getOpaqueData(), Buffer, BufferSize, BufferCapacity);
582 SaveSourceLocation(ColonColonLoc, Buffer, BufferSize, BufferCapacity);
583 }
584
Extend(ASTContext & Context,IdentifierInfo * Identifier,SourceLocation IdentifierLoc,SourceLocation ColonColonLoc)585 void NestedNameSpecifierLocBuilder::Extend(ASTContext &Context,
586 IdentifierInfo *Identifier,
587 SourceLocation IdentifierLoc,
588 SourceLocation ColonColonLoc) {
589 Representation = NestedNameSpecifier::Create(Context, Representation,
590 Identifier);
591
592 // Push source-location info into the buffer.
593 SaveSourceLocation(IdentifierLoc, Buffer, BufferSize, BufferCapacity);
594 SaveSourceLocation(ColonColonLoc, Buffer, BufferSize, BufferCapacity);
595 }
596
Extend(ASTContext & Context,NamespaceDecl * Namespace,SourceLocation NamespaceLoc,SourceLocation ColonColonLoc)597 void NestedNameSpecifierLocBuilder::Extend(ASTContext &Context,
598 NamespaceDecl *Namespace,
599 SourceLocation NamespaceLoc,
600 SourceLocation ColonColonLoc) {
601 Representation = NestedNameSpecifier::Create(Context, Representation,
602 Namespace);
603
604 // Push source-location info into the buffer.
605 SaveSourceLocation(NamespaceLoc, Buffer, BufferSize, BufferCapacity);
606 SaveSourceLocation(ColonColonLoc, Buffer, BufferSize, BufferCapacity);
607 }
608
Extend(ASTContext & Context,NamespaceAliasDecl * Alias,SourceLocation AliasLoc,SourceLocation ColonColonLoc)609 void NestedNameSpecifierLocBuilder::Extend(ASTContext &Context,
610 NamespaceAliasDecl *Alias,
611 SourceLocation AliasLoc,
612 SourceLocation ColonColonLoc) {
613 Representation = NestedNameSpecifier::Create(Context, Representation, Alias);
614
615 // Push source-location info into the buffer.
616 SaveSourceLocation(AliasLoc, Buffer, BufferSize, BufferCapacity);
617 SaveSourceLocation(ColonColonLoc, Buffer, BufferSize, BufferCapacity);
618 }
619
MakeGlobal(ASTContext & Context,SourceLocation ColonColonLoc)620 void NestedNameSpecifierLocBuilder::MakeGlobal(ASTContext &Context,
621 SourceLocation ColonColonLoc) {
622 assert(!Representation && "Already have a nested-name-specifier!?");
623 Representation = NestedNameSpecifier::GlobalSpecifier(Context);
624
625 // Push source-location info into the buffer.
626 SaveSourceLocation(ColonColonLoc, Buffer, BufferSize, BufferCapacity);
627 }
628
MakeSuper(ASTContext & Context,CXXRecordDecl * RD,SourceLocation SuperLoc,SourceLocation ColonColonLoc)629 void NestedNameSpecifierLocBuilder::MakeSuper(ASTContext &Context,
630 CXXRecordDecl *RD,
631 SourceLocation SuperLoc,
632 SourceLocation ColonColonLoc) {
633 Representation = NestedNameSpecifier::SuperSpecifier(Context, RD);
634
635 // Push source-location info into the buffer.
636 SaveSourceLocation(SuperLoc, Buffer, BufferSize, BufferCapacity);
637 SaveSourceLocation(ColonColonLoc, Buffer, BufferSize, BufferCapacity);
638 }
639
MakeTrivial(ASTContext & Context,NestedNameSpecifier * Qualifier,SourceRange R)640 void NestedNameSpecifierLocBuilder::MakeTrivial(ASTContext &Context,
641 NestedNameSpecifier *Qualifier,
642 SourceRange R) {
643 Representation = Qualifier;
644
645 // Construct bogus (but well-formed) source information for the
646 // nested-name-specifier.
647 BufferSize = 0;
648 SmallVector<NestedNameSpecifier *, 4> Stack;
649 for (NestedNameSpecifier *NNS = Qualifier; NNS; NNS = NNS->getPrefix())
650 Stack.push_back(NNS);
651 while (!Stack.empty()) {
652 NestedNameSpecifier *NNS = Stack.pop_back_val();
653 switch (NNS->getKind()) {
654 case NestedNameSpecifier::Identifier:
655 case NestedNameSpecifier::Namespace:
656 case NestedNameSpecifier::NamespaceAlias:
657 SaveSourceLocation(R.getBegin(), Buffer, BufferSize, BufferCapacity);
658 break;
659
660 case NestedNameSpecifier::TypeSpec:
661 case NestedNameSpecifier::TypeSpecWithTemplate: {
662 TypeSourceInfo *TSInfo
663 = Context.getTrivialTypeSourceInfo(QualType(NNS->getAsType(), 0),
664 R.getBegin());
665 SavePointer(TSInfo->getTypeLoc().getOpaqueData(), Buffer, BufferSize,
666 BufferCapacity);
667 break;
668 }
669
670 case NestedNameSpecifier::Global:
671 case NestedNameSpecifier::Super:
672 break;
673 }
674
675 // Save the location of the '::'.
676 SaveSourceLocation(Stack.empty()? R.getEnd() : R.getBegin(),
677 Buffer, BufferSize, BufferCapacity);
678 }
679 }
680
Adopt(NestedNameSpecifierLoc Other)681 void NestedNameSpecifierLocBuilder::Adopt(NestedNameSpecifierLoc Other) {
682 if (BufferCapacity)
683 free(Buffer);
684
685 if (!Other) {
686 Representation = nullptr;
687 BufferSize = 0;
688 return;
689 }
690
691 // Rather than copying the data (which is wasteful), "adopt" the
692 // pointer (which points into the ASTContext) but set the capacity to zero to
693 // indicate that we don't own it.
694 Representation = Other.getNestedNameSpecifier();
695 Buffer = static_cast<char *>(Other.getOpaqueData());
696 BufferSize = Other.getDataLength();
697 BufferCapacity = 0;
698 }
699
700 NestedNameSpecifierLoc
getWithLocInContext(ASTContext & Context) const701 NestedNameSpecifierLocBuilder::getWithLocInContext(ASTContext &Context) const {
702 if (!Representation)
703 return NestedNameSpecifierLoc();
704
705 // If we adopted our data pointer from elsewhere in the AST context, there's
706 // no need to copy the memory.
707 if (BufferCapacity == 0)
708 return NestedNameSpecifierLoc(Representation, Buffer);
709
710 // FIXME: After copying the source-location information, should we free
711 // our (temporary) buffer and adopt the ASTContext-allocated memory?
712 // Doing so would optimize repeated calls to getWithLocInContext().
713 void *Mem = Context.Allocate(BufferSize, alignof(void *));
714 memcpy(Mem, Buffer, BufferSize);
715 return NestedNameSpecifierLoc(Representation, Mem);
716 }
717