[Bug c++/92812] Implement P1975R0: Fixing the wording of parenthesized aggregate-initialization

["cvs-commit at gcc dot gnu.org" <gcc-bugzilla@gcc.gnu.org>]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=92812

--- Comment #11 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by Marek Polacek <mpolacek@gcc.gnu.org>:

https://gcc.gnu.org/g:753b4679bc46f6806cf45d9afc3783c6d3b63589

commit r11-2999-g753b4679bc46f6806cf45d9afc3783c6d3b63589
Author: Marek Polacek <polacek@redhat.com>
Date:   Wed Aug 26 08:27:33 2020 -0400

    c++: Fix P0960 in member init list and array [PR92812]

    This patch nails down the remaining P0960 case in PR92812:

      struct A {
        int ar[2];
        A(): ar(1, 2) {} // doesn't work without this patch
      };

    Note that when the target object is not of array type, this already
    works:

      struct S { int x, y; };
      struct A {
        S s;
        A(): s(1, 2) { } // OK in C++20
      };

    because build_new_method_call_1 takes care of the P0960 magic.

    It proved to be quite hairy.  When the ()-list has more than one
    element, we can always create a CONSTRUCTOR, because the code was
    previously invalid.  But when the ()-list has just one element, it
    gets all kinds of difficult.  As usual, we have to handle a("foo")
    so as not to wrap the STRING_CST in a CONSTRUCTOR.  Always turning
    x(e) into x{e} would run into trouble as in c++/93790.  Another
    issue was what to do about x({e}): previously, this would trigger
    "list-initializer for non-class type must not be parenthesized".
    I figured I'd make this work in C++20, so that given

      struct S { int x, y; };

    you can do

       S a[2];
       [...]
       A(): a({1, 2}) // initialize a[0] with {1, 2} and a[1] with {}

    It also turned out that, as an extension, we support compound literals:

      F (): m((S[1]) { 1, 2 })

    so this has to keep working as before.  Moreover, make sure not to trigger
    in compiler-generated code, like =default, where array assignment is
allowed.

    I've factored out a function that turns a TREE_LIST into a CONSTRUCTOR
    to simplify handling of P0960.

    paren-init35.C also tests this with vector types.

    gcc/cp/ChangeLog:

            PR c++/92812
            * cp-tree.h (do_aggregate_paren_init): Declare.
            * decl.c (do_aggregate_paren_init): New.
            (grok_reference_init): Use it.
            (check_initializer): Likewise.
            * init.c (perform_member_init): Handle initializing an array from
            a ()-list.  Use do_aggregate_paren_init.

    gcc/testsuite/ChangeLog:

            PR c++/92812
            * g++.dg/cpp0x/constexpr-array23.C: Adjust dg-error.
            * g++.dg/cpp0x/initlist69.C: Likewise.
            * g++.dg/diagnostic/mem-init1.C: Likewise.
            * g++.dg/init/array28.C: Likewise.
            * g++.dg/cpp2a/paren-init33.C: New test.
            * g++.dg/cpp2a/paren-init34.C: New test.
            * g++.dg/cpp2a/paren-init35.C: New test.
            * g++.old-deja/g++.brendan/crash60.C: Adjust dg-error.
            * g++.old-deja/g++.law/init10.C: Likewise.
            * g++.old-deja/g++.other/array3.C: Likewise.