clang/test/SemaTemplate/alias-template-with-lambdas.cpp

   1 // RUN: %clang_cc1 -std=c++2c -fsyntax-only -verify %s
   2 namespace lambda_calls {
   3
   4 template <class>
   5 concept True = true;
   6
   7 template <class>
   8 concept False = false; // #False
   9
  10 template <class T> struct S {
  11   template <class... U> using type = decltype([](U...) {}(U()...));
  12   template <class U> using type2 = decltype([](auto) {}(1));
  13   template <class U> using type3 = decltype([](True auto) {}(1));
  14   template <class>
  15   using type4 = decltype([](auto... pack) { return sizeof...(pack); }(1, 2));
  16
  17   template <class U> using type5 = decltype([](False auto...) {}(1)); // #Type5
  18
  19   template <class U>
  20   using type6 = decltype([]<True> {}.template operator()<char>());
  21   template <class U>
  22   using type7 = decltype([]<False> {}.template operator()<char>()); // #Type7
  23
  24   template <class U>
  25   using type8 = decltype([]() // #Type8
  26                            requires(sizeof(U) == 32) // #Type8-requirement
  27                          {}());
  28
  29   template <class... U>
  30   using type9 = decltype([]<True>(U...) {}.template operator()<char>(U()...));
  31   // https://github.com/llvm/llvm-project/issues/76674
  32   template <class U>
  33   using type10 = decltype([]<class V> { return V(); }.template operator()<U>());
  34
  35   template <class U> using type11 = decltype([] { return U{}; });
  36 };
  37
  38 template <class> using Meow = decltype([]<True> {}.template operator()<int>());
  39
  40 template <class... U>
  41 using MeowMeow = decltype([]<True>(U...) {}.template operator()<char>(U()...));
  42
  43 // https://github.com/llvm/llvm-project/issues/70601
  44 template <class> using U = decltype([]<True> {}.template operator()<int>());
  45
  46 U<int> foo();
  47
  48 void bar() {
  49   using T = S<int>::type<int, int, int>;
  50   using T2 = S<int>::type2<int>;
  51   using T3 = S<int>::type3<char>;
  52   using T4 = S<int>::type4<void>;
  53   using T5 = S<int>::type5<void>; // #T5
  54   // expected-error@#Type5 {{no matching function for call}}
  55   // expected-note@#T5 {{type alias 'type5' requested here}}
  56   // expected-note@#Type5 {{constraints not satisfied [with auto:1 = <int>]}}
  57   // expected-note@#Type5 {{because 'int' does not satisfy 'False'}}
  58   // expected-note@#False {{because 'false' evaluated to false}}
  59
  60   using T6 = S<int>::type6<void>;
  61   using T7 = S<int>::type7<void>; // #T7
  62   // expected-error@#Type7 {{no matching member function for call}}
  63   // expected-note@#T7 {{type alias 'type7' requested here}}
  64   // expected-note@#Type7 {{constraints not satisfied [with $0 = char]}}
  65   // expected-note@#Type7 {{because 'char' does not satisfy 'False'}}
  66   // expected-note@#False {{because 'false' evaluated to false}}
  67
  68   using T8 = S<int>::type8<char>; // #T8
  69   // expected-error@#Type8 {{no matching function for call}}
  70   // expected-note@#T8 {{type alias 'type8' requested here}}
  71   // expected-note@#Type8 {{constraints not satisfied}}
  72   // expected-note@#Type8-requirement {{because 'sizeof(char) == 32' (1 == 32) evaluated to false}}
  73
  74   using T9 = S<int>::type9<long, long, char>;
  75   using T10 = S<int>::type10<int>;
  76   using T11 = S<int>::type11<int>;
  77   int x = T11()();
  78   using T12 = Meow<int>;
  79   using T13 = MeowMeow<char, int, long, unsigned>;
  80
  81   static_assert(__is_same(T, void));
  82   static_assert(__is_same(T2, void));
  83   static_assert(__is_same(T3, void));
  84   static_assert(__is_same(T4, decltype(sizeof(0))));
  85   static_assert(__is_same(T6, void));
  86   static_assert(__is_same(T9, void));
  87   static_assert(__is_same(T10, int));
  88   static_assert(__is_same(T12, void));
  89   static_assert(__is_same(T13, void));
  90 }
  91
  92 namespace GH82104 {
  93
  94 template <typename, typename... D> constexpr int Value = sizeof...(D);
  95
  96 template <typename T, typename... U>
  97 using T14 = decltype([]<int V = 0>(auto Param) {
  98   return Value<T, U...> + V + (int)sizeof(Param);
  99 }("hello"));
 100
 101 template <typename T> using T15 = T14<T, T>;
 102
 103 static_assert(__is_same(T15<char>, int));
 104
 105 // FIXME: This still crashes because we can't extract template arguments T and U
 106 // outside of the instantiation context of T16.
 107 #if 0
 108 template <typename T, typename... U>
 109 using T16 = decltype([](auto Param) requires (sizeof(Param) != 1 && sizeof...(U) > 0) {
 110   return Value<T, U...> + sizeof(Param);
 111 });
 112 static_assert(T16<int, char, float>()(42) == 2 + sizeof(42));
 113 #endif
 114 } // namespace GH82104
 115
 116 namespace GH89853 {
 117
 118 template <typename = void>
 119 static constexpr auto innocuous = []<int m> { return m; };
 120
 121 template <auto Pred = innocuous<>>
 122 using broken = decltype(Pred.template operator()<42>());
 123
 124 broken<> *boom;
 125
 126 template <auto Pred =
 127               []<char c> {
 128                 (void)static_cast<char>(c);
 129               }>
 130 using broken2 = decltype(Pred.template operator()<42>());
 131
 132 broken2<> *boom2;
 133
 134 template <auto Pred = []<char m> { return m; }>
 135 using broken3 = decltype(Pred.template operator()<42>());
 136
 137 broken3<> *boom3;
 138
 139 static constexpr auto non_default = []<char c>(True auto) {
 140     (void) static_cast<char>(c);
 141 };
 142
 143 template<True auto Pred>
 144 using broken4 = decltype(Pred.template operator()<42>(Pred));
 145
 146 broken4<non_default>* boom4;
 147
 148 } // namespace GH89853
 149
 150 namespace GH105885 {
 151
 152 template<int>
 153 using test = decltype([](auto...) {
 154 }());
 155
 156 static_assert(__is_same(test<0>, void));
 157
 158 } // namespace GH105885
 159
 160 namespace GH102760 {
 161
 162 auto make_tuple = []< class Tag, class... Captures>(Tag, Captures...) {
 163   return []< class _Fun >( _Fun) -> void requires requires { 0; }
 164   {};
 165 };
 166
 167 template < class, class... _As >
 168 using Result = decltype(make_tuple(0)(_As{}...));
 169
 170 using T = Result<int, int>;
 171
 172 } // namespace GH102760
 173
 174 } // namespace lambda_calls