[BUG] Non-implicit default constructor is implicit

[JohelEGP]

Title: Non-implicit default constructor is implicit.

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

t: type = {
  operator=: (out this) = { }
}
main: () = { }

Commands:

cppfront -clean-cpp1 main.cpp2
clang++17 -std=c++2b -stdlib=libc++ -lc++abi -I . main.cpp

Expected result:

public: explicit t();

Actual result and error:

public: t();

#include "cpp2util.h"

class t;
  
class t {
  public: t();

  public: t(t const&) = delete;
  public: auto operator=(t const&) -> void = delete;
};
auto main() -> int;

  t::t(){}

auto main() -> int{}

[gregmarr]

#375 (comment)

My intent was that explicit should just be the default for converting constructors, not for copy/move constructors.

I would assume that the default constructor would also not be explicit by default, just like copy/move.

[JohelEGP]

See also https://quuxplusone.github.io/blog/2023/04/08/most-ctors-should-be-explicit/.
It's also needed to implement <utility> types.

// [[pair.piecewise]](https://eel.is/c++draft/pair.piecewise), pair piecewise construction
  struct piecewise_construct_t {
    explicit piecewise_construct_t() = default;
  };
  inline constexpr piecewise_construct_t piecewise_construct{};
  template<class... Types> class tuple;         // defined in [<tuple>](https://eel.is/c++draft/tuple.syn#header:%3ctuple%3e)

  // in-place construction
  struct in_place_t {
    explicit in_place_t() = default;
  };
  inline constexpr in_place_t in_place{};

  template<class T>
    struct in_place_type_t {
      explicit in_place_type_t() = default;
    };
  template<class T> constexpr in_place_type_t<T> in_place_type{};

  template<size_t I>
    struct in_place_index_t {
      explicit in_place_index_t() = default;
    };
  template<size_t I> constexpr in_place_index_t<I> in_place_index{};

[JohelEGP]

See also https://quuxplusone.github.io/blog/2023/04/08/most-ctors-should-be-explicit/.

The most relevant passage is https://quuxplusone.github.io/blog/2023/04/08/most-ctors-should-be-explicit/#every-other-constructor-even-the:

Every other constructor (even the zero-argument constructor!) should be explicit or have a very well-understood domain-specific reason why not. Example: string(const char*).

[hsutter]

Interesting -- I wasn't familiar with explicit and default construction. This sounds right and I've changed it to emit explicit also for a non-implicit default constructor. Thanks!