[Clang] Remove redundant init-parens in AST print

[lichray]

Summary

Given a dependent T (maybe an undeduced auto),

Before:

new T(z)  -->  new T((z))  # changes meaning with more args
new T{z}  -->  new T{z}
    T(z)  -->      T(z)
    T{z}  -->      T({z})  # forbidden if T is auto

After:

new T(z)  -->  new T(z)
new T{z}  -->  new T{z}
    T(z)   -->     T(z)
    T{z}   -->     T{z}

Depends on D113393

[aaron.ballman]

LGTM aside from a nit.

clang/lib/AST/StmtPrinter.cpp

2156–2159

You should still spell out the type as it's not spelled out in the initialization.

[lichray]

clang/lib/AST/StmtPrinter.cpp

2156–2159

In this piece of code, I got "CXXNewExpr," "InitializationStyle", "::" -- every morpheme needed to derive the type "CXXNewExpr::InitializationStyle," so I guess it's clear enough.

[aaron.ballman]

clang/lib/AST/StmtPrinter.cpp

2156–2159

I don't want to hold anything up over this, but the usual rule of thumb is "in the initialization" so that we don't have to hunt around to other code to figure out the type.

[lichray]

Nit

clang/lib/AST/StmtPrinter.cpp

if (Optional<Expr *> Size = E->getArraySize())
       (*Size)->printPretty(s, Helper, Policy);
     s << ']';
   }
   E->getAllocatedType().print(OS, Policy, TypeS);
   if (E->isParenTypeId())
     OS << ")";
 
   CXXNewExpr::InitializationStyle InitStyle = E->getInitializationStyle();
-  if (InitStyle) {
-    if (InitStyle == CXXNewExpr::CallInit)
+  if (InitStyle != CXXNewExpr::NoInit) {
+    bool Bare = InitStyle == CXXNewExpr::CallInit &&
+                !isa<ParenListExpr>(E->getInitializer());
+    if (Bare)
       OS << "(";
     PrintExpr(E->getInitializer());
-    if (InitStyle == CXXNewExpr::CallInit)
+    if (Bare)
       OS << ")";
   }
 }
 
 void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
   if (E->isGlobalDelete())
     OS << "::";
   OS << "delete ";
void StmtPrinter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
   PrintExpr(E->getSubExpr());
 }
 
 void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) {
   // Just forward to the subexpression.
   PrintExpr(E->getSubExpr());
 }
 
-void
-StmtPrinter::VisitCXXUnresolvedConstructExpr(
-                                           CXXUnresolvedConstructExpr *Node) {
+void StmtPrinter::VisitCXXUnresolvedConstructExpr(
   Node->getTypeAsWritten().print(OS, Policy);
-  OS << "(";
-  for (CXXUnresolvedConstructExpr::arg_iterator Arg = Node->arg_begin(),
-                                             ArgEnd = Node->arg_end();
-       Arg != ArgEnd; ++Arg) {
+  if (!Node->isListInitialization())
+    OS << '(';
+  for (auto Arg = Node->arg_begin(), ArgEnd = Node->arg_end(); Arg != ArgEnd;
+       ++Arg) {
     if (Arg != Node->arg_begin())
       OS << ", ";
     PrintExpr(*Arg);
   }
-  OS << ")";
+  if (!Node->isListInitialization())
+    OS << ')';
 }
 
 void StmtPrinter::VisitCXXDependentScopeMemberExpr(
                                          CXXDependentScopeMemberExpr *Node) {
   if (!Node->isImplicitAccess()) {
     PrintExpr(Node->getBase());
     OS << (Node->isArrow() ? "->" : ".");
   }

clang/test/CXX/expr/expr.prim/expr.prim.req/simple-requirement.cpp

 using r5i2 = r5<char>;
 
 template<typename T>
 struct E {
   struct non_default_constructible { non_default_constructible(T t) { } };
 };
 
 template<typename T> requires requires(T t) { typename E<T>::non_default_constructible{}; }
-// expected-note@-1 {{because 'typename E<T>::non_default_constructible({})' would be invalid: no matching constructor for initialization of 'typename E<int>::non_default_constructible'}}
+// expected-note@-1 {{because 'typename E<T>::non_default_constructible{}' would be invalid: no matching constructor for initialization of 'typename E<int>::non_default_constructible'}}
 struct r6 {};
 
 using r6i1 = r6<int>;
 // expected-error@-1 {{constraints not satisfied for class template 'r6' [with T = int]}}
 
 template<typename T> requires requires(T t) { typename E<T>::non_default_constructible(); }
 // expected-note@-1 {{because 'typename E<T>::non_default_constructible()' would be invalid: no matching constructor for initialization of 'typename E<int>::non_default_constructible'}}
 struct r7 {};

clang/test/SemaCXX/cxx2b-ast-print.cpp

 // RUN: %clang_cc1 -std=c++2b -fsyntax-only -ast-print %s | FileCheck %s
 
+template <template <class...> class C>
 void test_auto_expr(long long y, auto &&z) {
   int x[] = {3, 4};
 
   // CHECK{LITERAL}: (int)(x[1])
   void(auto(x[1]));
   // CHECK{LITERAL}: (int){x[1]}
   void(auto{x[1]});
 
   // CHECK{LITERAL}: (int *)(x)
   void(auto(x));
   // CHECK{LITERAL}: (int *){x}
   void(auto{x});
 
   // CHECK{LITERAL}: auto(z)
   void(auto(z));
-  // CHECK{LITERAL}: auto({z})
-  void(auto{z}); // T({z}) is legal unless T = auto
+  // CHECK{LITERAL}: auto{z}
+  void(auto{z});
 
   // CHECK{LITERAL}: new int *(x)
   void(new auto(x));
   // CHECK{LITERAL}: new int *{x}
   void(new auto{x});
 
+  // CHECK{LITERAL}: new auto(z)
+  void(new auto(z));
+  // CHECK{LITERAL}: new auto{z}
+  void(new auto{z});
+
   // CHECK{LITERAL}: new long long(y)
   void(new decltype(auto)(y));
   // CHECK{LITERAL}: new long long{y}
   void(new decltype(auto){y});
+
+  // CHECK{LITERAL}: new decltype(auto)(z)
+  void(new decltype(auto)(z));
+  // CHECK{LITERAL}: new decltype(auto){z}
+  void(new decltype(auto){z});
+
+  // CHECK{LITERAL}: C(x, y, z)
+  void(C(x, y, z));
+  // CHECK{LITERAL}: C{x, y, z}
+  void(C{x, y, z});
+
+  // CHECK{LITERAL}: new C(x, y, z)
+  void(new C(x, y, z));
+  // CHECK{LITERAL}: new C{x, y, z}
+  void(new C{x, y, z});
 }