Inconsistency with std::vector constructors due to braced-init-list

[bluetarpmedia]

The following Cpp2:

main: () = {
    v1: std::vector<std::string> = (10, "abc");
    v2: std::vector<std::string> = (10);
    v3: std::vector<int>         = (10, 1);
    v4: std::vector<int>         = (10);

    std::println("v1: {}", v1);
    std::println("v2: {}", v2);
    std::println("v3: {}", v3);
    std::println("v4: {}", v4);

    v5:= std::vector<int>(10, 1);
    v6:= std::vector<int>(10);

    std::println("v5: {}", v5);
    std::println("v6: {}", v6);
}

prints this to stdout:

v1: ["abc", "abc", "abc", "abc", "abc", "abc", "abc", "abc", "abc", "abc"]
v2: ["", "", "", "", "", "", "", "", "", ""]
v3: [10, 1]
v4: [10]
v5: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
v6: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

because of how cppfront emits the constructor calls in C++, which when able invokes the initializer list overload:

std::vector<std::string> v1 {10, "abc"};
std::vector<std::string> v2 {10};
std::vector<int>         v3 {10, 1};  // Calls initializer list overload
std::vector<int>         v4 {10};     // Calls initializer list overload

Repro on Godbolt.

Can this be improved to prevent the inconsistency and/or avoid ambiguity between a braced-init-list of integers and the two parameters for the vector constructor taking count and value?

---

One option would be for cppfront to lower the constructor calls using parens instead of braces, which means the following would now be consistent:

std::vector<std::string> v1 (10, "abc");  // ten "abc"s
std::vector<std::string> v2 (10);         // ten empty strings
std::vector<int>         v3 (10, 1);      // ten 1s
std::vector<int>         v4 (10);         // ten 0s

and then Cpp2 could offer an alternative syntax for a list of items that would be lowered to a C++ braced-init-list (or, see below, maybe something even better):

v: std::vector<int> = list(10, 1);  // placeholder name
                                    // lower to a C++ braced-init-list: {10, 1}

This seems similar to Rust's vec! macro:

let mut v = vec![10, 1];

But perhaps this is a good chance to fix some issues with C++'s initializer list and implement something like @tcbrindle's make_vector helper.

[tcbrindle]

In C++ you can also "explicitly" invoke an init-list constructor by saying e.g.

std::vector<int> vec({1, 2, 3});

In a similar vein, perhaps something like

v1: std::vector<int> = ({1, 2, 3});
v2:= std::vector<int>({4, 5, 6});

could be used in Cpp2? That is, if you want initialiser-list construction, you explicitly pass a list inside the regular constructor brackets

[bluetarpmedia]

Thanks, that's good to know!