[Tooling] Fix getting fully qualified names of template alias types.

[sivachandra]

Fix syntax in test.

[rnk]

lgtm

cfe/trunk/lib/Tooling/Core/QualTypeNames.cpp

static NestedNameSpecifier *createNestedNameSpecifierForScopeOf(
   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);
 }

cfe/trunk/unittests/Tooling/QualTypeNamesTest.cpp

TEST(QualTypeNameTest, getFullyQualifiedName) {
   Visitor.ExpectedQualTypeNames["CheckJ"] = "struct A::aStruct";
   // Anonymous Namespaces nested in named namespaces and vice-versa.
   Visitor.ExpectedQualTypeNames["CheckK"] = "D::aStruct";
   // Namespace alias
   Visitor.ExpectedQualTypeNames["CheckL"] = "A::B::C::MyInt";
   Visitor.ExpectedQualTypeNames["non_dependent_type_var"] =
       "Foo<X>::non_dependent_type";
   Visitor.ExpectedQualTypeNames["AnEnumVar"] = "EnumScopeClass::AnEnum";
+  Visitor.ExpectedQualTypeNames["AliasTypeVal"] = "A::B::C::InnerAlias<int>";
   Visitor.runOver(
       "int CheckInt;\n"
+      "template <typename T>\n"
+      "class OuterTemplateClass { };\n"
       "namespace A {\n"
       " namespace B {\n"
       "   class Class0 { };\n"
       "   namespace C {\n"
       "     typedef int MyInt;"
+      "     template <typename T>\n"
+      "     using InnerAlias = OuterTemplateClass<T>;\n"
+      "     InnerAlias<int> AliasTypeVal;\n"
       "   }\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"
Visitor.runOver(
       "void F() {\n"
       "  var.dependent_type_var = 0;\n"
       "var.non_dependent_type_var = 0;\n"
       "}\n"
       "class EnumScopeClass {\n"
       "public:\n"
       "  enum AnEnum { ZERO, ONE };\n"
       "};\n"
-      "EnumScopeClass::AnEnum AnEnumVar;\n"
+      "EnumScopeClass::AnEnum AnEnumVar;\n",
+      TypeNameVisitor::Lang_CXX11
 );
 
   TypeNameVisitor Complex;
   Complex.ExpectedQualTypeNames["CheckTX"] = "B::TX";
   Complex.runOver(
       "namespace A {"
       "  struct X {};"
       "}"