[Tooling] Add option to getFullyQualifiedName using a custom PritingPolicy

[mikhail.ramalho]

Summary

In our user case, we need to generate unique names for every tag, including anonymous structs/unions.

This adds a custom PrintingPolicy option to getFullyQualifiedName and the test case shows that different names are generated for different anonymous unions/structs.

[arphaman]

unittests/Tooling/QualTypeNamesTest.cpp

218

You should probably use multiline string here, i.e. R(" ... ")

[saugustine]

This is a good change as far as functionality, but I defer to others on the style and other details.

[mikhail.ramalho]

Should I update the other tests in QualTypeNamesTest.cpp to use multiline strings as well?

[mikhail.ramalho]

Updated QualTypeNamesTest.cpp to use multiline string in all tests.

Also ran clang-format -style=LLVM for code style.

[mikhail.ramalho]

ping

[klimek]

Sorry for jumping in late, but I'm somewhat questioning whether an extra function in the API is worth the cost here:
If you already have a printing policy, getting the type name will be 1 line instead of 2; having an extra function in a large API seems not worth it at a first glance.

[mikhail.ramalho]

Should we keep just the version with the custom printing policy then?

[mikhail.ramalho]

Rebased to current master.

Removed the getFullyQualifiedName overloaded function.

[rnk]

Mostly looks good.

unittests/Tooling/QualTypeNamesTest.cpp

225

Please choose a different variable name that doesn't clash with the PrintingPolicy type.

[mikhail.ramalho]

Renamed variables in the test so it doesn't match the type name

[mikhail.ramalho]

ping.

unittests/Tooling/QualTypeNamesTest.cpp

225

Done.

[mikhail.ramalho]

Ping.

[klimek]

I believe this was accepted by rnk - are you waiting for specific further feedback?

[mikhail.ramalho]

Last review asked to change the test case, I just want to make sure
everything is fine this time.

[saugustine]

In D36610#1083952, @mikhail.ramalho wrote:

Ping.

Given that richard smith is the only non-approver, and that he hasn't responded, and that I contributed this code, I'm going to make an executive decision and say that this is OK to submit.

We will roll back if there are problems.

[mikhail.ramalho]

Thanks.

I just need someone to push it, as I don't have write access to the repo.

[saugustine]

I applied this to a clean local copy, which has no other changes, and have
the following test error, which may be pilot error on my part, but
nevertheless, this test needs to be robust to changes in the line number.

llvm-svn/llvm/tools/clang/unittests/Tooling/QualTypeNamesTest.cpp:39:
Failure
Value of: false

Actual: false

Expected: true
Typename::getFullyQualifiedName failed for (anonymous struct)::un_in_st_1

Actual: union (anonymous struct at input.cc:1:1)::(anonymous union at

input.cc:2:27)
Exepcted: union (anonymous struct at input.cc:1:1)::(anonymous union at
input.cc:2:31)

[mikhail.ramalho]

Fixed the test case.

[saugustine]

Committed as r331552.

include/clang/Tooling/Core/QualTypeNames.h

 /// \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,
                                   bool WithGlobalNsPrefix = false);
+
+std::string getFullyQualifiedName(QualType QT,
+                                  const ASTContext &Ctx,
+                                  const PrintingPolicy &Policy,
+                                  bool WithGlobalNsPrefix = false);
 }  // end namespace TypeName
 }  // end namespace clang
 #endif  // LLVM_CLANG_TOOLING_CORE_QUALTYPENAMES_H

lib/Tooling/Core/QualTypeNames.cpp

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 PrintingPolicy &Policy,
+                                  bool WithGlobalNsPrefix) {
+  QualType FQQT = getFullyQualifiedType(QT, Ctx, WithGlobalNsPrefix);
+  return FQQT.getAsString(Policy);
+}
+
+std::string getFullyQualifiedName(QualType QT,
+                                  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, WithGlobalNsPrefix);
-  return FQQT.getAsString(Policy);
+  return getFullyQualifiedName(QT, Ctx, Policy, WithGlobalNsPrefix);
 }
 
 }  // 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"
+#include "clang/Tooling/Core/QualTypeNames.h"
 using namespace clang;
 
 namespace {
 struct TypeNameVisitor : TestVisitor<TypeNameVisitor> {
   llvm::StringMap<std::string> ExpectedQualTypeNames;
   bool WithGlobalNsPrefix = false;
+  bool CustomPrintingPolicy = false;
 
   // ValueDecls are the least-derived decl with both a qualtype and a
   // name.
   bool traverseDecl(Decl *D) {
-    return true;  // Always continue
+    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,
+      std::string ActualName;
+      if (!CustomPrintingPolicy)
+        ActualName = TypeName::getFullyQualifiedName(VD->getType(), *Context,
                                                      WithGlobalNsPrefix);
+      else {
+        PrintingPolicy Policy(Context->getPrintingPolicy());
+        Policy.SuppressScope = false;
+        Policy.AnonymousTagLocations = true;
+        Policy.PolishForDeclaration = true;
+        Policy.SuppressUnwrittenScope = true;
+        ActualName = TypeName::getFullyQualifiedName(
+            VD->getType(), *Context, Policy, 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;
       }
TEST(QualTypeNameTest, getFullyQualifiedName) {
   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.ExpectedQualTypeNames["CheckM"] = "const A::B::Class0 *";
   Visitor.ExpectedQualTypeNames["CheckN"] = "const X *";
   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"
-      "   void Function3(const B::Class0* CheckM);\n"
-      "  }\n"
-      "template<typename... Values> class Variadic {};\n"
-      "Variadic<int, B::Template0<int, char>, "
-      "         B::Template1<int, long>, "
-      "         B::C::MyInt > CheckE;\n"
-      " namespace BC = B::C;\n"
-      " BC::MyInt CheckL;\n"
-      "}\n"
-      "using A::B::Class0;\n"
-      "void Function(Class0 CheckF);\n"
-      "using namespace A::B::C;\n"
-      "void Function(MyInt CheckG);\n"
-      "void f() {\n"
-      "  struct X {} CheckH;\n"
-      "}\n"
-      "struct X;\n"
-      "void f(const ::X* CheckN) {}\n"
-      "namespace {\n"
-      "  class aClass {};\n"
-      "   aClass CheckI;\n"
-      "}\n"
-      "namespace A {\n"
-      "  struct aStruct {} CheckJ;\n"
-      "}\n"
-      "namespace {\n"
-      "  namespace D {\n"
-      "    namespace {\n"
-      "      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::Lang_CXX11
-);
+      R"(int CheckInt;
+         template <typename>
+         class OuterTemplateClass { };
+         namespace A {
+          namespace B {
+            class Class0 { };
+            namespace C {
+              typedef int MyInt;
+              template <typename T>
+              using InnerAlias = OuterTemplateClass<T>;
+              InnerAlias<int> AliasTypeVal;
+            }
+            template<class X, class Y> class Template0;
+            template<class X, class Y> class Template1;
+            typedef B::Class0 AnotherClass;
+            void Function1(Template0<C::MyInt,
+                           AnotherClass> CheckC);
+            void Function2(Template0<Template1<C::MyInt, AnotherClass>,
+                                     Template0<int, long> > CheckD);
+            void Function3(const B::Class0* CheckM);
+           }
+         template<typename... Values> class Variadic {};
+         Variadic<int, B::Template0<int, char>, 
+                  B::Template1<int, long>, 
+                  B::C::MyInt > CheckE;
+          namespace BC = B::C;
+          BC::MyInt CheckL;
+         }
+         using A::B::Class0;
+         void Function(Class0 CheckF);
+         using namespace A::B::C;
+         void Function(MyInt CheckG);
+         void f() {
+           struct X {} CheckH;
+         }
+         struct X;
+         void f(const ::X* CheckN) {}
+         namespace {
+           class aClass {};
+            aClass CheckI;
+         }
+         namespace A {
+           struct aStruct {} CheckJ;
+         }
+         namespace {
+           namespace D {
+             namespace {
+               class aStruct {};
+               aStruct CheckK;
+             }
+           }
+         }
+         template<class T> struct Foo {
+           typedef typename T::A dependent_type;
+           typedef int non_dependent_type;
+           dependent_type dependent_type_var;
+           non_dependent_type non_dependent_type_var;
+         };
+         struct X { typedef int A; };
+         Foo<X> var;
+         void F() {
+           var.dependent_type_var = 0;
+         var.non_dependent_type_var = 0;
+         }
+         class EnumScopeClass {
+         public:
+           enum AnEnum { ZERO, ONE };
+         };
+         EnumScopeClass::AnEnum AnEnumVar;)",
+      TypeNameVisitor::Lang_CXX11);
 
   TypeNameVisitor Complex;
   Complex.ExpectedQualTypeNames["CheckTX"] = "B::TX";
-  Complex.runOver(
-      "namespace A {"
-      "  struct X {};"
-      "}"
-      "using A::X;"
-      "namespace fake_std {"
-      "  template<class... Types > class tuple {};"
-      "}"
-      "namespace B {"
-      "  using fake_std::tuple;"
-      "  typedef tuple<X> TX;"
-      "  TX CheckTX;"
-      "  struct A { typedef int X; };"
-      "}");
+  Complex.runOver(R"(namespace A {
+                       struct X {};
+                     }
+                     using A::X;
+                     namespace fake_std {
+                       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"
-  );
+  GlobalNsPrefix.runOver(R"(namespace A {
+                              namespace B {
+                                int IntVal;
+                                bool BoolVal;
+                                struct X {};
+                                X XVal;
+                                template <typename T> class CCC { };
+                                template <typename T>
+                                using Alias = CCC<T>;
+                                Alias<int> IntAliasVal;
+                                struct Y { struct Z {}; };
+                                Y::Z ZVal;
+                              }
+                             }
+                            struct Z {};
+                            Z GlobalZVal;
+                            namespace {
+                              namespace D {
+                                namespace {
+                                  class aStruct {};
+                                  aStruct CheckK;
+                                }
+                              }
+                            })");
+
+  TypeNameVisitor PrintingPolicy;
+  PrintingPolicy.CustomPrintingPolicy = true;
+  PrintingPolicy.ExpectedQualTypeNames["a"] = "short";
+  PrintingPolicy.ExpectedQualTypeNames["un_in_st_1"] =
+      "union (anonymous struct at input.cc:1:1)::(anonymous union at "
+      "input.cc:2:31)";
+  PrintingPolicy.ExpectedQualTypeNames["b"] = "short";
+  PrintingPolicy.ExpectedQualTypeNames["un_in_st_2"] =
+      "union (anonymous struct at input.cc:1:1)::(anonymous union at "
+      "input.cc:5:31)";
+  PrintingPolicy.ExpectedQualTypeNames["anon_st"] =
+      "struct (anonymous struct at input.cc:1:1)";
+  PrintingPolicy.runOver(R"(struct {
+                              union {
+                                short a;
+                              } un_in_st_1;
+                              union {
+                                short b;
+                              } un_in_st_2;
+                            } anon_st;)");
 }
 
-}  // end anonymous namespace
+} // end anonymous namespace