[Concepts] Fix placeholder constraints when references are involved

[royjacobson]

Summary

Placeholder types were not checked for constraint satisfaction when modified by references or pointers.
The behavior now matches that of GCC and MSVC.

Are there other modifiers we might need to "peel"? I'm not sure my approach to this is the 'right' way to fix this, the loop feels a bit clunky.

GitHub issues #54443, #53911

[royjacobson]

I noticed issue #53911 which is very similar so I fixed it as well.

[erichkeane]

Can you add some tests for the OTHER forms of 'auto' as well? We have decltype(auto) and auto_type, and I want to make sure whatever we do with those 'looks right'.

clang/lib/Sema/SemaTemplateDeduction.cpp

4773

We don't do curley braces on single-line blocks.

[royjacobson]

Remove the curly brackets from one line loop.

[royjacobson]

In D122083#3402289, @erichkeane wrote:

Can you add some tests for the OTHER forms of 'auto' as well? We have decltype(auto) and auto_type, and I want to make sure whatever we do with those 'looks right'.

Can we have constraints on __auto_type? As far as I understand it, it's a C extension with very limited C++ support.
About decltype(auto) - we can't have */& modifiers with it, and that's already covered by tests like p7-cxx14.

So (I think?) it's always invalid code and it fails earlier during parsing.

[erichkeane]

In D122083#3402440, @royjacobson wrote:

In D122083#3402289, @erichkeane wrote:

Can you add some tests for the OTHER forms of 'auto' as well? We have decltype(auto) and auto_type, and I want to make sure whatever we do with those 'looks right'.

Can we have constraints on __auto_type? As far as I understand it, it's a C extension with very limited C++ support.

I tried a couple and cannot convince GCC to let me deduce it.

About decltype(auto) - we can't have */& modifiers with it, and that's already covered by tests like p7-cxx14.

Ah, right, thanks!

So (I think?) it's always invalid code and it fails earlier during parsing.

Yep, thanks for that.

1 more test I'd like to see that doesn't seem covered (ref to ptr), AND according to @aaron.ballman we need "Release Notes" for this. Otherwise LGTM. Do you have commit rights yet?

clang/test/SemaTemplate/concepts.cpp

207–211

would also like C auto*&

[royjacobson]

Add test for auto**& combination

[royjacobson]

In D122083#3402445, @erichkeane wrote:

1 more test I'd like to see that doesn't seem covered (ref to ptr),

Added, good idea.

AND according to @aaron.ballman we need "Release Notes" for this. Otherwise LGTM. Do you have commit rights yet?

Yeah, I got commit rights :)
This should go into "Bug Fixes" section in clang/docs/ReleaseNotes.rst, right? Or "C++20 Feature Support"?

[erichkeane]

In D122083#3402523, @royjacobson wrote:

In D122083#3402445, @erichkeane wrote:

1 more test I'd like to see that doesn't seem covered (ref to ptr),

Added, good idea.

AND according to @aaron.ballman we need "Release Notes" for this. Otherwise LGTM. Do you have commit rights yet?

Yeah, I got commit rights :)
This should go into "Bug Fixes" section in clang/docs/ReleaseNotes.rst, right? Or "C++20 Feature Support"?

I'd suggest 'bug fixes'.

[royjacobson]

Added release notes.

[erichkeane]

LGTM, thanks!

[royjacobson]

Rebase

clang/docs/ReleaseNotes.rst

- ``CXXNewExpr::getArraySize()`` previously returned a ``llvm::Optional``
   wrapping a ``nullptr`` when the ``CXXNewExpr`` did not have an array
   size expression. This was fixed and ``::getArraySize()`` will now always
   either return ``None`` or a ``llvm::Optional`` wrapping a valid ``Expr*``.
   This fixes `Issue 53742 <https://github.com/llvm/llvm-project/issues/53742>`_.
 - We now ignore full expressions when traversing cast subexpressions. This
   fixes `Issue 53044 <https://github.com/llvm/llvm-project/issues/53044>`_.
 - Allow `-Wno-gnu` to silence GNU extension diagnostics for pointer arithmetic
   diagnostics. Fixes `Issue 54444 <https://github.com/llvm/llvm-project/issues/54444>`_.
+- Placeholder constraints, as in `Concept auto x = f();`, were not checked when modifiers
+  like ``auto&`` or ``auto**`` were added. These constraints are now checked.
+  This fixes  `Issue 53911 <https://github.com/llvm/llvm-project/issues/53911>`_
+  and  `Issue 54443 <https://github.com/llvm/llvm-project/issues/54443>`_.
 
 Improvements to Clang's diagnostics
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 - ``-Wliteral-range`` will warn on floating-point equality comparisons with
   constants that are not representable in a casted value. For example,
   ``(float) f == 0.1`` is always false.
 
 Non-comprehensive list of changes in this release

clang/lib/Sema/SemaTemplateDeduction.cpp

Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
   QualType DeducedType = Deduced[0].getAsType();
 
   if (InitList) {
     DeducedType = BuildStdInitializerList(DeducedType, Loc);
     if (DeducedType.isNull())
       return DAR_FailedAlreadyDiagnosed;
   }
 
-  if (const auto *AT = Type.getType()->getAs<AutoType>()) {
+  QualType MaybeAuto = Type.getType().getNonReferenceType();
+  while (MaybeAuto->isPointerType())
+    MaybeAuto = MaybeAuto->getPointeeType();
+  if (const auto *AT = MaybeAuto->getAs<AutoType>()) {
     if (AT->isConstrained() && !IgnoreConstraints) {
-      auto ConstraintsResult =
-          CheckDeducedPlaceholderConstraints(*this, *AT,
-                                             Type.getContainedAutoTypeLoc(),
-                                             DeducedType);
+      auto ConstraintsResult = CheckDeducedPlaceholderConstraints(
+          *this, *AT, Type.getContainedAutoTypeLoc(), DeducedType);
       if (ConstraintsResult != DAR_Succeeded)
         return ConstraintsResult;
     }
   }
 
   Result = SubstituteDeducedTypeTransform(*this, DeducedType).Apply(Type);
   if (Result.isNull())
     return DAR_FailedAlreadyDiagnosed;

clang/test/SemaTemplate/concepts.cpp

 namespace PR50561 {
   template<typename> concept C = false;
   template<typename T, typename U> void f(T, U);
   template<C T, typename U> void f(T, U) = delete;
   void g() { f(0, 0); }
 }
 
 namespace PR49188 {
-  template<class T> concept C = false;     // expected-note 6 {{because 'false' evaluated to false}}
+  template<class T> concept C = false;     // expected-note 7 {{because 'false' evaluated to false}}
 
   C auto f1() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
     return void();
   }
   C auto f2() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
     return;
   }
   C auto f3() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
   }
   C decltype(auto) f4() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
     return void();
   }
   C decltype(auto) f5() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
     return;
   }
   C decltype(auto) f6() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
   }
-  C auto& f7() { // expected-error {{cannot form a reference to 'void'}}
+  C auto& f7() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
     return void();
   }
   C auto& f8() {
     return; // expected-error {{cannot deduce return type 'C auto &' from omitted return expression}}
   }
   C auto& f9() { // expected-error {{cannot deduce return type 'C auto &' for function with no return statements}}
   }
 }
 namespace PR53911 {
-  template<class T> concept C = false;
+  template<class T> concept C = false; // expected-note 3 {{because 'false' evaluated to false}}
 
-  C auto *f1() {
-    return (void*)nullptr; // FIXME: should error
+  C auto *f1() { // expected-error {{deduced type 'void' does not satisfy 'C'}}
+    return (void*)nullptr;
   }
-  C auto *f2() {
-    return (int*)nullptr; // FIXME: should error
+  C auto *f2() { // expected-error {{deduced type 'int' does not satisfy 'C'}}
+    return (int*)nullptr;
+  }
+  C auto *****f3() { // expected-error {{deduced type 'int' does not satisfy 'C'}}
+    return (int*****)nullptr;
   }
 }
 
 namespace PR54379 {
 template <int N>
 struct A {
   static void f() requires (N == 0) { return; } // expected-note {{candidate template ignored: constraints not satisfied}} expected-note {{evaluated to false}}
   static void f() requires (N == 1) { return; } // expected-note {{candidate template ignored: constraints not satisfied}} expected-note {{evaluated to false}}
 };
 void (*f1)() = A<2>::f; // expected-error {{address of overloaded function 'f' does not match required type}}
 
 struct B {
   template <int N2 = 1> static void f() requires (N2 == 0) { return; }  // expected-note {{candidate template ignored: constraints not satisfied [with N2 = 1]}} expected-note {{evaluated to false}}
 };
 void (*f2)() = B::f; // expected-error {{address of overloaded function 'f' does not match required type}}
 }
+
+namespace PR54443 {
+
+template <class T, class U>
+struct is_same { static constexpr bool value = false; };
+
+template <class T>
+struct is_same<T, T> { static constexpr bool value = true; };
+
+template <class T, class U>
+concept same_as = is_same<T, U>::value; // expected-note-re 4 {{because {{.*}} evaluated to false}}
+
+int const &f();
+
+same_as<int const> auto i1 = f(); // expected-error {{deduced type 'int' does not satisfy 'same_as<const int>'}}
+same_as<int const> auto &i2 = f();
+same_as<int const> auto &&i3 = f(); // expected-error {{deduced type 'const int &' does not satisfy 'same_as<const int>'}}
+
+same_as<int const &> auto i4 = f(); // expected-error {{deduced type 'int' does not satisfy 'same_as<const int &>'}}
+same_as<int const &> auto &i5 = f(); // expected-error {{deduced type 'const int' does not satisfy 'same_as<const int &>'}}
+same_as<int const &> auto &&i6 = f();
+
+template <class T>
+concept C = false; // expected-note 3 {{because 'false' evaluated to false}}
+
+int **const &g();
+
+C auto **j1 = g();   // expected-error {{deduced type 'int' does not satisfy 'C'}}
+C auto **&j2 = g();  // expected-error {{deduced type 'int' does not satisfy 'C'}}
+C auto **&&j3 = g(); // expected-error {{deduced type 'int' does not satisfy 'C'}}
+}