[BUG] `@basic_value` default constructor is not `implicit`

[JohelEGP]

Title: @basic_value default constructor is not implicit.

Description:

We expect a value to be assignable from an empty argument list, like x = ().

Minimal reproducer (https://cpp2.godbolt.org/z/ahM4Pcdbq):

t: @basic_value type = { }
u: type = {
  a: t = ();
  operator=: (out this, x: i32) = _ = x;
}
main: () = { }

Commands:

cppfront main.cpp2
clang++17 -std=c++23 -stdlib=libc++ -lc++abi -pedantic-errors -Wall -Wextra -Wconversion -I . main.cpp

Expected result: public: t();

Actual result and error: public: explicit t();

Cpp2 lowered to Cpp1:

//=== Cpp2 type declarations ====================================================


#include "cpp2util.h"

class t;
class u;
  

//=== Cpp2 type definitions and function declarations ===========================

class t {
public: t(t const& that);

public: auto operator=(t const& that) -> t& ;
public: t(t&& that) noexcept;
public: auto operator=(t&& that) noexcept -> t& ;
public: explicit t();

};
class u {
  private: t a {}; 
  public: explicit u(cpp2::in<cpp2::i32> x);
  public: auto operator=(cpp2::in<cpp2::i32> x) -> u& ;

  public: u(u const&) = delete; /* No 'that' constructor, suppress copy */
  public: auto operator=(u const&) -> void = delete;
};
auto main() -> int;


//=== Cpp2 function definitions =================================================



t::t(t const& that){}
auto t::operator=(t const& that) -> t& {
                                return *this;}
t::t(t&& that) noexcept{}
auto t::operator=(t&& that) noexcept -> t& {
                                return *this;}
t::t(){}
  u::u(cpp2::in<cpp2::i32> x) { (void) x;  }
  auto u::operator=(cpp2::in<cpp2::i32> x) -> u&  { 
                                  a = {};
  (void) x;
                                  return *this;
   }

auto main() -> int{}

Output:

main.cpp2:5:37: error: no viable overloaded '='
    5 |                                   a = {};
      |                                   ~ ^ ~~

[JohelEGP]

I noticed that this happens to work (https://cpp2.godbolt.org/z/Wof3Gfsd7):

t: @basic_value type = {
  x: i32 = ();
  operator=: (out this, y: i32) = _ = y;
  // private operator=: (inout this, y: i32) = _ = y;
}
u: type = {
  a: t = ();
  operator=: (out this, x: i32) = _ = x;
}
main: () = { }

And it's because it actually invokes the "explicit" assignment (#468 (comment)).
If we uncomment the commented line to opt-out of it (#468 (comment)),
then Clang's error message makes it evident:

main.cpp2:9:37: error: 'operator=' is a private member of 't'
    9 |                                   a = {};
      |                                   ~ ^ ~~

This is similar to #487's quote of #451 (comment).

[JohelEGP]

See https://cpp2.godbolt.org/z/8fE3sGxvn:

• Such types still model std::semiregular.
• The fix probably is to explicitly write operator=: (inout this, _: i32) = a = _;.
• Having the NSDMI be t() also "fixes" it, but can introduce performance regressions (just like [BUG] The meaning of operator= with multiple non-this parameters #451).
  • This easier "fix" reminds me of the discussion at [BUG] move-assignment operators defaulting to memberwise semantics makes it impossible to cleanup old value #475 on the complexity of what's going on with the SMFs.

[JohelEGP]

But aggregates of basic_values with the generated default constructor
can't be value initialized or initialized from an empty list (https://cpp2.godbolt.org/z/f76WbYv4P):

t: @basic_value type = { }
u: @struct type = {
  a: t;
}
main: () = {
  _ = :u = ();
}

main.cpp2:6:23: error: chosen constructor is explicit in copy-initialization
    6 |   static_cast<void>(u{});
      |                       ^
main.cpp2:9:4: note: explicit constructor declared here
    9 | t::t(){}
      |    ^
main.cpp2:3:13: note: in implicit initialization of field 'a' with omitted initializer
    3 |   public: t a; 
      |             ^
1 error generated.