// PR c++/91363 - P0960R3: Parenthesized initialization of aggregates.
// { dg-do run { target c++20 } }

// Test T[]().

int i;
int a1[](1, 2, 3);
static_assert(sizeof(a1) == 3 * sizeof (int), "");
int a2[](1.0, 2, 3);
static_assert(sizeof(a2) == 3 * sizeof (int), "");
int a3[3](1, 2, 3);
int a4[3](1, 2); // a4[2] is value-initialized.
int a5[](++i, ++i);
static_assert(sizeof(a5) == 2 * sizeof (int), "");
int a6[](1);
static_assert(sizeof(a6) == sizeof (int), "");
int a7[]({});
static_assert(sizeof(a7) == sizeof (int), "");
int a8[]({}, {}, {}, {}, {}, {});
static_assert(sizeof(a8) == 6 * sizeof (int), "");
int a9[]((1));
static_assert(sizeof(a9) == sizeof (int), "");
int a10[]((1), (2), (3));
static_assert(sizeof(a10) == 3 * sizeof (int), "");
int a11[][2]{1};
static_assert(sizeof(a11) == 2 * sizeof (int), "");
int a12[][2]({1, 2}, {3, 4});
static_assert(sizeof(a12) == 4 * sizeof (int), "");

const int (&ra1)[](1, 2);
const int (&ra2)[](1.0, 2);
const int (&ra3)[2](1.0, 2);
int (&&rra1)[](1, 2);
int (&&rra2)[](1.0, 2);
int (&&rra3)[2](1.0, 2);

struct S { int i; } s;
S s1[]({1});
static_assert(sizeof(s1) == sizeof (S), "");
S s2[]({1}, {2});
static_assert(sizeof(s2) == 2 * sizeof (S), "");
S s3[]({1}, {2}, {3});
static_assert(sizeof(s3) == 3 * sizeof (S), "");
S s4[3]({1}, {2});
static_assert(sizeof(s4) == 3 * sizeof (S), "");
S s5[]({++i}, {++i});
static_assert(sizeof(s2) == 2 * sizeof (S), "");
S s6[](s, s);

struct R { int i; int j; };
R r1[]({1, 2});
static_assert(sizeof(r1) == sizeof (R), "");
R r2[]({1, 2}, {3, 4});
static_assert(sizeof(r2) == 2 * sizeof (R), "");
R r3[]({1.0, 2}, {3.2, 4});
static_assert(sizeof(r3) == 2 * sizeof (R), "");

char c1[]('r');
char c2[]('r', 'a', 'c', 'c', 'o', 'o', 'n');
char c3[]("yarrow");
char c4[4]("oak");
char c5[10]("cat");
const char (&c6)[4]("eel");

int g;
struct X {
  int i;
  X() { ++g; }
  X(int) { };
};

int
main ()
{
  // Here we'll value-initialize l[1] and l[2], which will zero-initialize it.
  int l[3](42);
  if (l[0] != 42 || l[1] != 0 || l[2] != 0)
    __builtin_abort ();

  // Here we'll value-initialize x[2] and x[3].  Since X is a class type
  // with a user-provided ctor, we'll default-initialize in both cases.
  X x[4]({ 1 }, { 2 });
  if (g != 2)
    __builtin_abort ();

  if (a1[0] != 1 || a1[1] != 2 || a1[2] != 3)
    __builtin_abort ();
  if (a2[0] != 1 || a2[1] != 2 || a2[2] != 3)
    __builtin_abort ();
  if (a3[0] != 1 || a3[1] != 2 || a3[2] != 3)
    __builtin_abort ();
  if (a4[0] != 1 || a4[1] != 2 || a4[2] != 0)
    __builtin_abort ();
  if (a5[0] != 1 || a5[1] != 2)
    __builtin_abort ();
  if (a6[0] != 1)
    __builtin_abort ();
  if (a7[0] != 0)
    __builtin_abort ();
  if (a8[0] != 0 || a8[1] != 0 || a8[2] != 0 || a8[3] != 0
      || a8[4] != 0 || a8[5] != 0)
    __builtin_abort ();
  if (a9[0] != 1)
    __builtin_abort ();
  if (a10[0] != 1 || a10[1] != 2 || a10[2] != 3)
    __builtin_abort ();
  if (a11[0][0] != 1 || a11[0][1] != 0)
    __builtin_abort ();
  if (a12[0][0] != 1 || a12[0][1] != 2 || a12[1][0] != 3 || a12[1][1] != 4)
    __builtin_abort ();

  if (ra1[0] != 1 || ra1[1] != 2)
    __builtin_abort ();
  if (ra2[0] != 1 || ra2[1] != 2)
    __builtin_abort ();
  if (ra3[0] != 1 || ra3[1] != 2)
    __builtin_abort ();
  if (rra1[0] != 1 || rra1[1] != 2)
    __builtin_abort ();
  if (rra2[0] != 1 || rra2[1] != 2)
    __builtin_abort ();
  if (rra3[0] != 1 || rra3[1] != 2)
    __builtin_abort ();

  if (s1[0].i != 1)
    __builtin_abort ();
  if (s2[0].i != 1 || s2[1].i != 2)
    __builtin_abort ();
  if (s3[0].i != 1 || s3[1].i != 2 || s3[2].i != 3)
    __builtin_abort ();
  if (s4[0].i != 1 || s4[1].i != 2 || s4[2].i != 0)
    __builtin_abort ();
  if (s5[0].i != 3 || s5[1].i != 4)
    __builtin_abort ();

  if (r1[0].i != 1 || r1[0].j != 2)
    __builtin_abort ();
  if (r2[0].i != 1 || r2[0].j != 2 || r2[1].i != 3 || r2[1].j != 4)
    __builtin_abort ();
  if (r3[0].i != 1 || r3[0].j != 2 || r3[1].i != 3 || r3[1].j != 4)
    __builtin_abort ();
}