clang/test/SemaCXX/cxx1z-lambda-star-this.cpp

   1 // RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -emit-llvm-only %s
   2 // RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -DDELAYED_TEMPLATE_PARSING
   3 // RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fms-extensions %s -DMS_EXTENSIONS
   4 // RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing -fms-extensions %s -DMS_EXTENSIONS -DDELAYED_TEMPLATE_PARSING
   5
   6 template <class, class>
   7 constexpr bool is_same = false;
   8 template <class T>
   9 constexpr bool is_same<T, T> = true;
  10
  11 namespace test_star_this {
  12 namespace ns1 {
  13 class A {
  14   int x = 345;
  15   auto foo() {
  16     (void)[ *this, this ]{}; //expected-error{{'this' can appear only once}}
  17     (void)[this] { ++x; };
  18     (void)[*this] { ++x; }; //expected-error{{read-only variable}}
  19     (void)[*this]() mutable { ++x; };
  20     (void)[=] { return x; };
  21     (void)[&, this ] { return x; };
  22     (void)[ =, *this ] { return x; };
  23     (void)[&, *this ] { return x; };
  24   }
  25 };
  26 } // namespace ns1
  27
  28 namespace ns2 {
  29 class B {
  30   B(const B &) = delete; //expected-note{{deleted here}}
  31   int *x = (int *)456;
  32   void foo() {
  33     (void)[this] { return x; };
  34     (void)[*this] { return x; }; //expected-error{{call to deleted}}
  35   }
  36 };
  37 } // namespace ns2
  38
  39 namespace ns3 {
  40 class B {
  41   B(const B &) = delete; //expected-note2{{deleted here}}
  42
  43   int *x = (int *)456;
  44
  45 public:
  46   template <class T = int>
  47   void foo() {
  48     (void)[this] { return x; };
  49     (void)[*this] { return x; }; //expected-error2{{call to deleted}} expected-note {{while substituting into a lambda}}
  50   }
  51
  52   B() = default;
  53 } b;
  54 B *c = (b.foo(), nullptr); //expected-note{{in instantiation}}
  55 } // namespace ns3
  56
  57 namespace ns4 {
  58 template <class U>
  59 class B {
  60   B(const B &) = delete; //expected-note{{deleted here}}
  61   double d = 3.14;
  62
  63 public:
  64   template <class T = int>
  65   auto foo() {
  66     const auto &L = [*this](auto a) mutable { //expected-error{{call to deleted}} expected-note {{while substituting into a lambda}}
  67       d += a;
  68       return [this](auto b) { return d += b; };
  69     };
  70   }
  71
  72   B() = default;
  73 };
  74 void main() {
  75   B<int *> b;
  76   b.foo(); //expected-note{{in instantiation}}
  77 } // end main
  78 } // namespace ns4
  79
  80 namespace ns5 {
  81
  82 struct X {
  83   double d = 3.14;
  84   X(const volatile X &);
  85   void foo() {
  86   }
  87
  88   void foo() const { //expected-note{{const}}
  89
  90     auto L = [*this]() mutable {
  91       static_assert(is_same<decltype(this), const X *>);
  92       auto M = [this] {
  93         static_assert(is_same<decltype(this), const X *>);
  94         auto N = [] {
  95           static_assert(is_same<decltype(this), const X *>);
  96         };
  97       };
  98     };
  99
 100     auto L1 = [*this] {
 101       static_assert(is_same<decltype(this), const X *>);
 102       auto M = [this]() mutable {
 103         static_assert(is_same<decltype(this), const X *>);
 104         auto N = [] {
 105           static_assert(is_same<decltype(this), const X *>);
 106         };
 107       };
 108       auto M2 = [*this]() mutable {
 109         static_assert(is_same<decltype(this), const X *>);
 110         auto N = [] {
 111           static_assert(is_same<decltype(this), const X *>);
 112         };
 113       };
 114     };
 115
 116     auto GL1 = [*this](auto a) {
 117       static_assert(is_same<decltype(this), const X *>);
 118       auto M = [this](auto b) mutable {
 119         static_assert(is_same<decltype(this), const X *>);
 120         auto N = [](auto c) {
 121           static_assert(is_same<decltype(this), const X *>);
 122         };
 123         return N;
 124       };
 125
 126       auto M2 = [*this](auto a) mutable {
 127         static_assert(is_same<decltype(this), const X *>);
 128         auto N = [](auto b) {
 129           static_assert(is_same<decltype(this), const X *>);
 130         };
 131         return N;
 132       };
 133       return [=](auto a) mutable { M(a)(a); M2(a)(a); };
 134     };
 135
 136     GL1("abc")
 137     ("abc");
 138
 139     auto L2 = [this]() mutable {
 140       static_assert(is_same<decltype(this), const X *>);
 141       ++d; //expected-error{{cannot assign}}
 142     };
 143     auto GL = [*this](auto a) mutable {
 144       static_assert(is_same<decltype(this), const X *>);
 145       auto M = [this](auto b) {
 146         static_assert(is_same<decltype(this), const X *>);
 147         auto N = [](auto c) {
 148           static_assert(is_same<decltype(this), const X *>);
 149         };
 150         N(3.14);
 151       };
 152       M("abc");
 153     };
 154     GL(3.14);
 155   }
 156   void foo() volatile const {
 157     auto L = [this]() {
 158       static_assert(is_same<decltype(this), const volatile X *>);
 159       auto M = [*this]() mutable {
 160         static_assert(is_same<decltype(this), const volatile X *>);
 161         auto N = [this] {
 162           static_assert(is_same<decltype(this), const volatile X *>);
 163           auto M = [] {
 164             static_assert(is_same<decltype(this), const volatile X *>);
 165           };
 166         };
 167         auto N2 = [*this] {
 168           static_assert(is_same<decltype(this), const volatile X *>);
 169         };
 170       };
 171       auto M2 = [*this]() {
 172         static_assert(is_same<decltype(this), const volatile X *>);
 173         auto N = [this] {
 174           static_assert(is_same<decltype(this), const volatile X *>);
 175         };
 176       };
 177     };
 178   }
 179 };
 180
 181 } // namespace ns5
 182 namespace ns6 {
 183 struct X {
 184   double d;
 185   auto foo() const {
 186     auto L = [*this]() mutable {
 187       auto M = [=](auto a) {
 188         auto N = [this] {
 189           static_assert(is_same<decltype(this), const X *>);
 190           auto O = [*this] {
 191             static_assert(is_same<decltype(this), const X *>);
 192           };
 193         };
 194         N();
 195         static_assert(is_same<decltype(this), const X *>);
 196       };
 197       return M;
 198     };
 199     return L;
 200   }
 201 };
 202
 203 int main() {
 204   auto L = X{}.foo();
 205   auto M = L();
 206   M(3.14);
 207 }
 208 } // namespace ns6
 209 namespace ns7 {
 210
 211 struct X {
 212   double d;
 213   X();
 214   X(const X &);
 215   X(X &) = delete;
 216   auto foo() const {
 217     //OK - the object used to initialize our capture is a const object and so prefers the non-deleted ctor.
 218     const auto &&L = [*this]{};
 219   }
 220 };
 221 int main() {
 222   X x;
 223   x.foo();
 224 }
 225 } // namespace ns7
 226
 227 } // namespace test_star_this
 228
 229 namespace PR32831 {
 230 // https://bugs.llvm.org/show_bug.cgi?id=32831
 231 namespace ns1 {
 232 template <typename Func>
 233 void fun_template(Func func) {
 234   (void)[&]() {
 235     func(0);
 236   };
 237 }
 238
 239 class A {
 240   void member_foo() {
 241     (void)[this] {
 242       (void)[this] {
 243         fun_template(
 244             [this](auto X) {
 245               auto L = [this](auto Y) { member_foo(); };
 246               L(5);
 247             });
 248         fun_template(
 249             [this](auto) { member_foo(); });
 250       };
 251     };
 252   }
 253 };
 254 } // namespace ns1
 255
 256 namespace ns2 {
 257
 258 struct B {
 259   int data = 0;
 260   template <class F>
 261   void mem2(F f) {
 262     (void)[&](auto f) {
 263       (void)[&] { f(this->data); };
 264     }
 265     (f);
 266   }
 267 };
 268
 269 class A {
 270   void member_foo() {
 271     (void)[this] {
 272       (void)[this] {
 273         B{}.mem2(
 274             [this](auto X) {
 275               auto L = [this](auto Y) { member_foo(); };
 276               L(5);
 277             });
 278         B{}.mem2(
 279             [this](auto) { member_foo(); });
 280       };
 281     };
 282   }
 283   int data = 0;
 284   auto m2() {
 285     return [this] { return [] () -> decltype(data){ return 0; }; };
 286   }
 287   auto m3() {
 288     return [] { return [] () -> decltype(data){ return 0; }; };
 289   }
 290 };
 291
 292 } // namespace ns2
 293
 294 } // namespace PR32831
 295
 296 namespace PR45881 {
 297 struct A {
 298     void f();
 299 };
 300 int id(A*);
 301 void A::f() {
 302     auto z = [*this](auto z2, decltype(z2(this)) z3){};
 303     z(id,3);
 304 }
 305 } // namespace PR45881
 306
 307
 308 namespace GH50866 {
 309 struct S;
 310
 311 void f(S *) = delete; // expected-note {{would lose const qualifier}}
 312 void f(const S *) = delete; // expected-note {{candidate function has been explicitly deleted}}
 313
 314 struct S {
 315   void g() const {
 316     [*this]() mutable { f(this); }(); // expected-error {{call to deleted function}}
 317   }
 318 };
 319
 320 void g() {
 321   S s{};
 322   s.g();
 323 }
 324 }