fct addition(int8 a, b) <- int16 result:
    result := a + b
end

int16 add
add := addition(10, 30)

fct allocation(int8 size) <- 'ptr' int8 result:
    result := alloc(size)
end

'ptr' int8 mem
mem := allocation(250)

template<typename T, typename... Types>
void print (T t, Types... args)
{
  std::cout << t << '\n';
  if constexpr (sizeof...(args) > 0)
    print (args...);
}

int main ()
{
  print ('a', "foo", 42);
}

template<typename... Types>
void print (Types... args)
{
  std::cout << args...[0] << '\n';
}

int main ()
{
  print ('a', "foo", 42);
}

struct S { int a, b; };

void
g (S& s)
{
  auto [ a, b [[gnu::deprecated]] ] = s;
}

void oldfn(char *) = delete("unsafe, use newfn");
void newfn(char *);

void g ()
{
  oldfn ("bagel");
}

q.C: In function ‘void g()’:
q.C:7:9: error: use of deleted function ‘void oldfn(char*)’: unsafe, use newfn
7 |   oldfn ("bagel");
  |   ~~~~~~^~~~~~~~~
q.C:1:6: note: declared here
1 | void oldfn(char *) = delete("unsafe, use newfn");
  |      ^~~~~

template<class... Ts>
class Foo {
  friend Ts...;
};

template<typename... Ts>
class Passkey {
  friend Ts...;
  Passkey() {}
};

class A;
class B;

struct Widget {
  // Only callable from A and B.
  void secret (Passkey<A, B>);
};

class A {
  void doit (Widget& w) {
    w.secret ({}); // OK
  }
};

class B {
  void doit (Widget& w) {
    w.secret ({}); // OK
  }
};

class D {
  void doit (Widget& w) {
    w.secret ({}); // won't compile!
  }
};

constexpr void use (int *) { }

constexpr int
foo ()
{
  auto *p = new int[]{1, 2, 3};
  use (p);
  delete[] p;
  return 1;
}

int main ()
{
  constexpr auto r = foo ();
}

#include <memory>

constexpr int foo ()
{
  std::allocator<int> alloc;
  auto p = alloc.allocate (16);
  new (p) int(42);
  alloc.deallocate (p, 16);
  return 1;
}

int main ()
{
  constexpr int r = foo ();
}

struct S {
  int a, b;
  explicit operator bool () const noexcept { return a != b; }
};
void use (int, int);

void g (S s)
{
  if (auto [ a, b ] = s)
    use (a, b);
}

struct S;

void foo (S *p)
{
  delete p;
}

void d_depr(auto......); // deprecated
void d_okay(auto..., ...);  // OK

void g_depr(int...);     // deprecated
void g_okay(int, ...);   // OK

void h_depr(int x...);   // deprecated
void h_okay(int x, ...); // OK

int arr1[5];
int arr2[5];
bool same = arr1 == arr2;

enum class E { Smashing, Pumpkins };
void foo() {
  using E::Smashing;
  using E::Smashing;
  using E::Pumpkins;
}

#include <compare>

struct C {
  long long i : 8;
};

void f() {
  C x{1}, y{2};
  x.i <=> y.i; // OK
}

template<bool B> struct X {
  static void f(short) requires B; // #1
  static void f(short);            // #2
};
void test() {
  auto x = &X<true>::f;     // OK, deduces void(*)(short), selects #1
  auto y = &X<false>::f;    // OK, deduces void(*)(short), selects #2
}