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

   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 *
  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 *
  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 *
  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 *
  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 *
 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 *
 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 *
 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 *
 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
 143 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.
 169 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.
 177 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.
 185 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.
 203 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.
 233 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
 253 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.
 274 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
 351 LLVM_DUMP_METHOD void NestedNameSpecifier::dump(const LangOptions &LO) const {
 352   dump(llvm::errs(), LO);
 353 }
 354
 355 LLVM_DUMP_METHOD void NestedNameSpecifier::dump() const { dump(llvm::errs()); }
 356
 357 LLVM_DUMP_METHOD void NestedNameSpecifier::dump(llvm::raw_ostream &OS) const {
 358   LangOptions LO;
 359   dump(OS, LO);
 360 }
 361
 362 LLVM_DUMP_METHOD void NestedNameSpecifier::dump(llvm::raw_ostream &OS,
 363                                                 const LangOptions &LO) const {
 364   print(OS, PrintingPolicy(LO));
 365 }
 366
 367 unsigned
 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
 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.
 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.
 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
 422 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
 434 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
 464 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
 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.
 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.
 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::
 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::
 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
 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
 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
 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
 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
 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
 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
 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
 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
 701 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 }