[DeclPrinter] Honor TerseOutput for constructors

[nik]

Summary

...by not printing the body (as for functions) and not printing the
member initialization list.

[nik]

• [DeclPrinter] Allow printing fully qualified name of function declaration

[nik]

Ops, restored to previous state.

[nik]

Try to restore, II.

[nik]

Sorry for the noise, I'm just doing my first steps with "arc diff".

I've managed to restore this - please review or add more appropriate reviewers.

[arphaman]

LGTM

lib/AST/DeclPrinter.cpp

618

NIT: This function is getting a bit unwieldy. You might want to extract the initializer printing code into a new function in a pre/post commit.

[nik]

Thanks for the fast review! :)

Please land/submit this for me as I don't have permissions for this.

lib/AST/DeclPrinter.cpp

618

Will do.

[nik]

lib/AST/DeclPrinter.cpp

618

https://reviews.llvm.org/D40066

[arphaman]

Thanks. Sure, I will commit the patches today.

[arphaman]

FYI, please remember to CC cfe-commits for your future patches.

[nik]

Thanks Alex!

FYI, please remember to CC cfe-commits for your future patches.

Oh, OK. I guess I somehow assumed arc diff would took care of that.

include/clang/AST/PrettyPrinter.h

: Indentation(2), SuppressSpecifiers(false),
       SuppressStrongLifetime(false), SuppressLifetimeQualifiers(false),
       SuppressTemplateArgsInCXXConstructors(false),
       Bool(LO.Bool), Restrict(LO.C99),
       Alignof(LO.CPlusPlus11), UnderscoreAlignof(LO.C11),
       UseVoidForZeroParams(!LO.CPlusPlus),
       TerseOutput(false), PolishForDeclaration(false),
       Half(LO.Half), MSWChar(LO.MicrosoftExt && !LO.WChar),
       IncludeNewlines(true), MSVCFormatting(false),
-      ConstantsAsWritten(false), SuppressImplicitBase(false) { }
+      ConstantsAsWritten(false), SuppressImplicitBase(false),
+      FullyQualifiedName(false) { }
 
   /// Adjust this printing policy for cases where it's known that we're
   /// printing C++ code (for instance, if AST dumping reaches a C++-only
   /// construct). This should not be used if a real LangOptions object is
   /// available.
   void adjustForCPlusPlus() {
     SuppressTagKeyword = true;
     Bool = true;
struct PrintingPolicy {
   /// \code
   /// 0x10
   /// 2.5e3
   /// \endcode
   bool ConstantsAsWritten : 1;
 
   /// When true, don't print the implicit 'self' or 'this' expressions.
   bool SuppressImplicitBase : 1;
+
+  /// When true, print the fully qualified name of function declarations.
+  /// This is the opposite of SuppressScope and thus overrules it.
+  bool FullyQualifiedName : 1;
 };
 
 } // end namespace clang
 
 #endif

lib/AST/DeclPrinter.cpp

if ((CDecl && CDecl->isExplicitSpecified()) ||
         (ConversionDecl && ConversionDecl->isExplicitSpecified()) ||
         (GuideDecl && GuideDecl->isExplicitSpecified()))
       Out << "explicit ";
   }
 
   PrintingPolicy SubPolicy(Policy);
   SubPolicy.SuppressSpecifiers = false;
   std::string Proto;
+
+  if (Policy.FullyQualifiedName) {
+    Proto += D->getQualifiedNameAsString();
+  } else {
     if (!Policy.SuppressScope) {
       if (const NestedNameSpecifier *NS = D->getQualifier()) {
         llvm::raw_string_ostream OS(Proto);
         NS->print(OS, Policy);
       }
     }
     Proto += D->getNameInfo().getAsString();
+  }
+
   if (GuideDecl)
     Proto = GuideDecl->getDeducedTemplate()->getDeclName().getAsString();
   if (const TemplateArgumentList *TArgs = D->getTemplateSpecializationArgs()) {
     llvm::raw_string_ostream POut(Proto);
     DeclPrinter TArgPrinter(POut, SubPolicy, Context, Indentation);
     TArgPrinter.printTemplateArguments(*TArgs);
   }
 
if (FT && FT->hasDynamicExceptionSpec()) {
         EOut.flush();
         Proto += EOut.str();
         Proto += ")";
       }
     }
 
     if (CDecl) {
       if (!Policy.TerseOutput) {
         bool HasInitializerList = false;
         for (const auto *BMInitializer : CDecl->inits()) {
           if (BMInitializer->isInClassMemberInitializer())
             continue;
 
           if (!HasInitializerList) {
             Proto += " : ";
             Out << Proto;
             Proto.clear();

unittests/AST/DeclPrinterTest.cpp

PrintedDeclMatches(StringRef Code, const std::vector<std::string> &Args,
   if (Printer.getPrinted() != ExpectedPrinted)
     return ::testing::AssertionFailure()
       << "Expected \"" << ExpectedPrinted.str() << "\", "
          "got \"" << Printer.getPrinted().str() << "\"";
 
   return ::testing::AssertionSuccess();
 }
 
-::testing::AssertionResult PrintedDeclCXX98Matches(StringRef Code,
-                                                   StringRef DeclName,
-                                                   StringRef ExpectedPrinted) {
+::testing::AssertionResult
+PrintedDeclCXX98Matches(StringRef Code, StringRef DeclName,
+                        StringRef ExpectedPrinted,
+                        PrintingPolicyModifier PolicyModifier = nullptr) {
   std::vector<std::string> Args(1, "-std=c++98");
   return PrintedDeclMatches(Code,
                             Args,
                             namedDecl(hasName(DeclName)).bind("id"),
                             ExpectedPrinted,
-                            "input.cc");
+                            "input.cc",
+                            PolicyModifier);
 }
 
 ::testing::AssertionResult
 PrintedDeclCXX98Matches(StringRef Code, const DeclarationMatcher &NodeMatch,
                         StringRef ExpectedPrinted,
                         PrintingPolicyModifier PolicyModifier = nullptr) {
   std::vector<std::string> Args(1, "-std=c++98");
   return PrintedDeclMatches(Code,

 
 TEST(DeclPrinter, TestFunctionDecl1) {
   ASSERT_TRUE(PrintedDeclCXX98Matches(
     "void A();",
     "A",
     "void A()"));
 }
 
+TEST(DeclPrinter, TestFreeFunctionDecl_FullyQualifiedName) {
+    ASSERT_TRUE(PrintedDeclCXX98Matches(
+      "void A();",
+      "A",
+      "void A()",
+      [](PrintingPolicy &Policy){ Policy.FullyQualifiedName = true; }));
+}
+
+TEST(DeclPrinter, TestFreeFunctionDeclInNamespace_FullyQualifiedName) {
+    ASSERT_TRUE(PrintedDeclCXX98Matches(
+      "namespace X { void A(); };",
+      "A",
+      "void X::A()",
+      [](PrintingPolicy &Policy){ Policy.FullyQualifiedName = true; }));
+}
+
+TEST(DeclPrinter, TestMemberFunction_FullyQualifiedName) {
+    ASSERT_TRUE(PrintedDeclCXX98Matches(
+      "struct X { void A(); };",
+      "A",
+      "void X::A()",
+      [](PrintingPolicy &Policy){ Policy.FullyQualifiedName = true; }));
+}
+
+TEST(DeclPrinter, TestMemberFunctionInNamespace_FullyQualifiedName) {
+    ASSERT_TRUE(PrintedDeclCXX98Matches(
+      "namespace Z { struct X { void A(); }; }",
+      "A",
+      "void Z::X::A()",
+      [](PrintingPolicy &Policy){ Policy.FullyQualifiedName = true; }));
+}
+
+TEST(DeclPrinter, TestMemberFunctionOutside_FullyQualifiedName) {
+    ASSERT_TRUE(PrintedDeclCXX98Matches(
+      "struct X { void A(); };"
+       "void X::A() {}",
+      functionDecl(hasName("A"), isDefinition()).bind("id"),
+      "void X::A()",
+      [](PrintingPolicy &Policy){ Policy.FullyQualifiedName = true; }));
+}
+
 TEST(DeclPrinter, TestFunctionDecl2) {
   ASSERT_TRUE(PrintedDeclCXX98Matches(
     "void A() {}",
     "A",
     "void A()"));
 }
 
 TEST(DeclPrinter, TestFunctionDecl3) {