[Clang] Implement decltype(auto)(x) from P0849R2

[lichray]

Summary

As a Clang extension. See also https://wg21.link/p0849r2

The implementation takes a shortcut by forming CXXFunctionalCastExpr.
Doing so costs losing 'decltype(auto)' keyword in AST. Although
we do that elsewhere, because this is in an expression, it's more
difficult to keep AST print legal *and* trustworthy.

Depends on D113393

[lichray]

In D113393#3345275, @aaron.ballman wrote:

Also implemented decltype(auto)(x) (https://wg21.link/p0849r2) as a Clang extension.

I'd like to better understand the use cases for this. WG21 considered this as part of the feature and ultimately rejected it (fairly strongly, according to the EWG polls). From the meeting minutes, [...]

Not intended to argue for something when people who were against do not present - it's an awkward keyword for std::forward, arguably shorter, safer, faster...

[lichray]

Rebase

[lichray]

This comment was removed by lichray.

[lichray]

Restore the right diff

[aaron.ballman]

I'm adding more reviewers for a wider audience on this topic. Personally, I don't think we should support this extension. EWG voted pretty strongly against it: 0/3/7/6/1 (https://github.com/cplusplus/papers/issues/293#issuecomment-585662477) and Clang has a policy that language extensions should have representation within the appropriate governing body (https://clang.llvm.org/get_involved.html#criteria). Given that the governing body for this rejected it and there's not a significant user benefit to supporting it, I think we shouldn't step into the C++ design space for this extension. However, I have no idea how others feel.

[erichkeane]

In D120589#3408015, @aaron.ballman wrote:

I'm adding more reviewers for a wider audience on this topic. Personally, I don't think we should support this extension. EWG voted pretty strongly against it: 0/3/7/6/1 (https://github.com/cplusplus/papers/issues/293#issuecomment-585662477) and Clang has a policy that language extensions should have representation within the appropriate governing body (https://clang.llvm.org/get_involved.html#criteria). Given that the governing body for this rejected it and there's not a significant user benefit to supporting it, I think we shouldn't step into the C++ design space for this extension. However, I have no idea how others feel.

I tend to agree, EWG seemed quite against this (though sadly, it looks like the minutes never got uploaded to the wiki). For something to fail the 'is a problem worth solving' (aka, the 'author should do more work' vote) it means the room was quite against it. While I can see the attraction of this, I don't think it is a good feature.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_decltype_auto_cannot_be_combined : Error<
   "'decltype(auto)' cannot be combined with other type specifiers">;
 def err_decltype_auto_function_declarator_not_declaration : Error<
   "'decltype(auto)' can only be used as a return type "
   "in a function declaration">;
 def err_decltype_auto_compound_type : Error<
   "cannot form %select{pointer to|reference to|array of}0 'decltype(auto)'">;
 def err_decltype_auto_initializer_list : Error<
   "cannot deduce 'decltype(auto)' from initializer list">;
+def ext_decltype_auto_expr : ExtWarn<
+  "functional-style cast to 'decltype(auto)' is a Clang extension">,
+  InGroup<DiagGroup<"decltype-auto-cast">>;
 
 // C++17 deduced class template specialization types
 def err_deduced_class_template_compound_type : Error<
   "cannot %select{form pointer to|form reference to|form array of|"
   "form function returning|use parentheses when declaring variable with}0 "
   "deduced class template specialization type">;
 def err_deduced_non_class_template_specialization_type : Error<
   "%select{<error>|function template|variable template|alias template|"

clang/lib/Sema/SemaExprCXX.cpp

if (Inits.empty())
                        << Ty << FullRange);
     if (Inits.size() > 1) {
       Expr *FirstBad = Inits[1];
       return ExprError(Diag(FirstBad->getBeginLoc(),
                             diag::err_auto_expr_init_multiple_expressions)
                        << Ty << FullRange);
     }
     if (getLangOpts().CPlusPlus2b) {
-      if (Ty->getAs<AutoType>())
-        Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange;
+      if (auto *TyAuto = Ty->getAs<AutoType>())
+        Diag(TyBeginLoc, TyAuto->isDecltypeAuto()
+                             ? diag::ext_decltype_auto_expr
+                             : diag::warn_cxx20_compat_auto_expr)
+            << FullRange;
     }
     Expr *Deduce = Inits[0];
     if (isa<InitListExpr>(Deduce))
       return ExprError(
           Diag(Deduce->getBeginLoc(), diag::err_auto_expr_init_paren_braces)
           << ListInitialization << Ty << FullRange);
     QualType DeducedType;
     if (DeduceAutoType(TInfo, Deduce, DeducedType) == DAR_Failed)
       return ExprError(Diag(TyBeginLoc, diag::err_auto_expr_deduction_failure)
                        << Ty << Deduce->getType() << FullRange
                        << Deduce->getSourceRange());
     if (DeducedType.isNull())
       return ExprError();
 
     Ty = DeducedType;
+    if (Ty->isReferenceType()) {
+      // decltype(auto)(x) takes a shortcut; see also P0849R2.
+      // FIXME: Substitute auto here to prevent a crash when diagnosing lifetime
+      // of array argument in constant evaluation. Shouldn't be done this way.
+      return BuildCXXFunctionalCastExpr(SubstAutoTypeSourceInfo(TInfo, Ty), Ty,
+                                        LParenOrBraceLoc, Deduce,
+                                        RParenOrBraceLoc);
+    }
     Entity = InitializedEntity::InitializeTemporary(TInfo, Ty);
   }
 
   if (Ty->isDependentType() || CallExpr::hasAnyTypeDependentArguments(Exprs)) {
     // FIXME: CXXUnresolvedConstructExpr does not model list-initialization
     // directly. We work around this by dropping the locations of the braces.
     SourceRange Locs = ListInitialization
                            ? SourceRange()

clang/lib/Sema/SemaType.cpp

if (Deduced) {
     case DeclaratorContext::ConversionId:
       if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType)
         Error = 14; // conversion-type-id
       IsDeducedReturnType = true;
       break;
     case DeclaratorContext::FunctionalCast:
       if (isa<DeducedTemplateSpecializationType>(Deduced))
         break;
-      if (SemaRef.getLangOpts().CPlusPlus2b && IsCXXAutoType &&
-          !Auto->isDecltypeAuto())
-        break; // auto(x)
+      if (SemaRef.getLangOpts().CPlusPlus2b && IsCXXAutoType)
+        break; // auto(x) and decltype(auto)(x)
       LLVM_FALLTHROUGH;
     case DeclaratorContext::TypeName:
       Error = 15; // Generic
       break;
     case DeclaratorContext::File:
     case DeclaratorContext::Block:
     case DeclaratorContext::ForInit:
     case DeclaratorContext::SelectionInit:

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp

-// RUN: %clang_cc1 -std=c++2b -verify %s
+// RUN: %clang_cc1 -std=c++2b -Wno-decltype-auto-cast -verify %s
 
 // p2.3 allows only T = auto in T(x).
+// As a Clang extension, we also allow T = decltype(auto) to match p2.2 (new T(x)).
 
 void test_decay() {
   int v[3];
   static_assert(__is_same(decltype(auto(v)), int *));
   static_assert(__is_same(decltype(auto{v}), int *));
   static_assert(__is_same(decltype(auto("lit")), char const *));
   static_assert(__is_same(decltype(auto{"lit"}), char const *));
 
+  void(decltype(auto)(v)); // expected-error {{functional-style cast}}
+  void(decltype(auto){v}); // expected-error {{cannot initialize an array element}}
+  static_assert(__is_same(decltype(decltype(auto)("lit")), char const(&)[4]));
+  static_assert(__is_same(decltype(decltype(auto){"lit"}), char const(&)[4]));
+
+  int fn(char *);
+  static_assert(__is_same(decltype(auto(fn)), int (*)(char *)));
+  static_assert(__is_same(decltype(auto{fn}), int (*)(char *)));
+
+  void(decltype(auto)(fn)); // expected-error{{functional-style cast}}
+  void(decltype(auto){fn}); // expected-error{{cannot create object of function type}}
+
   constexpr long i = 1;
   static_assert(__is_same(decltype(i), long const));
   static_assert(__is_same(decltype(auto(1L)), long));
   static_assert(__is_same(decltype(auto{1L}), long));
   static_assert(__is_same(decltype(auto(i)), long));
   static_assert(__is_same(decltype(auto{i}), long));
 
+  // scalar prvalue is not cv-qualified
+  static_assert(__is_same(decltype(decltype(auto)(1L)), long));
+  static_assert(__is_same(decltype(decltype(auto){1L}), long));
+  static_assert(__is_same(decltype(decltype(auto)(i)), long));
+  static_assert(__is_same(decltype(decltype(auto){i}), long));
+
   class A {
   } a;
   A const ac;
 
   static_assert(__is_same(decltype(auto(a)), A));
   static_assert(__is_same(decltype(auto(ac)), A));
 
+  static_assert(__is_same(decltype(decltype(auto)(a)), A));
+  static_assert(__is_same(decltype(decltype(auto)(ac)), A const));
+
+  static_assert(__is_same(decltype(decltype(auto)((a))), A &));
+  static_assert(__is_same(decltype(decltype(auto)((ac))), A const &));
+
+  static_assert(__is_same(decltype(decltype(auto){a}), A));
+  static_assert(__is_same(decltype(decltype(auto){ac}), A const));
+
+  static_assert(__is_same(decltype(decltype(auto){(a)}), A &));
+  static_assert(__is_same(decltype(decltype(auto){(ac)}), A const &));
+
   A &lr = a;
   A const &lrc = a;
   A &&rr = static_cast<A &&>(a);
   A const &&rrc = static_cast<A &&>(a);
 
   static_assert(__is_same(decltype(auto(lr)), A));
   static_assert(__is_same(decltype(auto(lrc)), A));
   static_assert(__is_same(decltype(auto(rr)), A));
   static_assert(__is_same(decltype(auto(rrc)), A));
+
+  static_assert(__is_same(decltype(decltype(auto)(lr)), A &));
+  static_assert(__is_same(decltype(decltype(auto)(lrc)), A const &));
+  static_assert(__is_same(decltype(decltype(auto)(rr)), A &&));
+  static_assert(__is_same(decltype(decltype(auto)(rrc)), A const &&));
 }
 
 class cmdline_parser {
 public:
   cmdline_parser(char const *);
   auto add_option(char const *, char const *) && -> cmdline_parser &&;
 };
 

 
 // post-C++17 semantics
 namespace auto_x {
 constexpr struct Uncopyable {
   constexpr explicit Uncopyable(int) {}
   constexpr Uncopyable(Uncopyable &&) = delete;
 } u = auto(Uncopyable(auto(Uncopyable(42))));
 } // namespace auto_x
+
+// decltype(auto) is no-op to prvalues
+namespace decltype_auto_x {
+constexpr struct Uncopyable {
+  constexpr explicit Uncopyable(int) {}
+  constexpr Uncopyable(Uncopyable &&) = delete;
+} u = decltype(auto)(Uncopyable(decltype(auto)(Uncopyable(42))));
+} // namespace decltype_auto_x
+
+// Forward with decltype(auto)
+constexpr auto invoke1 = [](auto &&x, auto &&y) {
+  return decltype(auto)(x)(decltype(auto)(y));
+};
+
+struct MoveOnly {
+  MoveOnly() = default;
+  MoveOnly(MoveOnly &&) = default;
+  MoveOnly(MoveOnly const &) = delete;
+};
+
+constexpr MoveOnly getMoveOnly() { return {}; }
+
+struct Fn {
+  constexpr int operator()(MoveOnly &) & { return 0; }
+  constexpr int operator()(MoveOnly &&) & { return 1; }
+
+  constexpr int operator()(MoveOnly &) && { return 2; }
+  constexpr int operator()(MoveOnly &&) && { return 3; }
+
+  constexpr int operator()(MoveOnly &) const & { return 4; }
+  constexpr int operator()(MoveOnly &&) const & { return 5; }
+
+  constexpr int operator()(MoveOnly &) const && { return 6; }
+  constexpr int operator()(MoveOnly &&) const && { return 7; }
+};
+
+constexpr void FwdWithDecltypeAuto() {
+  MoveOnly lv;
+  Fn f;
+  constexpr Fn cf;
+
+  static_assert(invoke1(f, lv) == 0);
+  static_assert(invoke1(f, getMoveOnly()) == 1);
+
+  static_assert(invoke1(Fn{}, lv) == 2);
+  static_assert(invoke1(Fn{}, getMoveOnly()) == 3);
+
+  static_assert(invoke1(cf, lv) == 4);
+  static_assert(invoke1(cf, getMoveOnly()) == 5);
+
+  static_assert(invoke1((Fn const){}, lv) == 6);
+  static_assert(invoke1((Fn const){}, getMoveOnly()) == 7);
+}
+
+struct FnArray {
+  template <class T, int N>
+  constexpr int operator()(T (&)[N]) const { return 0; }
+
+  template <class T, int N>
+  constexpr int operator()(T (&&)[N]) const { return 1; }
+};
+
+constexpr void FwdArrayWithDecltypeAuto() {
+  FnArray f;
+
+  static_assert(invoke1(f, "foo") == 0);
+  static_assert(invoke1(f, (int[]){1, 2, 3}) == 1);
+}

clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp

-// RUN: %clang_cc1 -std=c++2b -verify %s
+// RUN: %clang_cc1 -std=c++2b -Wno-decltype-auto-cast -verify %s
 
 template <class T>
 void foo(T);
 
 struct A {
   int m;
   char g(int);
   float g(double);
void diagnostics() {
   foo(auto{{a, 3.14}});   // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}}
   foo(auto({a}, {3.14})); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}}
   foo(auto{{a}, {3.14}}); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}}
 
   foo(auto{1, 2});   // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}}
   foo(auto({1, 2})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}}
   foo(auto{{1, 2}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}}
 }
+
+void diagnostics_extension() {
+  foo(decltype(auto)());   // expected-error {{initializer for functional-style cast to 'decltype(auto)' is empty}}
+  foo(decltype(auto){});   // expected-error {{initializer for functional-style cast to 'decltype(auto)' is empty}}
+  foo(decltype(auto)({})); // expected-error {{cannot deduce actual type for 'decltype(auto)' from parenthesized initializer list}}
+  foo(decltype(auto){{}}); // expected-error {{cannot deduce actual type for 'decltype(auto)' from nested initializer list}}
+
+  foo(decltype(auto)({a})); // expected-error {{cannot deduce actual type for 'decltype(auto)' from parenthesized initializer list}}
+  foo(decltype(auto){{a}}); // expected-error {{cannot deduce actual type for 'decltype(auto)' from nested initializer list}}
+
+  foo(decltype(auto)(&A::g)); // expected-error {{reference to overloaded function could not be resolved}}
+
+  foo(decltype(auto)(a, 3.14));     // expected-error {{initializer for functional-style cast to 'decltype(auto)' contains multiple expressions}}
+  foo(decltype(auto){a, 3.14});     // expected-error {{initializer for functional-style cast to 'decltype(auto)' contains multiple expressions}}
+  foo(decltype(auto)({a, 3.14}));   // expected-error {{cannot deduce actual type for 'decltype(auto)' from parenthesized initializer list}}
+  foo(decltype(auto){{a, 3.14}});   // expected-error {{cannot deduce actual type for 'decltype(auto)' from nested initializer list}}
+  foo(decltype(auto)({a}, {3.14})); // expected-error {{initializer for functional-style cast to 'decltype(auto)' contains multiple expressions}}
+  foo(decltype(auto){{a}, {3.14}}); // expected-error {{initializer for functional-style cast to 'decltype(auto)' contains multiple expressions}}
+
+  foo(decltype(auto){1, 2});   // expected-error {{initializer for functional-style cast to 'decltype(auto)' contains multiple expressions}}
+  foo(decltype(auto)({1, 2})); // expected-error {{cannot deduce actual type for 'decltype(auto)' from parenthesized initializer list}}
+  foo(decltype(auto){{1, 2}}); // expected-error {{cannot deduce actual type for 'decltype(auto)' from nested initializer list}}
+}

clang/test/SemaCXX/deduced-return-type-cxx14.cpp

namespace DecltypeAutoShouldNotBeADecltypeSpecifier {
   }
 
   namespace BaseClass {
     struct A : decltype(auto) {}; // expected-error {{'decltype(auto)' not allowed here}}
     struct B {
       B() : decltype(auto)() {} // expected-error {{'decltype(auto)' not allowed here}}
     };
   }
+
+  namespace Cast {
+    void foo() {
+      (void)decltype(auto)(0); // cxx14_20-error{{'decltype(auto)' not allowed here}} \
+                                  cxx2b-warning{{functional-style cast to 'decltype(auto)' is a Clang extension}}
+      (void)decltype(auto){0}; // cxx14_20-error{{'decltype(auto)' not allowed here}} \
+                                  cxx2b-warning{{functional-style cast to 'decltype(auto)' is a Clang extension}}
+    }
+  }
 }
 
 namespace CurrentInstantiation {
   // PR16875
   template<typename T> struct S {
     auto f() { return T(); }
     int g() { return f(); }
     auto h(bool b) {