clang/test/SemaTemplate/concepts-lambda.cpp

   1 // RUN: %clang_cc1 -std=c++20 -verify %s
   2 // RUN: %clang_cc1 -std=c++20 -verify %s -triple powerpc64-ibm-aix
   3
   4 namespace GH57945 {
   5   template<typename T>
   6     concept c = true;
   7
   8   template<typename>
   9     auto f = []() requires c<void> {
  10     };
  11
  12   void g() {
  13       f<int>();
  14   };
  15 }
  16
  17 namespace GH57945_2 {
  18   template<typename>
  19     concept c = true;
  20
  21   template<typename T>
  22     auto f = [](auto... args) requires c<T>  {
  23     };
  24
  25   template <typename T>
  26   auto f2 = [](auto... args)
  27     requires (sizeof...(args) > 0)
  28   {};
  29
  30   void g() {
  31       f<void>();
  32       f2<void>(5.0);
  33   }
  34 }
  35
  36 namespace GH57958 {
  37   template<class> concept C = true;
  38   template<int> constexpr bool v = [](C auto) { return true; }(0);
  39   int _ = v<0>;
  40 }
  41 namespace GH57958_2 {
  42   template<class> concept C = true;
  43   template<int> constexpr bool v = [](C auto...) { return true; }(0);
  44   int _ = v<0>;
  45 }
  46
  47 namespace GH57971 {
  48   template<typename>
  49     concept any = true;
  50
  51   template<typename>
  52     auto f = [](any auto) {
  53     };
  54
  55   using function_ptr = void(*)(int);
  56   function_ptr ptr = f<void>;
  57 }
  58
  59 // GH58368: A lambda defined in a concept requires we store
  60 // the concept as a part of the lambda context.
  61 namespace LambdaInConcept {
  62 using size_t = unsigned long;
  63
  64 template<size_t...Ts>
  65 struct IdxSeq{};
  66
  67 template <class T, class... Ts>
  68 concept NotLike = true;
  69
  70 template <size_t, class... Ts>
  71 struct AnyExcept {
  72   template <NotLike<Ts...> T> operator T&() const;
  73   template <NotLike<Ts...> T> operator T&&() const;
  74 };
  75
  76 template <class T>
  77   concept ConstructibleWithN = (requires {
  78                                 []<size_t I, size_t... Idxs>
  79                                 (IdxSeq<I, Idxs...>)
  80                                 requires requires { T{AnyExcept<I, T>{}}; }
  81                                 { }
  82                                 (IdxSeq<1,2,3>{});
  83     });
  84
  85 struct Foo {
  86   int i;
  87   double j;
  88   char k;
  89 };
  90
  91 static_assert(ConstructibleWithN<Foo>);
  92
  93 }
  94
  95 // GH60642 reported an assert being hit, make sure we don't assert.
  96 namespace GH60642 {
  97 template<auto Q> concept C = requires { Q.template operator()<float>(); };
  98 template<class> concept D = true;
  99 static_assert(C<[]<D>{}>);  // ok
 100 template<class> concept E = C<[]<D>{}>;
 101 static_assert(E<int>);  // previously Asserted.
 102
 103 // ensure we properly diagnose when "D" is false.
 104 namespace DIsFalse {
 105 template<auto Q> concept C = requires { Q.template operator()<float>(); };
 106 template<class> concept D = false;
 107 static_assert(C<[]<D>{}>);
 108 // expected-error@-1{{static assertion failed}}
 109 // expected-note@-2{{does not satisfy 'C'}}
 110 // expected-note@-5{{because 'Q.template operator()<float>()' would be invalid: no matching member function for call to 'operator()'}}
 111 template<class> concept E = C<[]<D>{}>;
 112 static_assert(E<int>);
 113 // expected-error@-1{{static assertion failed}}
 114 // expected-note@-2{{because 'int' does not satisfy 'E'}}
 115 // expected-note@-4{{does not satisfy 'C'}}
 116 // expected-note@-11{{because 'Q.template operator()<float>()' would be invalid: no matching member function for call to 'operator()'}}
 117 }
 118 }