Add lambda testsuite (#423)

Author: lucic71

cpp2rust/converter/converter.cpp

@@ -1951,8 +1951,10 @@ Converter::CallInfo Converter::CollectCallInfo(clang::CallExpr *expr) {
       proto = ptr_ty->getPointeeType()->getAs<clang::FunctionProtoType>();
     }
   }
-  assert((function || proto) &&
-         "Either function decl or function prototype should be known");
+  if (!function && !proto) {
+    llvm::report_fatal_error(
+        "Either function decl or function prototype should be known");
+  }
 
   unsigned num_args = expr->getNumArgs() - arg_begin;
   unsigned num_named_params =

cpp2rust/converter/converter_lib.cpp

@@ -10,6 +10,7 @@
 #include <clang/Basic/SourceManager.h>
 #include <clang/Sema/Initialization.h>
 #include <clang/Sema/Sema.h>
+#include <llvm/Support/ErrorHandling.h>
 #include <llvm/Support/Path.h>
 #include <llvm/Support/raw_ostream.h>
 
@@ -769,7 +770,10 @@ std::string GetNamedDeclAsString(const clang::NamedDecl *decl) {
 
   if (name.empty()) {
     auto *pdecl = llvm::dyn_cast<clang::ParmVarDecl>(decl);
-    assert(pdecl && "Unexpected unnamed construct");
+    if (!pdecl) {
+      decl->dump();
+      llvm::report_fatal_error("Unexpected unnamed construct");
+    }
 
     const auto *fn =
         llvm::dyn_cast<clang::FunctionDecl>(pdecl->getDeclContext());

tests/unit/lambda_as_field.cpp

@@ -0,0 +1,46 @@
+// ADDITIONAL_COMPILE_FLAGS: -std=c++23
+// no-compile
+#include <assert.h>
+
+template <typename F> struct Guard {
+  F f;
+  ~Guard() { f(); }
+};
+
+template <typename F> struct Holder {
+  F f;
+  int calls;
+  int call(int x) {
+    calls++;
+    return f(x);
+  }
+};
+
+template <typename T> auto wrap(T fn) {
+  return [fn](int x) { return fn(x) + 1; };
+}
+
+int main() {
+  int cleaned = 0;
+  {
+    Guard g{[&cleaned]() { cleaned++; }};
+    assert(cleaned == 0);
+  }
+  assert(cleaned == 1);
+
+  int factor = 3;
+  Holder h{[factor](int x) { return x * factor; }, 0};
+  factor = 100;
+  assert(h.call(2) == 6);
+  assert(h.call(5) == 15);
+  assert(h.calls == 2);
+
+  auto w = wrap([factor](int x) { return x * factor; });
+  factor = 7;
+  assert(w(2) == 201);
+
+  auto ww = wrap(w);
+  assert(ww(2) == 202);
+
+  return 0;
+}

tests/unit/lambda_as_template_argument.cpp

@@ -0,0 +1,28 @@
+// translation-fail
+#include <assert.h>
+
+template <typename F> int apply_int(F fn, int x) { return fn(x); }
+
+template <typename F> double apply_double(F fn, double x) { return fn(x); }
+
+template <typename F> int apply_twice(F fn, int x) { return fn(fn(x)); }
+
+int main() {
+  int factor = 3;
+  auto scale = [factor](int x) { return x * factor; };
+  assert(apply_twice(scale, 4) == 36);
+
+  assert(apply_int([](int x) { return -x; }, 9) == -9);
+
+  auto generic_scale = [factor](auto x) { return x * factor; };
+  assert(apply_int(generic_scale, 4) == 12);
+  assert(apply_double(generic_scale, 1.5) == 4.5);
+
+  assert(apply_int([](auto x) { return -x; }, 9) == -9);
+
+  auto offset = [factor]<typename T>(T x) { return x + factor; };
+  assert(apply_int(offset, 4) == 7);
+  assert(apply_double(offset, 1.5) == 4.5);
+
+  return 0;
+}

tests/unit/lambda_basic.cpp

@@ -0,0 +1,14 @@
+#include <assert.h>
+
+int main() {
+  auto zero = []() { return 42; };
+  assert(zero() == 42);
+
+  auto one = [](int x) { return x + 1; };
+  assert(one(1) == 2);
+
+  auto three = [](int x, int y, int z) { return x * 100 + y * 10 + z; };
+  assert(three(1, 2, 3) == 123);
+
+  return 0;
+}

tests/unit/lambda_capture_copy_ctor.cpp

@@ -0,0 +1,58 @@
+// no-compile: refcount
+// panic: unsafe
+#include <assert.h>
+#include <utility>
+
+struct Counted {
+  int copies;
+  int moves;
+  Counted() : copies(0), moves(0) {}
+  Counted(const Counted &o) : copies(o.copies + 1), moves(o.moves) {}
+  Counted(Counted &&o) : copies(o.copies), moves(o.moves + 1) {}
+};
+
+int drops = 0;
+
+struct Dropped {
+  Dropped() {}
+  Dropped(const Dropped &) {}
+  Dropped(Dropped &&) {}
+  ~Dropped() { drops++; }
+};
+
+int main() {
+  Counted c;
+  auto f = [c]() { return c.copies * 10 + c.moves; };
+  assert(f() == 10);
+
+  auto g = f;
+  assert(g() == 20);
+  assert(f() == 10);
+
+  auto h = std::move(f);
+  assert(h() == 11);
+
+  int returned = [c]() { return c; }().copies;
+  assert(returned == 2);
+
+  Counted arr[2];
+  auto a = [arr]() { return arr[0].copies + arr[1].copies; };
+  assert(a() == 2);
+
+  auto a2 = a;
+  assert(a2() == 4);
+
+  {
+    auto m = [d = Dropped()]() {};
+    auto m2 = std::move(m);
+  }
+  assert(drops == 2);
+
+  {
+    auto k = [d = Dropped()]() {};
+    auto k2 = k;
+  }
+  assert(drops == 4);
+
+  return 0;
+}

tests/unit/lambda_capture_implicit.cpp

@@ -0,0 +1,27 @@
+// panic
+#include <assert.h>
+
+int main() {
+  int a = 1;
+  int b = 2;
+  int c = 3;
+
+  auto by_value = [=](int x) { return a + b + c + x; };
+  assert(by_value(10) == 16);
+  a = 100;
+  assert(by_value(10) == 16);
+
+  auto by_ref = [&](int x) { return a + b + c + x; };
+  assert(by_ref(10) == 115);
+  b = 200;
+  assert(by_ref(10) == 313);
+
+  auto mixed = [=, &c](int x) {
+    c += x;
+    return a + b + c;
+  };
+  assert(mixed(1) == 100 + 200 + 4);
+  assert(c == 4);
+
+  return 0;
+}

tests/unit/lambda_capture_pass.cpp

@@ -0,0 +1,51 @@
+// no-compile
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+
+struct S {
+  int x;
+  int y;
+};
+
+int main() {
+  int base = 10;
+  auto add_base = [&base](int x) { return x + base; };
+  assert(add_base(5) == 15);
+  base = 100;
+  assert(add_base(5) == 105);
+
+  S s = {1, 2};
+  auto sum = [&s]() { return s.x + s.y; };
+  assert(sum() == 3);
+  s.x = 50;
+  assert(sum() == 52);
+
+  int counter = 0;
+  auto bump = [&counter]() { counter++; };
+  bump();
+  bump();
+  assert(counter == 2);
+
+  uint16_t arr[4] = {3, 1, 2, 0};
+  auto swap = [&arr](size_t i, size_t j) {
+    uint16_t t = arr[j];
+    arr[j] = arr[i];
+    arr[i] = t;
+  };
+  swap(0, 3);
+  assert(arr[0] == 0);
+  assert(arr[3] == 3);
+
+  int total = 0;
+  auto add = [&t = total](int x) { t += x; };
+  add(2);
+  add(3);
+  assert(total == 5);
+
+  auto set_y = [&y = s.y](int v) { y = v; };
+  set_y(9);
+  assert(s.y == 9);
+
+  return 0;
+}

tests/unit/lambda_capture_ref.cpp

@@ -0,0 +1,43 @@
+// no-compile: refcount
+// panic: unsafe
+#include <assert.h>
+
+struct S {
+  int n;
+  int twice() const { return n * 2; }
+
+  int modify_copy() {
+    auto f = [*this]() mutable {
+      n += 10;
+      return n;
+    };
+    int r = f();
+    return r * 100 + n;
+  }
+
+  int snapshot() {
+    auto f = [*this]() { return twice(); };
+    n = 99;
+    return f();
+  }
+
+  int mixed(int k) {
+    auto f = [=, *this]() { return n + k; };
+    n = 0;
+    return f();
+  }
+};
+
+int main() {
+  S s = {1};
+  assert(s.modify_copy() == 1101);
+  assert(s.n == 1);
+
+  assert(s.snapshot() == 2);
+  assert(s.n == 99);
+
+  assert(s.mixed(1) == 100);
+  assert(s.n == 0);
+
+  return 0;
+}