[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 ↗

(On Diff #61737)

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

lib/Tooling/Core/QualTypeNames.cpp

443

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

443

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

443

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/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/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);
+/// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace
+/// specifier "::" should be prepended or not.
+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.
+/// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace
+/// specifier "::" should be prepended or not.
 static NestedNameSpecifier *createNestedNameSpecifier(
-    const ASTContext &Ctx, const NamespaceDecl *Namesp);
+    const ASTContext &Ctx,
+    const NamespaceDecl *Namesp,
+    bool WithGlobalNsPrefix);
 
 /// \brief Create a NestedNameSpecifier for TagDecl and its enclosing
 /// scopes.
 ///
 /// \param[in] Ctx - the AST Context to be used.
 /// \param[in] TD - the TagDecl for which a NestedNameSpecifier is
 /// requested.
 /// \param[in] FullyQualify - Convert all template arguments into fully
 /// qualified names.
+/// \param[in] WithGlobalNsPrefix - Indicate whether the global namespace
+/// specifier "::" should be prepended or not.
 static NestedNameSpecifier *createNestedNameSpecifier(
-    const ASTContext &Ctx, const TypeDecl *TD, bool FullyQualify);
+    const ASTContext &Ctx, const TypeDecl *TD,
+    bool FullyQualify, bool WithGlobalNsPrefix);
 
 static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
-    const ASTContext &Ctx, const Decl *decl, bool FullyQualified);
+    const ASTContext &Ctx, const Decl *decl,
+    bool FullyQualified, bool WithGlobalNsPrefix);
 
 static NestedNameSpecifier *getFullyQualifiedNestedNameSpecifier(
-    const ASTContext &Ctx, NestedNameSpecifier *scope);
+    const ASTContext &Ctx, NestedNameSpecifier *scope, bool WithGlobalNsPrefix);
 
 static bool getFullyQualifiedTemplateName(const ASTContext &Ctx,
-                                          TemplateName &TName) {
+                                          TemplateName &TName,
+                                          bool WithGlobalNsPrefix) {
   bool Changed = false;
   NestedNameSpecifier *NNS = nullptr;
 
   TemplateDecl *ArgTDecl = TName.getAsTemplateDecl();
   // ArgTDecl won't be NULL because we asserted that this isn't a
   // dependent context very early in the call chain.
   assert(ArgTDecl != nullptr);
   QualifiedTemplateName *QTName = TName.getAsQualifiedTemplateName();
 
   if (QTName && !QTName->hasTemplateKeyword()) {
     NNS = QTName->getQualifier();
-    NestedNameSpecifier *QNNS = getFullyQualifiedNestedNameSpecifier(Ctx, NNS);
+    NestedNameSpecifier *QNNS = getFullyQualifiedNestedNameSpecifier(
+        Ctx, NNS, WithGlobalNsPrefix);
     if (QNNS != NNS) {
       Changed = true;
       NNS = QNNS;
     } else {
       NNS = nullptr;
     }
   } else {
-    NNS = createNestedNameSpecifierForScopeOf(Ctx, ArgTDecl, true);
+    NNS = createNestedNameSpecifierForScopeOf(
+        Ctx, ArgTDecl, true, WithGlobalNsPrefix);
   }
   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);
+    Changed = getFullyQualifiedTemplateName(Ctx, TName, WithGlobalNsPrefix);
     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(
             TN, FQArgs.data(), FQArgs.size(),
             TSTRecord->getCanonicalTypeInternal());
         // getTemplateSpecializationType returns a fully qualified
         // version of the specialization itself, so no need to qualify
         // it.
         return QT.getTypePtr();
       }
     }
   }
   return TypePtr;
 }
 
 static NestedNameSpecifier *createOuterNNS(const ASTContext &Ctx, const Decl *D,
-                                           bool FullyQualify) {
+                                           bool FullyQualify,
+                                           bool WithGlobalNsPrefix) {
   const DeclContext *DC = D->getDeclContext();
   if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
     while (NS && NS->isInline()) {
       // Ignore inline namespace;
       NS = dyn_cast<NamespaceDecl>(NS->getDeclContext());
     }
-    if (NS->getDeclName()) return createNestedNameSpecifier(Ctx, NS);
+    if (NS->getDeclName()) {
+      return createNestedNameSpecifier(Ctx, NS, WithGlobalNsPrefix);
+    }
     return nullptr;  // no starting '::', no anonymous
   } else if (const auto *TD = dyn_cast<TagDecl>(DC)) {
-    return createNestedNameSpecifier(Ctx, TD, FullyQualify);
+    return createNestedNameSpecifier(Ctx, TD, FullyQualify, WithGlobalNsPrefix);
   } else if (const auto *TDD = dyn_cast<TypedefNameDecl>(DC)) {
-    return createNestedNameSpecifier(Ctx, TDD, FullyQualify);
+    return createNestedNameSpecifier(
+        Ctx, TDD, FullyQualify, WithGlobalNsPrefix);
+  } else if (WithGlobalNsPrefix && DC->isTranslationUnit()) {
+    return NestedNameSpecifier::GlobalSpecifier(Ctx);
   }
-  return nullptr;  // no starting '::'
+  return nullptr;  // no starting '::' if |WithGlobalNsPrefix| is false
 }
 
 /// \brief Return a fully qualified version of this name specifier.
 static NestedNameSpecifier *getFullyQualifiedNestedNameSpecifier(
-    const ASTContext &Ctx, NestedNameSpecifier *Scope) {
+    const ASTContext &Ctx, NestedNameSpecifier *Scope,
+    bool WithGlobalNsPrefix) {
   switch (Scope->getKind()) {
     case NestedNameSpecifier::Global:
       // Already fully qualified
       return Scope;
     case NestedNameSpecifier::Namespace:
-      return TypeName::createNestedNameSpecifier(Ctx, Scope->getAsNamespace());
+      return TypeName::createNestedNameSpecifier(
+          Ctx, Scope->getAsNamespace(), WithGlobalNsPrefix);
     case NestedNameSpecifier::NamespaceAlias:
       // Namespace aliases are only valid for the duration of the
       // scope where they were introduced, and therefore are often
       // invalid at the end of the TU.  So use the namespace name more
       // likely to be valid at the end of the TU.
       return TypeName::createNestedNameSpecifier(
-          Ctx, Scope->getAsNamespaceAlias()->getNamespace()->getCanonicalDecl());
+          Ctx,
+          Scope->getAsNamespaceAlias()->getNamespace()->getCanonicalDecl(),
+          WithGlobalNsPrefix);
     case NestedNameSpecifier::Identifier:
       // A function or some other construct that makes it un-namable
       // at the end of the TU. Skip the current component of the name,
       // but use the name of it's prefix.
-      return getFullyQualifiedNestedNameSpecifier(Ctx, Scope->getPrefix());
+      return getFullyQualifiedNestedNameSpecifier(
+          Ctx, Scope->getPrefix(), WithGlobalNsPrefix);
     case NestedNameSpecifier::Super:
     case NestedNameSpecifier::TypeSpec:
     case NestedNameSpecifier::TypeSpecWithTemplate: {
       const Type *Type = Scope->getAsType();
       // Find decl context.
       const TagDecl *TD = nullptr;
       if (const TagType *TagDeclType = Type->getAs<TagType>()) {
         TD = TagDeclType->getDecl();
       } else {
         TD = Type->getAsCXXRecordDecl();
       }
       if (TD) {
         return TypeName::createNestedNameSpecifier(Ctx, TD,
-                                                   true /*FullyQualified*/);
+                                                   true /*FullyQualified*/,
+                                                   WithGlobalNsPrefix);
       } else if (const auto *TDD = dyn_cast<TypedefType>(Type)) {
         return TypeName::createNestedNameSpecifier(Ctx, TDD->getDecl(),
-                                                   true /*FullyQualified*/);
+                                                   true /*FullyQualified*/,
+                                                   WithGlobalNsPrefix);
       }
       return Scope;
     }
   }
   llvm_unreachable("bad NNS kind");
 }
 
 /// \brief Create a nested name specifier for the declaring context of
 /// the type.
 static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
-    const ASTContext &Ctx, const Decl *Decl, bool FullyQualified) {
+    const ASTContext &Ctx, const Decl *Decl,
+    bool FullyQualified, bool WithGlobalNsPrefix) {
   assert(Decl);
 
   const DeclContext *DC = Decl->getDeclContext()->getRedeclContext();
   const auto *Outer = dyn_cast_or_null<NamedDecl>(DC);
   const auto *OuterNS = dyn_cast_or_null<NamespaceDecl>(DC);
   if (Outer && !(OuterNS && OuterNS->isAnonymousNamespace())) {
     if (const auto *CxxDecl = dyn_cast<CXXRecordDecl>(DC)) {
       if (ClassTemplateDecl *ClassTempl =
if (const auto *CxxDecl = dyn_cast<CXXRecordDecl>(DC)) {
           Decl = *(ClassTempl->spec_begin());
           Outer = dyn_cast<NamedDecl>(Decl);
           OuterNS = dyn_cast<NamespaceDecl>(Decl);
         }
       }
     }
 
     if (OuterNS) {
-      return createNestedNameSpecifier(Ctx, OuterNS);
+      return createNestedNameSpecifier(Ctx, OuterNS, WithGlobalNsPrefix);
     } else if (const auto *TD = dyn_cast<TagDecl>(Outer)) {
-      return createNestedNameSpecifier(Ctx, TD, FullyQualified);
+      return createNestedNameSpecifier(
+          Ctx, TD, FullyQualified, WithGlobalNsPrefix);
     } else if (dyn_cast<TranslationUnitDecl>(Outer)) {
       // Context is the TU. Nothing needs to be done.
       return nullptr;
     } else {
       // Decl's context was neither the TU, a namespace, nor a
       // TagDecl, which means it is a type local to a scope, and not
       // accessible at the end of the TU.
       return nullptr;
     }
+  } else if (WithGlobalNsPrefix && DC->isTranslationUnit()) {
+    return NestedNameSpecifier::GlobalSpecifier(Ctx);
   }
   return nullptr;
 }
 
 /// \brief Create a nested name specifier for the declaring context of
 /// the type.
 static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
-    const ASTContext &Ctx, const Type *TypePtr, bool FullyQualified) {
+    const ASTContext &Ctx, const Type *TypePtr,
+    bool FullyQualified, bool WithGlobalNsPrefix) {
   if (!TypePtr) return nullptr;
 
   Decl *Decl = nullptr;
   // There are probably other cases ...
   if (const auto *TDT = dyn_cast<TypedefType>(TypePtr)) {
     Decl = TDT->getDecl();
   } else if (const auto *TagDeclType = dyn_cast<TagType>(TypePtr)) {
     Decl = TagDeclType->getDecl();
   } else if (const auto *TST = dyn_cast<TemplateSpecializationType>(TypePtr)) {
     Decl = TST->getTemplateName().getAsTemplateDecl();
   } else {
     Decl = TypePtr->getAsCXXRecordDecl();
   }
 
   if (!Decl) return nullptr;
 
-  return createNestedNameSpecifierForScopeOf(Ctx, Decl, FullyQualified);
+  return createNestedNameSpecifierForScopeOf(
+      Ctx, Decl, FullyQualified, WithGlobalNsPrefix);
 }
 
-NestedNameSpecifier *createNestedNameSpecifier(
-    const ASTContext &Ctx, const NamespaceDecl *Namespace) {
+NestedNameSpecifier *createNestedNameSpecifier(const ASTContext &Ctx,
+                                               const NamespaceDecl *Namespace,
+                                               bool WithGlobalNsPrefix) {
   while (Namespace && Namespace->isInline()) {
     // Ignore inline namespace;
     Namespace = dyn_cast<NamespaceDecl>(Namespace->getDeclContext());
   }
   if (!Namespace) return nullptr;
 
   bool FullyQualified = true;  // doesn't matter, DeclContexts are namespaces
   return NestedNameSpecifier::Create(
-      Ctx, createOuterNNS(Ctx, Namespace, FullyQualified), Namespace);
+      Ctx,
+      createOuterNNS(Ctx, Namespace, FullyQualified, WithGlobalNsPrefix),
+      Namespace);
 }
 
-NestedNameSpecifier *createNestedNameSpecifier(
-    const ASTContext &Ctx, const TypeDecl *TD, bool FullyQualify) {
-  return NestedNameSpecifier::Create(Ctx, createOuterNNS(Ctx, TD, FullyQualify),
-                                     false /*No TemplateKeyword*/,
-                                     TD->getTypeForDecl());
+NestedNameSpecifier *createNestedNameSpecifier(const ASTContext &Ctx,
+                                               const TypeDecl *TD,
+                                               bool FullyQualify,
+                                               bool WithGlobalNsPrefix) {
+  return NestedNameSpecifier::Create(
+      Ctx,
+      createOuterNNS(Ctx, TD, FullyQualify, WithGlobalNsPrefix),
 }
 
 /// \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,
   Qualifiers PrefixQualifiers = QT.getLocalQualifiers();
   QT = QualType(QT.getTypePtr(), 0);
   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.
+  // Create a nested name specifier if needed.
   Prefix = createNestedNameSpecifierForScopeOf(Ctx, QT.getTypePtr(),
-                                               true /*FullyQualified*/);
+                                               true /*FullyQualified*/,
+                                               WithGlobalNsPrefix);
 
   // 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.ExpectedQualTypeNames["ZVal"] = "::A::B::Y::Z";
+  GlobalNsPrefix.ExpectedQualTypeNames["GlobalZVal"] = "::Z";
+  GlobalNsPrefix.ExpectedQualTypeNames["CheckK"] = "D::aStruct";
+  GlobalNsPrefix.runOver(
+      "namespace A {\n"
+      "  namespace B {\n"
+      "    int IntVal;\n"
+      "    bool BoolVal;\n"
+      "    struct X {};\n"
+      "    X XVal;\n"
+      "    template <typename T> class CCC { };\n"
+      "    template <typename T>\n"
+      "    using Alias = CCC<T>;\n"
+      "    Alias<int> IntAliasVal;\n"
+      "    struct Y { struct Z {}; };\n"
+      "    Y::Z ZVal;\n"
+      "  }\n"
+      "}\n"
+      "struct Z {};\n"
+      "Z GlobalZVal;\n"
+      "namespace {\n"
+      "  namespace D {\n"
+      "    namespace {\n"
+      "      class aStruct {};\n"
+      "      aStruct CheckK;\n"
+      "    }\n"
+      "  }\n"
+      "}\n"
+  );
 }
 
 }  // end anonymous namespace