Make store_as_base<Name,T> follow T's interface, closes #338

`store_as_base<Name, T>` should be echoing `T`s constructor interface:
- add a default constructor
- guard it and all the constructors with a `requires requires{ T{}; }` clause

Also, for a type that doesn't define any constructors, explicitly generate an =default'ed default constructor and =delete copy/move operations

Author: hsutter

include/cpp2util.h

@@ -647,9 +647,21 @@ class store_as_base
     T value;
 
 public:
-    store_as_base( T const& t    ) : value{t}                  { }
-    store_as_base( T     && t    ) : value{std::move(t)}       { }
-    store_as_base( auto  && args ) : value{CPP2_FORWARD(args)} { }
+    store_as_base()
+        requires requires { T{ }; }
+        : value{ } { }
+
+    store_as_base( T const& t )
+        requires requires { T{t}; }
+        : value{t} { }
+
+    store_as_base( T && t )
+        requires requires { T{std::move(t)}; }
+        : value{std::move(t)} { }
+
+    store_as_base( auto  && args )
+        requires requires { T{CPP2_FORWARD(args)}; }
+        : value{CPP2_FORWARD(args)} { }
 
     auto value__()       -> T      & { return value; }
     auto value__() const -> T const& { return value; }

regression-tests/test-results/pure2-type-and-namespace-aliases.cpp

@@ -30,7 +30,7 @@ class myclass {
     public: using str = std::string;
 
     private: using str2 = std::string;
-};
+public: myclass() = default; myclass(myclass const&) = delete; auto operator=(myclass const&) -> void = delete; };
 
 namespace N3 = ::std::literals;
 

regression-tests/test-results/pure2-types-basics.cpp

@@ -53,7 +53,7 @@ class myclass {
 
     public: class nested {
         public: static auto g() -> void;
-    };
+public: nested() = default; nested(nested const&) = delete; auto operator=(nested const&) -> void = delete; };
 
     public: template<typename T, typename U> [[nodiscard]] static auto f1(T const& t, U const& u) -> auto;
     public: template<typename T, typename U> [[nodiscard]] static auto f2(T const& t, U const& u) -> auto;

regression-tests/test-results/pure2-types-order-independence-and-nesting.cpp

@@ -69,8 +69,8 @@ namespace M {
 template<typename T, typename U> class A {
     public: template<int I> class B {
         public: template<typename V, int J, typename W> static auto f(W const& w) -> void;
-    };
-};
+public: B() = default; B(B const&) = delete; auto operator=(B const&) -> void = delete; };
+public: A() = default; A(A const&) = delete; auto operator=(A const&) -> void = delete; };
 
 }
 

source/cppfront.cpp

@@ -4898,8 +4898,9 @@ class cppfront
 
             //  Type definition
 
-            auto separator    = std::string{":"};
-            auto started_body = false;
+            auto separator         = std::string{":"};
+            auto started_body      = false;
+            auto found_constructor = false;
             assert(compound_stmt);
 
             for (auto& stmt : compound_stmt->statements)
@@ -4916,6 +4917,10 @@ class cppfront
                 auto& decl = std::get<statement_node::declaration>(stmt->statement);
                 assert(decl);
 
+                if (decl->is_constructor()) {
+                    found_constructor = true;
+                }
+
                 //  First we'll encounter the base types == subobjects named "this"
                 //  and any data members declared before them that we push into private bases
                 assert(decl->name());
@@ -4959,15 +4964,30 @@ class cppfront
             }
 
             //  Ensure we emit the { even if there are only bases in the type
-            if (
-                printer.get_phase() == printer.phase1_type_defs_func_decls
-                && !started_body
-                )
+            if (printer.get_phase() == printer.phase1_type_defs_func_decls)
             {
-                printer.print_cpp2(" {", compound_stmt->position());
-            }
+                if (!started_body) {
+                    printer.print_cpp2(" {", compound_stmt->position());
+                }
+
+                //  If there no constructor was defined, there shoudl only be
+                //  a default constructor, so generate that and disable copy/move
+                if (!found_constructor) {
+                    auto id = print_to_string(*n.identifier);
+                    printer.print_cpp2(
+                        "public: " + id + "() = default; ",
+                        compound_stmt->position()
+                    );
+                    printer.print_cpp2(
+                        "" + id + "(" + id + " const&) = delete; ",
+                        compound_stmt->position()
+                    );
+                    printer.print_cpp2(
+                        "auto operator=(" + id + " const&) -> void = delete; ",
+                        compound_stmt->position()
+                    );
+                }
 
-            if (printer.get_phase() == printer.phase1_type_defs_func_decls) {
                 printer.print_cpp2("};\n", compound_stmt->close_brace);
             }
         }