[Tooling] Add optional argument to getFullyQualifiedName to prepend "::".

[saugustine]

This looks good and useful to me on the Tooling/Core side, but someone more familiar with the internals of NestedNamesSpecifiers should sign off on that portion.

Also, I would probably add a test case for _Bool, which is a case that has confused other logic like this. I think it will work, but may as well include the proof.

[rnk]

lib/AST/NestedNameSpecifier.cpp

50

Doesn't this mutate the AST in place? We shouldn't be doing that.

lib/Tooling/Core/QualTypeNames.cpp

405

Rather than building the NNS here and mutating it after the fact, why not pass WithGlobalNsPrefix down to createNestedNameSpecifierForScopeOf?

[sivachandra]

A little adjustment.

[sivachandra]

lib/Tooling/Core/QualTypeNames.cpp

405

I think that can eliminate the need for the Prepend method. Let me dig a little more and get back.

[sivachandra]

Address comments.

[sivachandra]

PTAL

lib/Tooling/Core/QualTypeNames.cpp

405

WithGlobalNsPrefix has been added to every function in this file :)

This eliminates the need for the Prepend function.

[sivachandra]

Improve global type handling.

[sivachandra]

Ping.

[rnk]

lgtm

[sivachandra]

Thanks for the review; Committed.

include/clang/AST/NestedNameSpecifier.h

public:
   ///
   /// The nested-name-specifier is assumed to be dependent, but has no
   /// prefix because the prefix is implied by something outside of the
   /// nested name specifier, e.g., in "x->Base::f", the "x" has a dependent
   /// type.
   static NestedNameSpecifier *Create(const ASTContext &Context,
                                      IdentifierInfo *II);
 
+  /// \brief Builds a specifier with the global specifier ("::") prepended.
+  /// If the input specifier already has the global specifier, then the input
+  /// specifier itself is returned.
+  static NestedNameSpecifier *PrependGlobalSpecifier(
+          const ASTContext &Context, const NestedNameSpecifier *Specifier);
+  
+
   /// \brief Returns the nested name specifier representing the global
   /// scope.
   static NestedNameSpecifier *GlobalSpecifier(const ASTContext &Context);
 
   /// \brief Returns the nested name specifier representing the __super scope
   /// for the given CXXRecordDecl.
   static NestedNameSpecifier *SuperSpecifier(const ASTContext &Context,
                                              CXXRecordDecl *RD);

include/clang/Tooling/Core/QualTypeNames.h

 namespace clang {
 namespace TypeName {
 /// \brief Get the fully qualified name for a type. This includes full
 /// qualification of all template parameters etc.
 ///
 /// \param[in] QT - the type for which the fully qualified name will be
 /// returned.
 /// \param[in] Ctx - the ASTContext to be used.
+/// \param[in] WithGlobalNsPrefix - If true, then the global namespace
+/// specifier "::" will be prepended to the fully qualified name.
 std::string getFullyQualifiedName(QualType QT,
-                                  const ASTContext &Ctx);
+                                  const ASTContext &Ctx,
+                                  bool WithGlobalNsPrefix = false);
 }  // end namespace TypeName
 }  // end namespace clang
 #endif  // LLVM_CLANG_TOOLING_CORE_QUALTYPENAMES_H

lib/AST/NestedNameSpecifier.cpp

NNS = new (Context, llvm::alignOf<NestedNameSpecifier>())
         NestedNameSpecifier(Mockup);
     Context.NestedNameSpecifiers.InsertNode(NNS, InsertPos);
   }
 
   return NNS;
 }
 
 NestedNameSpecifier *
+NestedNameSpecifier::PrependGlobalSpecifier(
+    const ASTContext &Context, const NestedNameSpecifier *Specifier) {
+  assert(Specifier && "Input nested name specifier cannot be NULL");
+
+  NestedNameSpecifier *P = const_cast<NestedNameSpecifier *>(Specifier);
+  while (P->getPrefix() != nullptr) {
+    P = P->getPrefix();
+  }
+
+  SpecifierKind Kind = P->getKind();
+  if (Kind == Global) {
+    return const_cast<NestedNameSpecifier *>(Specifier);
+  }
+
+  P->Prefix.setPointer(GlobalSpecifier(Context));
+  switch (Kind) {
+    case Namespace:
+    case NamespaceAlias:
+      P->Prefix.setInt(StoredDecl);
+      break;
+    case Identifier:
+      P->Prefix.setInt(StoredIdentifier);
+      break;
+    case TypeSpec:
+    case Super:
+      P->Prefix.setInt(StoredTypeSpec);
+      break;
+    case TypeSpecWithTemplate:
+      P->Prefix.setInt(StoredTypeSpecWithTemplate);
+      break;
+    default:
+      // Global is handled as a special case above.
+      assert(false && "Invalid NNS Kind!");
+   }
+
+  return FindOrInsert(Context, *Specifier);
+}
+
+NestedNameSpecifier *
 NestedNameSpecifier::Create(const ASTContext &Context,
                             NestedNameSpecifier *Prefix, IdentifierInfo *II) {
   assert(II && "Identifier cannot be NULL");
   assert((!Prefix || Prefix->isDependent()) && "Prefix must be dependent");
 
   NestedNameSpecifier Mockup;
   Mockup.Prefix.setPointer(Prefix);
   Mockup.Prefix.setInt(StoredIdentifier);

lib/Tooling/Core/QualTypeNames.cpp

 namespace TypeName {
 /// \brief Generates a QualType that can be used to name the same type
 /// if used at the end of the current translation unit. This ignores
 /// issues such as type shadowing.
 ///
 /// \param[in] QT - the type for which the fully qualified type will be
 /// returned.
 /// \param[in] Ctx - the ASTContext to be used.
-static QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx);
+static QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx,
+                                      bool WithGlobalNsPrefix);
 
 /// \brief Create a NestedNameSpecifier for Namesp and its enclosing
 /// scopes.
 ///
 /// \param[in] Ctx - the AST Context to be used.
 /// \param[in] Namesp - the NamespaceDecl for which a NestedNameSpecifier
 /// is requested.
 static NestedNameSpecifier *createNestedNameSpecifier(
if (NNS) {
     TName = Ctx.getQualifiedTemplateName(NNS,
                                          /*TemplateKeyword=*/false, ArgTDecl);
     Changed = true;
   }
   return Changed;
 }
 
 static bool getFullyQualifiedTemplateArgument(const ASTContext &Ctx,
-                                              TemplateArgument &Arg) {
+                                              TemplateArgument &Arg,
+                                              bool WithGlobalNsPrefix) {
   bool Changed = false;
 
   // Note: we do not handle TemplateArgument::Expression, to replace it
   // we need the information for the template instance decl.
 
   if (Arg.getKind() == TemplateArgument::Template) {
     TemplateName TName = Arg.getAsTemplate();
     Changed = getFullyQualifiedTemplateName(Ctx, TName);
     if (Changed) {
       Arg = TemplateArgument(TName);
     }
   } else if (Arg.getKind() == TemplateArgument::Type) {
     QualType SubTy = Arg.getAsType();
     // Check if the type needs more desugaring and recurse.
-    QualType QTFQ = getFullyQualifiedType(SubTy, Ctx);
+    QualType QTFQ = getFullyQualifiedType(SubTy, Ctx, WithGlobalNsPrefix);
     if (QTFQ != SubTy) {
       Arg = TemplateArgument(QTFQ);
       Changed = true;
     }
   }
   return Changed;
 }
 
 static const Type *getFullyQualifiedTemplateType(const ASTContext &Ctx,
-                                                 const Type *TypePtr) {
+                                                 const Type *TypePtr,
+                                                 bool WithGlobalNsPrefix) {
   // DependentTemplateTypes exist within template declarations and
   // definitions. Therefore we shouldn't encounter them at the end of
   // a translation unit. If we do, the caller has made an error.
   assert(!isa<DependentTemplateSpecializationType>(TypePtr));
   // In case of template specializations, iterate over the arguments
   // and fully qualify them as well.
   if (const auto *TST = dyn_cast<const TemplateSpecializationType>(TypePtr)) {
     bool MightHaveChanged = false;
     SmallVector<TemplateArgument, 4> FQArgs;
     for (TemplateSpecializationType::iterator I = TST->begin(), E = TST->end();
          I != E; ++I) {
       // Cheap to copy and potentially modified by
       // getFullyQualifedTemplateArgument.
       TemplateArgument Arg(*I);
-      MightHaveChanged |= getFullyQualifiedTemplateArgument(Ctx, Arg);
+      MightHaveChanged |= getFullyQualifiedTemplateArgument(
+          Ctx, Arg, WithGlobalNsPrefix);
       FQArgs.push_back(Arg);
     }
 
     // If a fully qualified arg is different from the unqualified arg,
     // allocate new type in the AST.
     if (MightHaveChanged) {
       QualType QT = Ctx.getTemplateSpecializationType(
           TST->getTemplateName(), FQArgs.data(), FQArgs.size(),
if (const auto *TSTDecl =
       const TemplateArgumentList &TemplateArgs = TSTDecl->getTemplateArgs();
 
       bool MightHaveChanged = false;
       SmallVector<TemplateArgument, 4> FQArgs;
       for (unsigned int I = 0, E = TemplateArgs.size(); I != E; ++I) {
         // cheap to copy and potentially modified by
         // getFullyQualifedTemplateArgument
         TemplateArgument Arg(TemplateArgs[I]);
-        MightHaveChanged |= getFullyQualifiedTemplateArgument(Ctx, Arg);
+        MightHaveChanged |= getFullyQualifiedTemplateArgument(
+            Ctx, Arg, WithGlobalNsPrefix);
         FQArgs.push_back(Arg);
       }
 
       // If a fully qualified arg is different from the unqualified arg,
       // allocate new type in the AST.
       if (MightHaveChanged) {
         TemplateName TN(TSTDecl->getSpecializedTemplate());
         QualType QT = Ctx.getTemplateSpecializationType(
NestedNameSpecifier *createNestedNameSpecifier(
     const ASTContext &Ctx, const TypeDecl *TD, bool FullyQualify) {
   return NestedNameSpecifier::Create(Ctx, createOuterNNS(Ctx, TD, FullyQualify),
                                      false /*No TemplateKeyword*/,
                                      TD->getTypeForDecl());
 }
 
 /// \brief Return the fully qualified type, including fully-qualified
 /// versions of any template parameters.
-QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx) {
+QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx,
+                               bool WithGlobalNsPrefix) {
   // In case of myType* we need to strip the pointer first, fully
   // qualify and attach the pointer once again.
   if (isa<PointerType>(QT.getTypePtr())) {
     // Get the qualifiers.
     Qualifiers Quals = QT.getQualifiers();
-    QT = getFullyQualifiedType(QT->getPointeeType(), Ctx);
+    QT = getFullyQualifiedType(QT->getPointeeType(), Ctx, WithGlobalNsPrefix);
     QT = Ctx.getPointerType(QT);
     // Add back the qualifiers.
     QT = Ctx.getQualifiedType(QT, Quals);
     return QT;
   }
 
   // In case of myType& we need to strip the reference first, fully
   // qualify and attach the reference once again.
   if (isa<ReferenceType>(QT.getTypePtr())) {
     // Get the qualifiers.
     bool IsLValueRefTy = isa<LValueReferenceType>(QT.getTypePtr());
     Qualifiers Quals = QT.getQualifiers();
-    QT = getFullyQualifiedType(QT->getPointeeType(), Ctx);
+    QT = getFullyQualifiedType(QT->getPointeeType(), Ctx, WithGlobalNsPrefix);
     // Add the r- or l-value reference type back to the fully
     // qualified one.
     if (IsLValueRefTy)
       QT = Ctx.getLValueReferenceType(QT);
     else
       QT = Ctx.getRValueReferenceType(QT);
     // Add back the qualifiers.
     QT = Ctx.getQualifiedType(QT, Quals);
QualType getFullyQualifiedType(QualType QT, const ASTContext &Ctx,
   ElaboratedTypeKeyword Keyword = ETK_None;
   if (const auto *ETypeInput = dyn_cast<ElaboratedType>(QT.getTypePtr())) {
     QT = ETypeInput->getNamedType();
     assert(!QT.hasLocalQualifiers());
     Keyword = ETypeInput->getKeyword();
   }
   // Create a nested name specifier if needed (i.e. if the decl context
   // is not the global scope.
   Prefix = createNestedNameSpecifierForScopeOf(Ctx, QT.getTypePtr(),
                                                true /*FullyQualified*/);
+  if (WithGlobalNsPrefix && !QT->isBuiltinType()) {
+    if (Prefix == nullptr) {
+      Prefix = NestedNameSpecifier::GlobalSpecifier(Ctx);
+    } else {
+      Prefix = NestedNameSpecifier::PrependGlobalSpecifier(Ctx, Prefix);
+    }
+  }
 
   // In case of template specializations iterate over the arguments and
   // fully qualify them as well.
   if (isa<const TemplateSpecializationType>(QT.getTypePtr()) ||
       isa<const RecordType>(QT.getTypePtr())) {
     // We are asked to fully qualify and we have a Record Type (which
     // may point to a template specialization) or Template
     // Specialization Type. We need to fully qualify their arguments.
 
-    const Type *TypePtr = getFullyQualifiedTemplateType(Ctx, QT.getTypePtr());
+    const Type *TypePtr = getFullyQualifiedTemplateType(
+        Ctx, QT.getTypePtr(), WithGlobalNsPrefix);
     QT = QualType(TypePtr, 0);
   }
   if (Prefix || Keyword != ETK_None) {
     QT = Ctx.getElaboratedType(Keyword, Prefix, QT);
   }
   QT = Ctx.getQualifiedType(QT, PrefixQualifiers);
   return QT;
 }
 
 std::string getFullyQualifiedName(QualType QT,
-                                  const ASTContext &Ctx) {
+                                  const ASTContext &Ctx,
+                                  bool WithGlobalNsPrefix) {
   PrintingPolicy Policy(Ctx.getPrintingPolicy());
   Policy.SuppressScope = false;
   Policy.AnonymousTagLocations = false;
   Policy.PolishForDeclaration = true;
   Policy.SuppressUnwrittenScope = true;
-  QualType FQQT = getFullyQualifiedType(QT, Ctx);
+  QualType FQQT = getFullyQualifiedType(QT, Ctx, WithGlobalNsPrefix);
   return FQQT.getAsString(Policy);
 }
 
 }  // end namespace TypeName
 }  // end namespace clang

unittests/Tooling/QualTypeNamesTest.cpp

 //===- unittest/Tooling/QualTypeNameTest.cpp ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/Core/QualTypeNames.h"
 #include "TestVisitor.h"
 using namespace clang;
 
 namespace {
 struct TypeNameVisitor : TestVisitor<TypeNameVisitor> {
   llvm::StringMap<std::string> ExpectedQualTypeNames;
+  bool WithGlobalNsPrefix = false;
 
   // ValueDecls are the least-derived decl with both a qualtype and a
   // name.
   bool traverseDecl(Decl *D) {
     return true;  // Always continue
   }
 
   bool VisitValueDecl(const ValueDecl *VD) {
     std::string ExpectedName =
         ExpectedQualTypeNames.lookup(VD->getNameAsString());
     if (ExpectedName != "") {
       std::string ActualName =
-          TypeName::getFullyQualifiedName(VD->getType(), *Context);
+          TypeName::getFullyQualifiedName(VD->getType(), *Context,
+                                          WithGlobalNsPrefix);
       if (ExpectedName != ActualName) {
         // A custom message makes it much easier to see what declaration
         // failed compared to EXPECT_EQ.
         EXPECT_TRUE(false) << "Typename::getFullyQualifiedName failed for "
                            << VD->getQualifiedNameAsString() << std::endl
                            << "   Actual: " << ActualName << std::endl
                            << " Exepcted: " << ExpectedName;
       }
Complex.runOver(
       "  template<class... Types > class tuple {};"
       "}"
       "namespace B {"
       "  using fake_std::tuple;"
       "  typedef tuple<X> TX;"
       "  TX CheckTX;"
       "  struct A { typedef int X; };"
       "}");
+
+  TypeNameVisitor GlobalNsPrefix;
+  GlobalNsPrefix.WithGlobalNsPrefix = true;
+  GlobalNsPrefix.ExpectedQualTypeNames["IntVal"] = "int";
+  GlobalNsPrefix.ExpectedQualTypeNames["BoolVal"] = "bool";
+  GlobalNsPrefix.ExpectedQualTypeNames["XVal"] = "::A::B::X";
+  GlobalNsPrefix.ExpectedQualTypeNames["IntAliasVal"] = "::A::B::Alias<int>";
+  GlobalNsPrefix.runOver(
+      "namespace A {"
+      "  namespace B {"
+      "    int IntVal;"
+      "    bool BoolVal;"
+      "    struct X {};"
+      "    X XVal;"
+      "    template <typename T> class CCC { };"
+      "    template <typename T>\n"
+      "    using Alias = CCC<T>;\n"
+      "    Alias<int> IntAliasVal;\n"
+      "  }"
+      "}"
+  );
 }
 
 }  // end anonymous namespace