370 lines · cpp
1// RUN: %clang_cc1 -std=c++20 -verify %s2// RUN: %clang_cc1 -std=c++20 -verify %s -triple powerpc64-ibm-aix3 4namespace 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 17namespace 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 36namespace GH57958 {37 template<class> concept C = true;38 template<int> constexpr bool v = [](C auto) { return true; }(0);39 int _ = v<0>;40}41namespace 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 47namespace 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 store60// the concept as a part of the lambda context.61namespace LambdaInConcept {62using size_t = unsigned long;63 64template<size_t...Ts>65struct IdxSeq{};66 67template <class T, class... Ts>68concept NotLike = true;69 70template <size_t, class... Ts>71struct AnyExcept {72 template <NotLike<Ts...> T> operator T&() const;73 template <NotLike<Ts...> T> operator T&&() const;74};75 76template <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 85struct Foo {86 int i;87 double j;88 char k;89};90 91static_assert(ConstructibleWithN<Foo>);92 93namespace GH56556 {94 95template <typename It>96inline constexpr It declare ();97 98template <typename It, template <typename> typename Template>99concept D = requires {100 { [] <typename T1> (Template<T1> &) {}(declare<It &>()) };101};102 103template <typename T>104struct B {};105 106template <typename T>107struct Adapter;108 109template <D<B> T>110struct Adapter<T> {};111 112template struct Adapter<B<int>>;113 114} // namespace GH56556115 116namespace GH82849 {117 118template <class T>119concept C = requires(T t) {120 requires requires (T u) {121 []<class V>(V) {122 return requires(V v) {123 [](V w) {}(v);124 };125 }(t);126 };127};128 129template <class From>130struct Widget;131 132template <C F>133struct Widget<F> {134 static F create(F from) {135 return from;136 }137};138 139template <class>140bool foo() {141 return C<int>;142}143 144void bar() {145 // https://github.com/llvm/llvm-project/issues/49570#issuecomment-1664966972146 Widget<char>::create(0);147}148 149} // namespace GH82849150 151}152 153// GH60642 reported an assert being hit, make sure we don't assert.154namespace GH60642 {155template<auto Q> concept C = requires { Q.template operator()<float>(); };156template<class> concept D = true;157static_assert(C<[]<D>{}>); // ok158template<class> concept E = C<[]<D>{}>;159static_assert(E<int>); // previously Asserted.160 161// ensure we properly diagnose when "D" is false.162namespace DIsFalse {163template<auto Q> concept C = requires { Q.template operator()<float>(); };164template<class> concept D = false;165static_assert(C<[]<D>{}>);166// expected-error@-1{{static assertion failed}}167// expected-note@-2{{does not satisfy 'C'}}168// expected-note@-5{{because 'Q.template operator()<float>()' would be invalid: no matching member function for call to 'operator()'}}169template<class> concept E = C<[]<D>{}>;170static_assert(E<int>);171// expected-error@-1{{static assertion failed}}172// expected-note@-2{{because 'int' does not satisfy 'E'}}173// expected-note@-4{{does not satisfy 'C'}}174// expected-note@-11{{because 'Q.template operator()<float>()' would be invalid: no matching member function for call to 'operator()'}}175}176}177 178namespace ReturnTypeRequirementInLambda {179template <typename T>180concept C1 = true;181 182template <class T>183concept test = [] {184 return requires(T t) {185 { t } -> C1;186 };187}();188 189static_assert(test<int>);190 191template <typename T>192concept C2 = true;193struct S1 {194 int f1() { return 1; }195};196 197void foo() {198 auto make_caller = []<auto member> {199 return [](S1 *ps) {200 if constexpr (requires {201 { (ps->*member)() } -> C2;202 })203 ;204 };205 };206 207 auto caller = make_caller.operator()<&S1::f1>();208}209} // namespace ReturnTypeRequirementInLambda210 211namespace GH73418 {212void foo() {213 int x;214 [&x](auto) {215 return [](auto y) {216 return [](auto obj, auto... params)217 requires requires {218 sizeof...(params);219 [](auto... pack) {220 return sizeof...(pack);221 }(params...);222 }223 { return false; }(y);224 }(x);225 }(x);226}227} // namespace GH73418228 229namespace GH93821 {230 231template <class>232concept C = true;233 234template <class...>235concept D = []<C T = int>() { return true; }();236 237D auto x = 0;238 239} // namespace GH93821240 241namespace dependent_param_concept {242template <typename... Ts> void sink(Ts...) {}243void dependent_param() {244 auto L = [](auto... x) {245 return [](decltype(x)... y) {246 return [](int z)247 requires requires { sink(y..., z); }248 {};249 };250 };251 L(0, 1)(1, 2)(1);252}253} // namespace dependent_param_concept254 255namespace init_captures {256template <int N> struct V {};257 258void sink(V<0>, V<1>, V<2>, V<3>, V<4>) {}259 260void init_capture_pack() {261 auto L = [](auto... z) {262 return [=](auto... y) {263 return [... w = z, y...](auto)264 requires requires { sink(w..., y...); }265 {};266 };267 };268 L(V<0>{}, V<1>{}, V<2>{})(V<3>{}, V<4>{})(1);269}270 271void dependent_capture_packs() {272 auto L = [](auto... z) {273 return [... w = z](auto... y) {274 return [... c = w](auto)275 requires requires { sink(c..., y...); }276 {};277 };278 };279 L(V<0>{}, V<1>{}, V<2>{})(V<3>{}, V<4>{})(1);280}281} // namespace init_captures282 283namespace GH110721 {284 285template <int N> void connect() {286 int x = N, y = N;287 [x, y = y]()288 requires requires { x; }289 {}();290}291 292void foo() {293 connect<42>();294}295 296} // namespace GH110721297 298namespace GH123441 {299 300void test() {301 auto L = [](auto... x) {302 return [](decltype(x)... y)303 requires true304 {};305 };306 L(0, 1)(1, 2);307}308 309}310 311namespace GH128175 {312 313template <class> void f() {314 [i{0}] {315 [&] {316 [&] {317 []()318 requires true319 {}();320 }();321 }();322 }();323}324 325template void f<int>();326 327}328 329namespace GH133719 {330 331template <class T>332constexpr auto f{[] (auto arg) {333 return [a{arg}] {334 [] () requires true {}();335 };336}};337 338void foo() {339 f<int>(0);340}341 342}343 344namespace GH147772 {345 346template<int...>347struct seq {};348 349using arr = char[1];350 351struct foo {352 template<int... i>353 constexpr foo(seq<i...>) requires requires {354 arr { [](auto) requires(i, true) { return 0; }(i)... };355 } {}356};357 358constexpr auto bar = foo(seq<0>());359}360 361namespace GH147650 {362template <int> int b;363template <int b>364void f()365 requires requires { [] { (void)b; static_assert(b == 42); }; } {}366void test() {367 f<42>();368}369}370