fix(cpp1): define static data member in the class body if possible

Author: JohelEGP

regression-tests/pure2-type-and-namespace-aliases.cpp2

@@ -33,3 +33,25 @@ main: () = {
     myfunc2 :== myfunc;
     myfunc2();
 }
+
+myclass5: type == myclass4;
+
+myclass3: @struct type = {
+    v0 :== :std::array = (0);;
+    v1: std::array == v0;
+    v2: myclass3 == :myclass3 = ();;
+    v3: _ == v0;
+    // v4 :== v2; // Not (yet) supported.
+    // v5: myclass4 == :myclass4 = ();; // Not yet supported.
+    // v6: myclass5 == :myclass5 = ();; // Not yet supported.
+    // v7 :== myclass3(); // Not (yet) supported.
+
+    // There's also a false positive:
+    // <https://github.com/hsutter/cppfront/issues/666#issuecomment-1722329609>.
+}
+
+myclass4: @struct type = { }
+
+myclass6: @struct <T: type> type = {
+    v: <U> _ requires true == 0;
+}

regression-tests/test-results/gcc-13/pure2-bugfix-for-non-local-function-expression.cpp.output

@@ -1 +1,3 @@
 pure2-bugfix-for-non-local-function-expression.cpp2:9:7: warning: ‘t’ has a base ‘t::<lambda()>’ which has no linkage [-Wsubobject-linkage]
+    9 | t: @struct type = {
+      |       ^

regression-tests/test-results/pure2-print.cpp

@@ -22,7 +22,7 @@ class outer {
     public: template<typename T> 
 CPP2_REQUIRES_ (true)
 #line 6 "pure2-print.cpp2"
-    static const T object_alias;
+    static constexpr T object_alias = 42;
 
     public: class mytype final
      {
@@ -90,12 +90,6 @@ auto main() -> int;
 //=== Cpp2 function definitions =================================================
 
 
-#line 6 "pure2-print.cpp2"
-    template<typename T> 
-requires (true)
-#line 6 "pure2-print.cpp2"
-    inline CPP2_CONSTEXPR T outer::object_alias = 42;
-
 #line 10 "pure2-print.cpp2"
         [[nodiscard]] auto outer::mytype::f() -> int { return 42;  }
 

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

@@ -20,6 +20,16 @@ class myclass;
 template<typename T> class myclass2;
 
 
+#line 39 "pure2-type-and-namespace-aliases.cpp2"
+class myclass3;
+    
+
+#line 53 "pure2-type-and-namespace-aliases.cpp2"
+class myclass4;
+
+template<typename T> class myclass6;
+    
+
 //=== Cpp2 type definitions and function declarations ===========================
 
 
@@ -49,7 +59,7 @@ auto myfunc() -> void;
 
 #line 25 "pure2-type-and-namespace-aliases.cpp2"
 template<typename T> class myclass2 {
-    public: static const int value;
+    public: static constexpr int value = 42;
 
     public: myclass2() = default;
     public: myclass2(myclass2 const&) = delete; /* No 'that' constructor, suppress copy */
@@ -60,6 +70,33 @@ template<typename T> class myclass2 {
 auto main() -> int;
 
 
+#line 37 "pure2-type-and-namespace-aliases.cpp2"
+using myclass5 = myclass4;
+
+class myclass3 {
+    public: static constexpr auto v0 = std::array{0};
+    public: static constexpr std::array v1 = v0;
+    public: static const myclass3 v2;
+    public: static constexpr auto v3 = v0;
+    // v4 :== v2; // Not (yet) supported.
+    // v5: myclass4 == :myclass4 = ();; // Not yet supported.
+    // v6: myclass5 == :myclass5 = ();; // Not yet supported.
+    // v7 :== myclass3(); // Not (yet) supported.
+
+    // There's also a false positive:
+    // <https://github.com/hsutter/cppfront/issues/666#issuecomment-1722329609>.
+};
+
+class myclass4 {};
+
+template<typename T> class myclass6 {
+    public: template<typename U> 
+CPP2_REQUIRES_ (true)
+#line 56 "pure2-type-and-namespace-aliases.cpp2"
+    static constexpr auto v = 0;
+};
+
+
 //=== Cpp2 function definitions =================================================
 
 
@@ -81,9 +118,6 @@ auto const& v2 = std::move(v);
 #line 23 "pure2-type-and-namespace-aliases.cpp2"
 }
 
-#line 26 "pure2-type-and-namespace-aliases.cpp2"
-    template <typename T> inline CPP2_CONSTEXPR int myclass2<T>::value = 42;
-
 #line 29 "pure2-type-and-namespace-aliases.cpp2"
 auto main() -> int{
     using view = std::string_view;
@@ -93,3 +127,7 @@ auto main() -> int{
     myfunc2();
 }
 
+#line 42 "pure2-type-and-namespace-aliases.cpp2"
+    inline CPP2_CONSTEXPR myclass3 myclass3::v2 = myclass3{};
+    
+

source/cppfront.cpp

@@ -4958,6 +4958,25 @@ class cppfront
     }
 
 
+    auto has_potentially_incomplete_type(
+        declaration_node const& n,
+        type_id_node const& t
+    )
+        -> bool
+    {
+        auto type_id = t.get_token();
+
+        if (!type_id) {
+            return false;
+        }
+
+        if (auto parent = n.get_parent()) {
+            return parent->name() && *type_id == *parent->name();
+        }
+
+        return false;
+    }
+
     //-----------------------------------------------------------------------
     //
     auto emit(
@@ -5072,8 +5091,19 @@ class cppfront
             auto& a = std::get<declaration_node::an_alias>(n.type);
             assert(a);
 
+            //  Helper for aliases that emit as a defining declaration.
+            auto const type_scope_object_alias_emits_in_phase_1_only = [&]() {
+                assert(
+                    n.parent_is_type()
+                    && n.is_object_alias()
+                );
+                return !a->type_id
+                       || a->type_id->is_wildcard()
+                       || !has_potentially_incomplete_type(n, *a->type_id);
+            };
+
             //  Namespace-scope aliases are emitted in phase 1,
-            //  type-scope object aliases in both phases 1 and 2, and
+            //  type-scope object aliases is emitted in phase 1 and maybe 2, and
             //  function-scope aliases in phase 2
             if (
                 (
@@ -5085,6 +5115,7 @@ class cppfront
                     n.parent_is_type()
                     && n.is_object_alias()
                     && printer.get_phase() == printer.phase2_func_defs
+                    && !type_scope_object_alias_emits_in_phase_1_only()
                     )
                 ||
                 (
@@ -5150,21 +5181,34 @@ class cppfront
                 //  Handle object aliases:
                 //      - at function scope, it's const&
                 //      - at namespace scope, it's inline constexpr
-                //      - at type scope, it's also inline constexpr but see note (*) below
+                //      - at type scope, it's also static constexpr but see note (*) below
                 else if (a->is_object_alias())
                 {
                     auto type = std::string{"auto"};
                     if (a->type_id) {
                         type = print_to_string(*a->type_id);
                     }
 
-                    //  (*) If this is at type scope, Cpp1 requires an out-of-line declaration dance
-                    //  for some cases to work - see https://stackoverflow.com/questions/11928089/
                     if (n.parent_is_type())
                     {
                         assert (n.parent_declaration->name());
 
-                        if (printer.get_phase() == printer.phase1_type_defs_func_decls) {
+                        if (type_scope_object_alias_emits_in_phase_1_only()) {
+                            if (printer.get_phase() == printer.phase1_type_defs_func_decls) {
+                                printer.print_cpp2(
+                                    "static constexpr "
+                                        + type + " "
+                                        + print_to_string(*n.identifier)
+                                        + " = "
+                                        + print_to_string( *std::get<alias_node::an_object>(a->initializer) )
+                                        + ";\n",
+                                    n.position()
+                                );
+                            }
+                        }
+                        //  At type scope, Cpp1 requires an out-of-line declaration dance
+                        //  for some cases to work - see https://stackoverflow.com/questions/11928089/
+                        else if (printer.get_phase() == printer.phase1_type_defs_func_decls) {
                             printer.print_cpp2(
                                 "static const "
                                     + type + " "