fix(to_cpp1): use specialization arguments in definition

Author: JohelEGP

regression-tests/pure2-template-specialization.cpp2

@@ -7,6 +7,14 @@ t: @struct <T> specialize<T> type requires std::is_void_v<T> = {
 t: @struct specialize<i64> type = {
   c: i32 = 3;
 }
+t: @struct specialize<* i8> type = {
+  f: () 17;
+  v: int == 29;
+}
+t: @struct <T> specialize<* T> type = {
+  v: int == 17;
+  f: () 29;
+}
 v: <T> const i32 = 1;
 v: <> specialize<void> const i32 = 2;
 v: specialize<i64> const i32 = 3;
@@ -17,6 +25,10 @@ main: ()   = {
   assert(t<i32>().a == 1);
   assert(t<void>().b == 2);
   assert(t<i64>().c == 3);
+  assert(t<* i8>::f() == 17);
+  assert(t<* i8>::v == 29);
+  assert(t<* i16>::v == 17);
+  assert(t<* i16>::f() == 29);
   assert(v<i32> == 1);
   assert(v<void> == 2);
   assert(v<i64> == 3);

regression-tests/test-results/pure2-template-specialization.cpp

@@ -20,9 +20,17 @@ template<typename T> requires( std::is_void_v<T> )
 template<> class t<cpp2::i64> {
   public: cpp2::i32 c {3}; 
 };
+template<> class t<cpp2::i8*> {
+  public: [[nodiscard]] static auto f() -> auto;
+  public: static const int v;
+};
+template<typename T> class t<T*> {
+  public: static const int v;
+  public: [[nodiscard]] static auto f() -> auto;
+};
 template<typename T> extern cpp2::i32 const v;
 
-#line 13 "pure2-template-specialization.cpp2"
+#line 21 "pure2-template-specialization.cpp2"
 template<> std::optional<cpp2::i32> inline constexpr v<cpp2::i16> = 4;
 template<> std::optional<cpp2::i8> inline constexpr v<cpp2::i8> = 5;
 template<typename T> std::optional<int> inline constexpr v<T*> = 6;
@@ -32,16 +40,27 @@ auto main() -> int;
 //=== Cpp2 function definitions =================================================
 
 
-#line 10 "pure2-template-specialization.cpp2"
+#line 11 "pure2-template-specialization.cpp2"
+  [[nodiscard]] auto t<cpp2::i8*>::f() -> auto { return 17;  }
+  inline CPP2_CONSTEXPR int t<cpp2::i8*>::v = 29;
+
+#line 15 "pure2-template-specialization.cpp2"
+  template <typename T> inline CPP2_CONSTEXPR int t<T*>::v = 17;
+  template <typename T> [[nodiscard]] auto t<T*>::f() -> auto { return 29;  }
+
 template<typename T> cpp2::i32 const v {1}; 
 template<> cpp2::i32 const v<void> {2}; 
 template<> cpp2::i32 const v<cpp2::i64> {3}; 
 
-#line 16 "pure2-template-specialization.cpp2"
+#line 24 "pure2-template-specialization.cpp2"
 auto main() -> int{
   cpp2::Default.expects(t<cpp2::i32>().a == 1, "");
   cpp2::Default.expects(t<void>().b == 2, "");
   cpp2::Default.expects(t<cpp2::i64>().c == 3, "");
+  cpp2::Default.expects(t<cpp2::i8*>::f() == 17, "");
+  cpp2::Default.expects(t<cpp2::i8*>::v == 29, "");
+  cpp2::Default.expects(t<cpp2::i16*>::v == 17, "");
+  cpp2::Default.expects(t<cpp2::i16*>::f() == 29, "");
   cpp2::Default.expects(v<cpp2::i32> == 1, "");
   cpp2::Default.expects(v<void> == 2, "");
   cpp2::Default.expects(v<cpp2::i64> == 3, "");

source/to_cpp1.h

@@ -4593,7 +4593,10 @@ class cppfront
                 )
             {
                 auto list = std::string{""};
-                if (parent->template_parameters) {
+                if (parent->specialization_template_arguments) {
+                    list = print_to_string(*parent->specialization_template_arguments, false, true, false, false);
+                }
+                else if (parent->template_parameters) {
                     auto separator = std::string{"<"};
                     for (auto& tparam : parent->template_parameters->parameters) {
                         assert (tparam->has_name());
@@ -5242,7 +5245,7 @@ class cppfront
 
                         auto specialization_template_arguments = std::string{};
                         if (n.specialization_template_arguments) {
-                            specialization_template_arguments = print_to_string(*n.specialization_template_arguments, false, true, false, false);
+                            specialization_template_arguments = print_to_string(*n.specialization_template_arguments, false, false, false, false);
                         }
 
                         printer.print_cpp2(
@@ -5446,7 +5449,7 @@ class cppfront
                 printer.print_cpp2("class ", n.position());
                 emit(*n.identifier);
                 if (n.specialization_template_arguments) {
-                    emit(*n.specialization_template_arguments, false, true, false, false);
+                    emit(*n.specialization_template_arguments, false, false, false, false);
                 }
 
                 //  Type declaration
@@ -6191,7 +6194,7 @@ class cppfront
             else {
                 emit(*n.identifier);
                 if (n.specialization_template_arguments) {
-                    emit(*n.specialization_template_arguments, false, true, false, false);
+                    emit(*n.specialization_template_arguments, false, false, false, false);
                 }
             }