clang/test/AST/Interp/lambda.cpp

   1 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify -std=c++20 %s
   2 // RUN: %clang_cc1 -verify=ref -std=c++20 %s
   3
   4 constexpr int a = 12;
   5 constexpr int f = [c = a]() { return c; }();
   6 static_assert(f == a);
   7
   8
   9 constexpr int inc() {
  10   int a = 10;
  11   auto f = [&a]() {
  12     ++a;
  13   };
  14
  15   f();f();
  16
  17   return a;
  18 }
  19 static_assert(inc() == 12);
  20
  21 constexpr int add(int a, int b) {
  22   auto doIt = [a, b](int c) {
  23     return a + b + c;
  24   };
  25
  26   return doIt(2);
  27 }
  28 static_assert(add(4, 5) == 11);
  29
  30
  31 constexpr int add2(int a, int b) {
  32   auto doIt = [a, b](int c) {
  33     auto bar = [a]() { return a; };
  34     auto bar2 = [b]() { return b; };
  35
  36     return bar() + bar2() + c;
  37   };
  38
  39   return doIt(2);
  40 }
  41 static_assert(add2(4, 5) == 11);
  42
  43
  44 constexpr int div(int a, int b) {
  45   auto f = [=]() {
  46     return a / b; // expected-note {{division by zero}} \
  47                   // ref-note {{division by zero}}
  48   };
  49
  50   return f(); // expected-note {{in call to '&f->operator()()'}} \
  51               // ref-note {{in call to 'f.operator()()'}}
  52 }
  53 static_assert(div(8, 2) == 4);
  54 static_assert(div(8, 0) == 4); // expected-error {{not an integral constant expression}} \
  55                                // expected-note {{in call to 'div(8, 0)'}} \
  56                                // ref-error {{not an integral constant expression}} \
  57                                // ref-note {{in call to 'div(8, 0)'}}
  58
  59
  60 struct F {
  61   float f;
  62 };
  63
  64 constexpr float captureStruct() {
  65   F someF = {1.0};
  66
  67   auto p = [someF]() {
  68     return someF.f;
  69   };
  70
  71   return p();
  72 }
  73
  74 static_assert(captureStruct() == 1.0);
  75
  76
  77 int constexpr FunCase() {
  78     return [x = 10] {
  79        decltype(x) y; // type int b/c not odr use
  80                       // refers to original init-capture
  81        auto &z = x; // type const int & b/c odr use
  82                      // refers to lambdas copy of x
  83         y = 10; // Ok
  84         //z = 10; // Ill-formed
  85         return y;
  86     }();
  87 }
  88
  89 constexpr int WC = FunCase();
  90
  91
  92 namespace LambdaParams {
  93   template<typename T>
  94   constexpr void callThis(T t) {
  95     return t();
  96   }
  97
  98   constexpr int foo() {
  99     int a = 0;
 100     auto f = [&a]() { ++a; };
 101
 102     callThis(f);
 103
 104     return a;
 105   }
 106   static_assert(foo() == 1);
 107 }
 108
 109 namespace StaticInvoker {
 110   constexpr int sv1(int i) {
 111     auto l = []() { return 12; };
 112     int (*fp)() = l;
 113     return fp();
 114   }
 115   static_assert(sv1(12) == 12);
 116
 117   constexpr int sv2(int i) {
 118     auto l = [](int m, float f, void *A) { return m; };
 119     int (*fp)(int, float, void*) = l;
 120     return fp(i, 4.0f, nullptr);
 121   }
 122   static_assert(sv2(12) == 12);
 123
 124   constexpr int sv3(int i) {
 125     auto l = [](int m, const int &n) { return m; };
 126     int (*fp)(int, const int &) = l;
 127     return fp(i, 3);
 128   }
 129   static_assert(sv3(12) == 12);
 130
 131   constexpr int sv4(int i) {
 132     auto l = [](int &m) { return m; };
 133     int (*fp)(int&) = l;
 134     return fp(i);
 135   }
 136   static_assert(sv4(12) == 12);
 137
 138   constexpr int sv5(int i) {
 139     struct F { int a; float f; };
 140     auto l = [](int m, F f) { return m; };
 141     int (*fp)(int, F) = l;
 142     return fp(i, F{12, 14.0});
 143   }
 144   static_assert(sv5(12) == 12);
 145
 146   constexpr int sv6(int i) {
 147     struct F { int a;
 148       constexpr F(int a) : a(a) {}
 149     };
 150
 151     auto l = [](int m) { return F(12); };
 152     F (*fp)(int) = l;
 153     F f = fp(i);
 154
 155     return fp(i).a;
 156   }
 157   static_assert(sv6(12) == 12);
 158 }
 159
 160 namespace LambdasAsParams {
 161   template<typename F>
 162   constexpr auto call(F f) {
 163     return f();
 164   }
 165   static_assert(call([](){ return 1;}) == 1);
 166   static_assert(call([](){ return 2;}) == 2);
 167
 168
 169   constexpr unsigned L = call([](){ return 12;});
 170   static_assert(L == 12);
 171
 172
 173   constexpr float heh() {
 174     auto a = []() {
 175       return 1.0;
 176     };
 177
 178     return static_cast<float>(a());
 179   }
 180   static_assert(heh() == 1.0);
 181 }
 182
 183 namespace ThisCapture {
 184   class Foo {
 185   public:
 186     int b = 32;
 187     int a;
 188
 189     constexpr Foo() : a([this](){ return b + 1;}()) {}
 190
 191     constexpr int Aplus2() const {
 192       auto F = [this]() {
 193         return a + 2;
 194       };
 195
 196       return F();
 197     }
 198   };
 199   constexpr Foo F;
 200   static_assert(F.a == 33, "");
 201   static_assert(F.Aplus2() == (33 + 2), "");
 202 }