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