contrib/llvm/tools/clang/lib/AST/NestedNameSpecifier.cpp

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