Stop using "template" when printing qualtype names

[saugustine]

Summary

The keyword "template" isn't necessary when
printing a fully-qualified qualtype name, and, in fact,
results in a syntax error if one tries to use it. So stop
printing it.

[rnk]

lgtm

This code seems like it's intended to avoid operating on dependent types, so it shouldn't need the template keyword. It's hard to have a fully qualified name that's valid at global scope and still somehow mentions template parameters.

unittests/Tooling/QualTypeNamesTest.cpp

138

What's supposed to be printed for dependent_type_var?

[saugustine]

Thanks for the quick review. Assuming my response to your comment on line 138 is adequate, would you mind checking it in?

unittests/Tooling/QualTypeNamesTest.cpp

138

I'm not clever enough to generate one that compiles when it is at the end of the TU.

When not at the end of the TU, this prints: FOO<X>::dependent_type, omitting the keyword.

I don't think this is worth adding as a test-case.

[saugustine]

Would you mind reviewing this, and checking it in if you find it acceptable?

lib/Tooling/Core/QualTypeNames.cpp

NestedNameSpecifier *createNestedNameSpecifier(
   bool FullyQualified = true;  // doesn't matter, DeclContexts are namespaces
   return NestedNameSpecifier::Create(
       Ctx, createOuterNNS(Ctx, Namespace, FullyQualified), Namespace);
 }
 
 NestedNameSpecifier *createNestedNameSpecifier(
     const ASTContext &Ctx, const TypeDecl *TD, bool FullyQualify) {
   return NestedNameSpecifier::Create(Ctx, createOuterNNS(Ctx, TD, FullyQualify),
-                                     true /*Template*/, TD->getTypeForDecl());
+                                     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) {
   // In case of myType* we need to strip the pointer first, fully
   // qualify and attach the pointer once again.
   if (isa<PointerType>(QT.getTypePtr())) {

unittests/Tooling/QualTypeNamesTest.cpp

TEST(QualTypeNameTest, getFullyQualifiedName) {
   Visitor.ExpectedQualTypeNames["CheckI"] = "aClass";
   // Keyword inclusion with namespaces
   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"] =
-      "template Foo<X>::non_dependent_type";
+      "Foo<X>::non_dependent_type";
+  Visitor.ExpectedQualTypeNames["AnEnumVar"] = "EnumScopeClass::AnEnum";
   Visitor.runOver(
       "int CheckInt;\n"
       "namespace A {\n"
       " namespace B {\n"
       "   class Class0 { };\n"
       "   namespace C {\n"
       "     typedef int MyInt;"
       "   }\n"
Visitor.runOver(
       "      class aStruct {};\n"
       "      aStruct CheckK;\n"
       "    }\n"
       "  }\n"
       "}\n"
       "template<class T> struct Foo {\n"
       "  typedef typename T::A dependent_type;\n"
       "  typedef int non_dependent_type;\n"
       "  dependent_type dependent_type_var;\n"
       "  non_dependent_type non_dependent_type_var;\n"
       "};\n"
       "struct X { typedef int A; };"
       "Foo<X> var;"
       "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"
 );
 
   TypeNameVisitor Complex;
   Complex.ExpectedQualTypeNames["CheckTX"] = "B::TX";
   Complex.runOver(
       "namespace A {"
       "  struct X {};"
       "}"