Support fully-qualified names for all QualTypes

[saugustine]

Summary

Calculate the fully qualified name of any QualType, including
recursively expanding template parameters, elaborated types and
other syntactice sugar.

This patch is adapted from code in the Cling project by Vassil
Vassilev<[e-mail]> and Philippe Canal
<[e-mail]>.

[nlewycky]

(I'm not doing a full review, I just happened to notice a couple things when skimming.)

lib/Tooling/Core/QualTypeNames.cpp

250

s/dyn_cast_or_null/dyn_cast/

You've already checked !TypePtr above, so it can't be null here.

306

s/qualifiy/qualify/

[rsmith]

include/clang/Tooling/Core/QualTypeNames.h

32

Please ensure there's a space between each /// and the content.

32–33

What do you mean by "fully qualified template arguments" here? Let me give you some examples:

namespace A {
  struct X {};
}
using A::X;
namespace B {
  using std::tuple;
  typedef typle<X> TX;
  TX t;
  struct A { typedef int X; };
}

What is the fully-qualified name of B::t's type? Is it B::TX or std::tuple<A::X> or std::tuple<::A::X>? Note that if you want to redeclare t from within namespace B, std::tuple<A::X> will name the wrong type.

Why does this only affect template arguments? Its name suggests it should affect the type as a whole (for instance, in the above case it should produce std::tuple<...>, not tuple<...>).

Generally, I think this interface needs to specify where the produced names can be used as a name for the specified type, otherwise I don't see how it can ever be reliable. For instance:

"Generates a name for a type that can be used to name the same type if used at the end of the current translation unit." (eg, B::TX or std::tuple<X>)

or:

"Generates a maximally-explicit name for a type that can be used in any context where all the relevant components have been declared. In such a context, this name will either name the intended type or produce an ambiguity error." (eg, ::std::tuple<::A::X>)

You should also specify what happens when it's not possible to generate such a name. For instance, given:

void f() {
  struct X {} x;
}

... there's no way to name the type of x from outside f (which makes certain refactoring operations impossible unless you also move the definition of struct X).

I think the ideal interface here would allow you to specify a location where you wish to insert the name, and would produce a "best possible" name for that type for that location, avoiding adding explicit qualification / desugaring wherever possible, but the interface should at least take the context-sensitivity of names into account.

37

Remove the clang::s; you're already in namespace clang.

49–79

Is it useful to expose the intermediary functionality to generate fully-qualified QualTypes and NestedNameSpecifiers rather than only exposing functionality to generate strings? What are the intended uses of these functions?

lib/Tooling/Core/QualTypeNames.cpp

341–343

This will not work in C, or if the type name is normally shadowed by a variable or function. You sometimes need to keep the keyword.

[saugustine]

• Update docs. Handle keywords and anonymous namespaces.

[saugustine]

Thanks for the reviews. Please take another look when you get a chance.

include/clang/Tooling/Core/QualTypeNames.h

32–33

My use case is to take a function signature, and communicate to a developer one way to declare the variables they need to call the function.

It does expand entire qualtypes, not just template parameters. (I've updated that description.)

Given the use case, "at the end of the translation unit" is the closest description of where these names would be valid, with the exception that this code avoids relying on any "using" declaration. "using foo::bar; void bat(bar b);", this code would describe foo's parameter as type foo::bar, rather than plain "bar", even though plain "bar" would work at the end of the translation unit.

I have updated the file header's comment to reflect all this, and added a couple of test cases to prove to myself that it does what I have documented. Along the way I have found a couple of places to explicitly mark where one would do things differently if one wanted to change this behavior.

The "ideal interface" idea is a good--and very cool--one, but my use case doesn't call for it.

49–79

I believe the Cling project (from which this code is adapted) uses all those functions internally. So I expect at least one client for those functions.

Let me know if you think hiding this interface is still the right thing.

lib/Tooling/Core/QualTypeNames.cpp

341–343

I've rewritten this code a bit, and this problem is solved near the end of this function. (This section itself is now mostly gone.)

[rsmith]

I think this functionality can be provided more simply by adding another flag to PrintingPolicy to request fully-qualified names always be produced. It already usually provides fully-qualified names; the only notable exception I can see is that if a qualifier was already provided, it uses that instead (in particular, there is a special case for printing ElaboratedTypes that uses the qualifier as written).

include/clang/Tooling/Core/QualTypeNames.h

56

refering -> referring

81

Missing /// on this line.

108

&, not & , please.

119–140

It would probably be better to have a single function to create a NestedNameSpecifier from a TypeDecl rather than splitting up these two cases.

134

TypedefDecl -> TypedefNameDecl

lib/Tooling/Core/QualTypeNames.cpp

32

NameSpecifier -> NestedNameSpecifier

52

ArgTDecl could be null here (for instance, if the TemplateName is a dependent template name).

88

What do you mean by 'Local' here?

90

I don't think this comment is accurate, just delete it?

99–100

Comment should start with a capital letter and end in a period.

106

This comment is inaccurate; you're not doing desugaring. (The name of DesArgs is also inappropriate; QualArgs or FQArgs or similar would better express the intent.)

108–111

Don't you need to form a fully-qualified template name here too?

151–154

This won't do the right thing if you reach an extern "C" or extern "C++" context. You can use getRedeclContext to skip those.

155

This will crash if you reached the TranslationUnitDecl or NS otherwise became null.

156

This is the wrong result if you reach an anonymous namespace nested within a named namespace.

167

Make this a function doc comment. And likewise for the similar cases below.

174–176

Why do you desugar namespace aliases here?

178–179

This indicates that the NestedNameSpecifier is dependent. Leaving this component alone seems like the right thing to do, but you should still fully-qualify the prefix.

187

Do not use dyn_cast on a Type*, it won't do what you want with type sugar. Use Type->getAs<TagType>() instead.

210–213

Call getRedeclContext here to skip extern "C" and the like.

214

If the outer context is an anonymous namespace, you should skip over it; it might be within another namespace.

215–235

I don't think this is the right way to handle this situation (it would be better to try to build the nested name specifier for the type, and fail if you can't build one that would name the right context). However, I don't see why you need to handle this at all -- it doesn't make sense to call this function with an instantiation-dependent QualType, as the notional "at the end of the translation unit" context has no template parameters in scope. You should probably detect and bail out on instantiation-dependent types earlier in the process.

241–246

The context might also be the translation unit here.

277

This is wrong in the same way as the similar code above.

301

This seems to miss out a lot of cases.

307

You don't need llvm:: on isa.

405

This call ignores a lot of the things you messed with above. It seems like only a couple of the modifications you make to the type actually affect how it's printed at all.

[saugustine]

• Update docs. Handle keywords and anonymous namespaces.
• Address code review issues. Cleanup many

[saugustine]

Richard,

Please take another look when you get a chance. Thanks.

[saugustine]

• Privatize all functions but getFullyQualifiedName.

[rsmith]

OK, let's go ahead with this approach for now; we can investigate replacing the implementation with a PrintingPolicy flag later.

lib/Tooling/Core/QualTypeNames.cpp

309–313

You don't need llvm:: on dyn_cast. It's more idiomatic to use const auto *TDT = dyn_cast<TypedefType>(TypePtr) rather than repeating the type on both sides of the =.

311–317

Maybe drop the braces around this to form an if/else if chain.

[saugustine]

• Cleanup dyn_cast usage inside QualTypeNames.

[saugustine]

I've updated the change.

Would you mind checking it in? I'll look into switching the implementations
shortly.

[rsmith]

In r260278.

include/clang/Tooling/Core/QualTypeNames.h

+//===--- QualTypeNames.h - Generate Complete QualType Names ----*- C++ -*-===//
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+// ===----------------------------------------------------------------------===//
+//
+// \file
+// Functionality to generate the fully-qualified names of QualTypes,
+// including recursively expanding any subtypes and template
+// parameters.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLING_CORE_QUALTYPENAMES_H
+#define LLVM_CLANG_TOOLING_CORE_QUALTYPENAMES_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang {
+class ASTContext;
+class NamespaceDecl;
+class NestedNameSpecifier;
+class QualType;
+class TagDecl;
+class Type;
+class TypedefNameDecl;
+
+namespace TypeName {
+///\brief Convert the type into one with fully qualified template
+/// arguments.
+///\param[in] QT - the type for which the fully qualified type will be
+/// returned.
+///\param[in] Ctx - the ASTContext to be used.
+clang::QualType getFullyQualifiedType(clang::QualType QT,
+                                      const clang::ASTContext &Ctx);
+
+///\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.
+std::string getFullyQualifiedName(clang::QualType QT,
+                                  const clang::ASTContext &Ctx);
+
+///\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.
+clang::NestedNameSpecifier *createNestedNameSpecifier(
+    const clang::ASTContext &Ctx, const clang::NamespaceDecl *Namesp);
+
+///\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.
+clang::NestedNameSpecifier *createNestedNameSpecifier(
+    const clang::ASTContext &Ctx, const clang::TagDecl *TD, bool FullyQualify);
+
+///\brief Create a NestedNameSpecifier for TypedefDecl and its enclosing
+/// scopes.
+///
+///\param[in] Ctx - the AST Context to be used.
+///\param[in] TD - the TypedefDecl for which a NestedNameSpecifier is
+/// requested.
+///\param[in] FullyQualify - Convert all template arguments (of possible
+/// parent scopes) into fully qualified names.
+clang::NestedNameSpecifier *createNestedNameSpecifier(
+    const clang::ASTContext &Ctx, const clang::TypedefNameDecl *TD,
+    bool FullyQualify);
+
+}  // end namespace TypeName
+}  // end namespace clang
+#endif  // LLVM_CLANG_TOOLING_CORE_QUALTYPENAMES_H

lib/Tooling/Core/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangToolingCore
   Lookup.cpp
   Replacement.cpp
+  QualTypeNames.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangLex
   clangRewrite
   )

lib/Tooling/Core/QualTypeNames.cpp

+//===------- QualTypeNames.cpp - Generate Complete QualType Names ---------===//
+//
+//                     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 "clang/AST/ASTContext.h"
+#include "clang/AST/DeclTemplate.h"
+#include "clang/AST/DeclarationName.h"
+#include "clang/AST/GlobalDecl.h"
+#include "clang/AST/Mangle.h"
+#include "clang/Sema/Lookup.h"
+#include "clang/Sema/Sema.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <stdio.h>
+#include <memory>
+
+namespace clang {
+
+static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
+    const ASTContext &Ctx, const Decl *decl, bool FullyQualified);
+
+static NestedNameSpecifier *getFullyQualifiedNameSpecifier(
+    const ASTContext &Ctx, NestedNameSpecifier *scope);
+
+static bool getFullyQualifiedTemplateName(const ASTContext &Ctx,
+                                          TemplateName &TName) {
+  bool Changed = false;
+  NestedNameSpecifier *NNS = nullptr;
+
+  TemplateDecl *ArgTDecl = TName.getAsTemplateDecl();
+  QualifiedTemplateName *QTName = TName.getAsQualifiedTemplateName();
+
+  if (QTName && !QTName->hasTemplateKeyword()) {
+    NNS = QTName->getQualifier();
+    NestedNameSpecifier *QNNS = getFullyQualifiedNameSpecifier(Ctx, NNS);
+    if (QNNS != NNS) {
+      Changed = true;
+      NNS = QNNS;
+    } else {
+      NNS = nullptr;
+    }
+  } else {
+    NNS = createNestedNameSpecifierForScopeOf(Ctx, ArgTDecl, true);
+  }
+  if (NNS) {
+    TName = Ctx.getQualifiedTemplateName(NNS,
+                                         /*TemplateKeyword=*/false, ArgTDecl);
+    Changed = true;
+  }
+  return Changed;
+}
+
+static bool getFullyQualifiedTemplateArgument(const ASTContext &Ctx,
+                                              TemplateArgument &Arg) {
+  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 = TypeName::getFullyQualifiedType(SubTy, Ctx);
+    if (QTFQ != SubTy) {
+      Arg = TemplateArgument(QTFQ);
+      Changed = true;
+    }
+  }
+  return Changed;
+}
+
+static const Type *getFullyQualifiedLocalType(const ASTContext &Ctx,
+                                              const Type *TypePtr) {
+  // We really just want to handle the template parameter if any ....
+  // In case of template specializations iterate over the arguments and
+  // fully qualify them as well.
+  if (const TemplateSpecializationType *TST =
+          llvm::dyn_cast<const TemplateSpecializationType>(TypePtr)) {
+    bool MightHaveChanged = false;
+    llvm::SmallVector<TemplateArgument, 4> DesArgs;
+    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);
+      DesArgs.push_back(Arg);
+    }
+
+    // If desugaring happened allocate new type in the AST.
+    if (MightHaveChanged) {
+      QualType QT = Ctx.getTemplateSpecializationType(
+          TST->getTemplateName(), DesArgs.data(), DesArgs.size(),
+          TST->getCanonicalTypeInternal());
+      return QT.getTypePtr();
+    }
+  } else if (const RecordType *TSTRecord =
+                 llvm::dyn_cast<const RecordType>(TypePtr)) {
+    // We are asked to fully qualify and we have a Record Type,
+    // which can point to a template instantiation with no sugar in any of
+    // its template argument, however we still need to fully qualify them.
+
+    if (const ClassTemplateSpecializationDecl *TSTDecl =
+            llvm::dyn_cast<ClassTemplateSpecializationDecl>(
+                TSTRecord->getDecl())) {
+      const TemplateArgumentList &TemplateArgs = TSTDecl->getTemplateArgs();
+
+      bool MightHaveChanged = false;
+      llvm::SmallVector<TemplateArgument, 4> DesArgs;
+      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);
+        DesArgs.push_back(Arg);
+      }
+
+      // If desugaring happened allocate new type in the AST.
+      if (MightHaveChanged) {
+        TemplateName TN(TSTDecl->getSpecializedTemplate());
+        QualType QT = Ctx.getTemplateSpecializationType(
+            TN, DesArgs.data(), DesArgs.size(),
+            TSTRecord->getCanonicalTypeInternal());
+        return QT.getTypePtr();
+      }
+    }
+  }
+  return TypePtr;
+}
+
+static NestedNameSpecifier *createOuterNNS(const ASTContext &Ctx, const Decl *D,
+                                           bool FullyQualify) {
+  const DeclContext *DC = D->getDeclContext();
+  if (const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DC)) {
+    while (NS && NS->isInline()) {
+      // Ignore inline namespace;
+      NS = dyn_cast_or_null<NamespaceDecl>(NS->getDeclContext());
+    }
+    if (NS->getDeclName()) return TypeName::createNestedNameSpecifier(Ctx, NS);
+    return nullptr;  // no starting '::', no anonymous
+  } else if (const TagDecl *TD = dyn_cast<TagDecl>(DC)) {
+    return TypeName::createNestedNameSpecifier(Ctx, TD, FullyQualify);
+  } else if (const TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(DC)) {
+    return TypeName::createNestedNameSpecifier(Ctx, TDD, FullyQualify);
+  }
+  return nullptr;  // no starting '::'
+}
+
+static NestedNameSpecifier *getFullyQualifiedNameSpecifier(
+    const ASTContext &Ctx, NestedNameSpecifier *Scope) {
+  // Return a fully qualified version of this name specifier
+  if (Scope->getKind() == NestedNameSpecifier::Global) {
+    // Already fully qualified.
+    return Scope;
+  }
+
+  if (const Type *Type = Scope->getAsType()) {
+    // Find decl context.
+    const TagDecl *TD = nullptr;
+    if (const TagType *TagDeclType = dyn_cast<TagType>(Type)) {
+      TD = TagDeclType->getDecl();
+    } else {
+      TD = Type->getAsCXXRecordDecl();
+    }
+    if (TD) {
+      return TypeName::createNestedNameSpecifier(Ctx, TD,
+                                                 true /*FullyQualified*/);
+    } else if (const TypedefType *TDD = dyn_cast<TypedefType>(Type)) {
+      return TypeName::createNestedNameSpecifier(Ctx, TDD->getDecl(),
+                                                 true /*FullyQualified*/);
+    }
+  } else if (const NamespaceDecl *NS = Scope->getAsNamespace()) {
+    return TypeName::createNestedNameSpecifier(Ctx, NS);
+  } else if (const NamespaceAliasDecl *Alias = Scope->getAsNamespaceAlias()) {
+    const NamespaceDecl *NS = Alias->getNamespace()->getCanonicalDecl();
+    return TypeName::createNestedNameSpecifier(Ctx, NS);
+  }
+
+  return Scope;
+}
+
+static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
+    const ASTContext &Ctx, const Decl *Decl, bool FullyQualified) {
+  // Create a nested name specifier for the declaring context of the type.
+
+  assert(Decl);
+
+  const NamedDecl *Outer =
+      llvm::dyn_cast_or_null<NamedDecl>(Decl->getDeclContext());
+  const NamespaceDecl *OuterNS =
+      llvm::dyn_cast_or_null<NamespaceDecl>(Decl->getDeclContext());
+  if (Outer && !(OuterNS && OuterNS->isAnonymousNamespace())) {
+    if (const CXXRecordDecl *CxxDecl =
+            llvm::dyn_cast<CXXRecordDecl>(Decl->getDeclContext())) {
+      if (ClassTemplateDecl *ClassTempl =
+              CxxDecl->getDescribedClassTemplate()) {
+        // We are in the case of a type(def) that was declared in a
+        // class template but is *not* type dependent.  In clang, it
+        // gets attached to the class template declaration rather than
+        // any specific class template instantiation.  This result in
+        // 'odd' fully qualified typename:
+        //
+        //    vector<_Tp,_Alloc>::size_type
+        //
+        // Make the situation is 'useable' but looking a bit odd by
+        // picking a random instance as the declaring context.
+        if (ClassTempl->spec_begin() != ClassTempl->spec_end()) {
+          Decl = *(ClassTempl->spec_begin());
+          Outer = llvm::dyn_cast<NamedDecl>(Decl);
+          OuterNS = llvm::dyn_cast<NamespaceDecl>(Decl);
+        }
+      }
+    }
+
+    if (OuterNS) {
+      return TypeName::createNestedNameSpecifier(Ctx, OuterNS);
+    } else if (const TagDecl *TD = llvm::dyn_cast<TagDecl>(Outer)) {
+      return TypeName::createNestedNameSpecifier(Ctx, TD, FullyQualified);
+    }
+  }
+  return nullptr;
+}
+
+static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
+    const ASTContext &Ctx, const Type *TypePtr, bool FullyQualified) {
+  // Create a nested name specifier for the declaring context of the type.
+
+  if (!TypePtr) return nullptr;
+
+  Decl *Decl = nullptr;
+  if (const TypedefType *TDT = llvm::dyn_cast<TypedefType>(TypePtr)) {
+    Decl = TDT->getDecl();
+  } else {
+    // There are probably other cases ...
+    if (const TagType *TagDeclType = llvm::dyn_cast_or_null<TagType>(TypePtr))
+      Decl = TagDeclType->getDecl();
+    else
+      Decl = TypePtr->getAsCXXRecordDecl();
+  }
+
+  if (!Decl) return nullptr;
+
+  return createNestedNameSpecifierForScopeOf(Ctx, Decl, FullyQualified);
+}
+
+NestedNameSpecifier *TypeName::createNestedNameSpecifier(
+    const ASTContext &Ctx, const NamespaceDecl *Namespace) {
+  while (Namespace && Namespace->isInline()) {
+    // Ignore inline namespace;
+    Namespace = dyn_cast_or_null<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);
+}
+
+NestedNameSpecifier *TypeName::createNestedNameSpecifier(
+    const ASTContext &Ctx, const TypedefNameDecl *TD, bool FullyQualify) {
+  return NestedNameSpecifier::Create(Ctx, createOuterNNS(Ctx, TD, FullyQualify),
+                                     true /*Template*/, TD->getTypeForDecl());
+}
+
+NestedNameSpecifier *TypeName::createNestedNameSpecifier(const ASTContext &Ctx,
+                                                         const TagDecl *TD,
+                                                         bool FullyQualify) {
+  const Type *Ty = Ctx.getTypeDeclType(TD).getTypePtr();
+  if (FullyQualify) Ty = getFullyQualifiedLocalType(Ctx, Ty);
+  return NestedNameSpecifier::Create(Ctx, createOuterNNS(Ctx, TD, FullyQualify),
+                                     false /* template keyword wanted */, Ty);
+}
+
+QualType TypeName::getFullyQualifiedType(QualType QT, const ASTContext &Ctx) {
+  // Return the fully qualified type, including for any template
+  // parameters.
+
+  // In case of myType* we need to strip the pointer first, fully
+  // qualify and attach the pointer once again.
+  if (llvm::isa<PointerType>(QT.getTypePtr())) {
+    // Get the qualifiers.
+    Qualifiers Quals = QT.getQualifiers();
+    QT = getFullyQualifiedType(QT->getPointeeType(), Ctx);
+    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
+  // qualifiy and attach the reference once again.
+  if (llvm::isa<ReferenceType>(QT.getTypePtr())) {
+    // Get the qualifiers.
+    bool IsLValueRefTy = llvm::isa<LValueReferenceType>(QT.getTypePtr());
+    Qualifiers Quals = QT.getQualifiers();
+    QT = getFullyQualifiedType(QT->getPointeeType(), Ctx);
+    // 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);
+    return QT;
+  }
+
+  // Remove the part of the type related to the type being a template
+  // parameter (we won't report it as part of the 'type name' and it
+  // is actually make the code below to be more complex (to handle
+  // those)
+  while (isa<SubstTemplateTypeParmType>(QT.getTypePtr())) {
+    // Get the qualifiers.
+    Qualifiers Quals = QT.getQualifiers();
+
+    QT = dyn_cast<SubstTemplateTypeParmType>(QT.getTypePtr())->desugar();
+
+    // Add back the qualifiers.
+    QT = Ctx.getQualifiedType(QT, Quals);
+  }
+
+  NestedNameSpecifier *Prefix = nullptr;
+  Qualifiers PrefixQualifiers;
+  if (const ElaboratedType *ETypeInput =
+          llvm::dyn_cast<ElaboratedType>(QT.getTypePtr())) {
+    // Intentionally, we do not care about the other compononent of
+    // the elaborated type (the keyword) as part of the name
+    // normalization is to remove it.
+    Prefix = ETypeInput->getQualifier();
+    if (Prefix) {
+      const NamespaceDecl *NS = Prefix->getAsNamespace();
+      if (Prefix != NestedNameSpecifier::GlobalSpecifier(Ctx) &&
+          !(NS && NS->isAnonymousNamespace())) {
+        PrefixQualifiers = QT.getLocalQualifiers();
+        Prefix = getFullyQualifiedNameSpecifier(Ctx, Prefix);
+        QT = QualType(ETypeInput->getNamedType().getTypePtr(), 0);
+      } else {
+        Prefix = nullptr;
+      }
+    }
+  } else {
+    // 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*/);
+
+    // move the qualifiers on the outer type (avoid 'std::const string'!)
+    if (Prefix) {
+      PrefixQualifiers = QT.getLocalQualifiers();
+      QT = QualType(QT.getTypePtr(), 0);
+    }
+  }
+
+  // In case of template specializations iterate over the arguments and
+  // fully qualify them as well.
+  if (llvm::isa<const TemplateSpecializationType>(QT.getTypePtr())) {
+    Qualifiers Quals = QT.getLocalQualifiers();
+    const Type *TypePtr = getFullyQualifiedLocalType(Ctx, QT.getTypePtr());
+    QT = Ctx.getQualifiedType(TypePtr, Quals);
+
+  } else if (llvm::isa<const RecordType>(QT.getTypePtr())) {
+    // We are asked to fully qualify and we have a Record Type,
+    // which can point to a template instantiation with no sugar in any of
+    // its template argument, however we still need to fully qualify them.
+
+    Qualifiers Quals = QT.getLocalQualifiers();
+    const Type *TypePtr = getFullyQualifiedLocalType(Ctx, QT.getTypePtr());
+    QT = Ctx.getQualifiedType(TypePtr, Quals);
+  }
+  if (Prefix) {
+    // We intentionally always use ETK_None, we never want
+    // the keyword (humm ... what about anonymous types?)
+    QT = Ctx.getElaboratedType(ETK_None, Prefix, QT);
+    QT = Ctx.getQualifiedType(QT, PrefixQualifiers);
+  }
+  return QT;
+}
+
+std::string TypeName::getFullyQualifiedName(QualType QT,
+                                            const ASTContext &Ctx) {
+  QualType FQQT = getFullyQualifiedType(QT, Ctx);
+  PrintingPolicy Policy(Ctx.getPrintingPolicy());
+  Policy.SuppressScope = false;
+  Policy.AnonymousTagLocations = false;
+  return FQQT.getAsString(Policy);
+}
+
+}  // end namespace clang

unittests/Tooling/CMakeLists.txt

add_clang_unittest(ToolingTests
   RecursiveASTVisitorTestCallVisitor.cpp
   RecursiveASTVisitorTestDeclVisitor.cpp
   RecursiveASTVisitorTestExprVisitor.cpp
   RecursiveASTVisitorTestTypeLocVisitor.cpp
   RefactoringTest.cpp
   RewriterTest.cpp
   RefactoringCallbacksTest.cpp
   ReplacementsYamlTest.cpp
+  QualTypeNamesTest.cpp
   )
 
 target_link_libraries(ToolingTests
   clangAST
   clangASTMatchers
   clangBasic
   clangFrontend
   clangLex
   clangRewrite
   clangTooling
   clangToolingCore
   )

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;
+
+  // 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());
+    std::string ActualName =
+        TypeName::getFullyQualifiedName(VD->getType(), *Context);
+    if (ExpectedName != "" && 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;
+    }
+    return true;
+  }
+};
+
+TEST(QualTypeNameTest, getFullyQualifiedName) {
+  TypeNameVisitor Visitor;
+  // Simple case to test the test framework itself.
+  Visitor.ExpectedQualTypeNames["CheckInt"] = "int";
+  Visitor.runOver("");
+
+  // Keeping the names of the variables whose types we check unique
+  // within the entire test--regardless of their own scope--makes it
+  // easier to diagnose test failures.
+
+  // Simple namespace qualifier
+  Visitor.ExpectedQualTypeNames["CheckA"] = "A::B::Class0";
+  // Lookup up the enclosing scopes, then down another one. (These
+  // appear as elaborated type in the AST. In that case--even if
+  // policy.SuppressScope = 0--qual_type.getAsString(policy) only
+  // gives the name as it appears in the source, not the full name.
+  Visitor.ExpectedQualTypeNames["CheckB"] = "A::B::C::Class1";
+  // Template parameter expansion.
+  Visitor.ExpectedQualTypeNames["CheckC"] =
+      "A::B::Template0<A::B::C::MyInt, A::B::AnotherClass>";
+  // Recursive template parameter expansion.
+  Visitor.ExpectedQualTypeNames["CheckD"] =
+      "A::B::Template0<A::B::Template1<A::B::C::MyInt, A::B::AnotherClass>, "
+      "A::B::Template0<int, long> >";
+  // Variadic Template expansion.
+  Visitor.ExpectedQualTypeNames["CheckE"] =
+      "A::Variadic<int, A::B::Template0<int, char>, "
+      "A::B::Template1<int, long>, A::B::C::MyInt>";
+  Visitor.runOver(
+      "int CheckInt;\n"
+      "namespace A {\n"
+      " namespace B {\n"
+      "   class Class0 { };\n"
+      "   namespace C {\n"
+      "     typedef int MyInt;"
+      "   }\n"
+      "   template<class X, class Y> class Template0;"
+      "   template<class X, class Y> class Template1;"
+      "   typedef B::Class0 AnotherClass;\n"
+      "   void Function1(Template0<C::MyInt,\n"
+      "                  AnotherClass> CheckC);\n"
+      "   void Function2(Template0<Template1<C::MyInt, AnotherClass>,\n"
+      "                            Template0<int, long> > CheckD);\n"
+      "  }\n"
+      "template<typename... Values> class Variadic {};\n"
+      "Variadic<int, B::Template0<int, char>, "
+      "         B::Template1<int, long>, "
+      "         B::C::MyInt > CheckE;\n"
+      "}\n");
+}
+
+}  // end anonymous namespace