[clang] Fix constrained decltype(auto) deduction

[mizvekov]

Summary

Prior to this fix, constrained decltype(auto) behaves exactly the same
as constrained regular auto.
This fixes it so it deduces like decltype(auto).

Signed-off-by: Matheus Izvekov <[e-mail]>

[rsmith]

Looks good, thanks!

clang/test/CXX/dcl/dcl.spec/dcl.type/dcl.spec.auto/p6.cpp

59–63

For completeness, it'd be nice to test the decltype((...)) case too.

[mizvekov]

Added new tests as suggested by rsmith.

By the way, I still need help commiting this.

[mizvekov]

Turns out someone had already reported this bug.

This change puts "PR48384" in the new tests.

clang/lib/Sema/SemaType.cpp

static QualType ConvertConstrainedAutoDeclSpecToType(Sema &S, DeclSpec &DS,
   TemplateArgsInfo.setLAngleLoc(TemplateId->LAngleLoc);
   TemplateArgsInfo.setRAngleLoc(TemplateId->RAngleLoc);
   ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
                                      TemplateId->NumArgs);
   S.translateTemplateArguments(TemplateArgsPtr, TemplateArgsInfo);
   llvm::SmallVector<TemplateArgument, 8> TemplateArgs;
   for (auto &ArgLoc : TemplateArgsInfo.arguments())
     TemplateArgs.push_back(ArgLoc.getArgument());
-  return S.Context.getAutoType(QualType(), AutoTypeKeyword::Auto, false,
-                               /*IsPack=*/false,
-                               cast<ConceptDecl>(TemplateId->Template.get()
-                                                 .getAsTemplateDecl()),
-                               TemplateArgs);
+  return S.Context.getAutoType(
+      QualType(), AutoKW, false, /*IsPack=*/false,
+      cast<ConceptDecl>(TemplateId->Template.get().getAsTemplateDecl()),
 }
 
 /// Convert the specified declspec to the appropriate type
 /// object.
 /// \param state Specifies the declarator containing the declaration specifier
 /// to be converted, along with other associated processing state.
 /// \returns The type described by the declaration specifiers.  This function
 /// never returns null.

clang/test/CXX/dcl/dcl.fct/p17.cpp

namespace constrained {
   static_assert(is_same_v<decltype(f8(i, i, ci)), void>);
   // expected-error@-1{{no matching}}
   void f9(const C auto &... x);
   // expected-note@-1{{candidate template ignored}} expected-note@-1{{because}}
   static_assert(is_same_v<decltype(f9(i, i)), void>);
   static_assert(is_same_v<decltype(f9(i, c)), void>);
   // expected-error@-1{{no matching}}
   static_assert(is_same_v<decltype(f9(i, i, ci)), void>);
-  void f10(C decltype(auto) x);
+  void f10(C decltype(auto) x); // expected-error{{decltype(auto)' not allowed in function prototype}}
   auto f11 = [] (C auto x) { };
   // expected-note@-1{{candidate template ignored}} expected-note@-1{{because}}
   static_assert(is_same_v<decltype(f11(1)), void>);
   static_assert(is_same_v<decltype(f11('a')), void>);
   // expected-error@-1{{no matching}}
 
   void f12(C2<char> auto x);
   // expected-note@-1{{candidate template ignored}} expected-note@-1{{because}}
namespace constrained {
   static_assert(is_same_v<decltype(f19(c, c, cc)), void>);
   // expected-error@-1{{no matching}}
   void f20(const C2<char> auto &... x);
   // expected-note@-1{{candidate template ignored}} expected-note@-1{{because}}
   static_assert(is_same_v<decltype(f20(c, c)), void>);
   static_assert(is_same_v<decltype(f20(i, c)), void>);
   // expected-error@-1{{no matching}}
   static_assert(is_same_v<decltype(f20(c, c, cc)), void>);
-  void f21(C2<char> decltype(auto) x);
+  void f21(C2<char> decltype(auto) x); // expected-error{{decltype(auto)' not allowed in function prototype}}
   auto f22 = [] (C2<char> auto x) { };
   // expected-note@-1{{candidate template ignored}} expected-note@-1{{because}}
   static_assert(is_same_v<decltype(f22(1)), void>);
   // expected-error@-1{{no matching}}
   static_assert(is_same_v<decltype(f22('a')), void>);
 
   struct S1 { S1(C auto); };
   // expected-note@-1{{candidate template ignored}} expected-note@-1{{because}}

clang/test/CXX/dcl/dcl.spec/dcl.type/dcl.spec.auto/p6.cpp

 // RUN:  %clang_cc1 -std=c++2a -verify %s
+template<typename T, typename U> constexpr bool is_same_v = false;
+template<typename T> constexpr bool is_same_v<T, T> = true;
 
 template<typename T, unsigned size>
 concept LargerThan = sizeof(T) > size;
 // expected-note@-1 2{{because 'sizeof(char) > 1U' (1 > 1) evaluated to false}}
 // expected-note@-2 {{because 'sizeof(int) > 10U' (4 > 10) evaluated to false}}
 // expected-note@-3 {{because 'sizeof(int) > 4U' (4 > 4) evaluated to false}}
 
 template<typename T>

 // expected-error@-1{{deduced type 'int' does not satisfy 'LargerThan<4>'}}
 ::LargerThan<2> auto test4() { return 10; }
 
 Large auto test5() -> void;
 // expected-error@-1{{function with trailing return type must specify return type 'auto', not 'Large auto'}}
 auto test6() -> Large auto { return 1; }
 
 X::Small auto test7() { return 'a'; }
-X::SmallerThan<5> auto test8() { return 10; }
+X::SmallerThan<5> auto test8() { return 10; }
+
+namespace PR48384 {
+  int a = 0;
+  int &b = a;
+  template <class T> concept True = true;
+
+  True auto c = a;
+  static_assert(is_same_v<decltype(c), int>);
+
+  True auto d = b;
+  static_assert(is_same_v<decltype(d), int>);
+
+  True decltype(auto) e = a;
+  static_assert(is_same_v<decltype(e), int>);
+
+  True decltype(auto) f = b;
+  static_assert(is_same_v<decltype(f), int&>);
+
+  True decltype(auto) g = (a);
+  static_assert(is_same_v<decltype(g), int&>);
+
+  True decltype(auto) h = (b);
+  static_assert(is_same_v<decltype(h), int&>);
+}

clang/test/Parser/cxx2a-placeholder-type-constraint.cpp

int foo() {
   {const C auto &a = 1;}
   {const C<> auto &a = 1;}
   {const C<int> auto &a = 1;}
   {const ns::D<int> auto &a = 1;}
   {C decltype(auto) a = 1;}
   {C<> decltype(auto) a = 1;}
   {C<int> decltype(auto) a = 1;}
   {const C<> decltype(auto) &a = 1;} // expected-error{{'decltype(auto)' cannot be combined with other type specifiers}}
-  // expected-error@-1{{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
+  // expected-error@-1{{cannot form reference to 'decltype(auto)'}}
   {const C<int> decltype(auto) &a = 1;} // expected-error{{'decltype(auto)' cannot be combined with other type specifiers}}
-  // expected-error@-1{{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
+  // expected-error@-1{{cannot form reference to 'decltype(auto)'}}
   {C a = 1;}
   // expected-error@-1{{expected 'auto' or 'decltype(auto)' after concept name}}
   {C decltype a19 = 1;}
   // expected-error@-1{{expected '('}}
   {C decltype(1) a20 = 1;}
   // expected-error@-1{{expected 'auto' or 'decltype(auto)' after concept name}}
-}
+}