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