feat: allow template specialization

regression-tests/pure2-template-specialization.cpp2

@@ -0,0 +1,18 @@
+t: @struct <T: type> type = {
+  a: i32 = 1;
+}
+t: @struct <T: type> specialize<T> type requires std::is_void_v<T> = {
+  b: i32 = 2;
+}
+t: @struct specialize<i64> type = {
+  c: i32 = 3;
+}
+v: <T> const i32 = 1;
+v: <> specialize<void> const i32 = 2;
+main: ()   = {
+  [[assert Testing: t<i32>().a == 1]]
+  [[assert Testing: t<void>().b == 2]]
+  [[assert Testing: t<i64>().c == 3]]
+  [[assert Testing: (v<i32>) == 1]]
+  [[assert Testing: (v<void>) == 2]]
+}

regression-tests/test-results/clang-18/clang-version.output

@@ -0,0 +1,4 @@
+clang version 18.0.0 (https://github.com/llvm/llvm-project.git 3723ede3cf5324827f8fbbe7f484c2ee4d7a7204)
+Target: x86_64-pc-linux-gnu
+Thread model: posix
+InstalledDir: /home/johel/root/clang-main/bin

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

@@ -0,0 +1,41 @@
+
+#define CPP2_USE_MODULES         Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+template<typename T> class t;
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+template<typename T> class t {
+  public: cpp2::i32 a {1}; 
+};
+template<typename T> requires( std::is_void_v<T> )
+  class t<T> {public: cpp2::i32 b {2}; 
+};
+template<> class t<cpp2::i64> {
+  public: cpp2::i32 c {3}; 
+};
+template<typename T> extern cpp2::i32 const v;
+
+auto main() -> int;
+
+
+//=== Cpp2 function definitions =================================================
+
+
+#line 10 "pure2-template-specialization.cpp2"
+template<typename T> cpp2::i32 const v {1}; 
+template<> cpp2::i32 const v<void> {2}; 
+auto main() -> int{
+  cpp2::Testing.expects(t<cpp2::i32>().a == 1, "");
+  cpp2::Testing.expects(t<void>().b == 2, "");
+  cpp2::Testing.expects(t<cpp2::i64>().c == 3, "");
+  cpp2::Testing.expects((v<cpp2::i32>) == 1, "");
+  cpp2::Testing.expects((v<void>) == 2, "");
+}
+

regression-tests/test-results/pure2-template-specialization.cpp2.output

@@ -0,0 +1,2 @@
+pure2-template-specialization.cpp2... ok (all Cpp2, passes safety checks)
+

source/cppfront.cpp

@@ -1617,7 +1617,8 @@ class cppfront
         unqualified_id_node const& n,
         bool in_synthesized_multi_return = false,
         bool is_local_name = true,
-        bool is_qualified = false
+        bool is_qualified = false,
+        bool emit_identifier = true
     )
         -> void
     {
@@ -1667,7 +1668,9 @@ class cppfront
         }
 
         assert(n.identifier);
-        emit(*n.identifier, is_qualified);  // inform the identifier if we know this is qualified
+        if (emit_identifier) {
+            emit(*n.identifier, is_qualified);  // inform the identifier if we know this is qualified
+        }
 
         if (n.open_angle != source_position{}) {
             printer.print_cpp2("<", n.open_angle);
@@ -4969,6 +4972,18 @@ class cppfront
             return;
         }
 
+        //  Do not forward declare specializations.
+        if (
+            n.is_specialization()
+            && (
+                (n.is_type() && printer.get_phase() == printer.phase0_type_decls)
+                || (n.is_object() && printer.get_phase() == printer.phase1_type_defs_func_decls)
+                )
+            )
+        {
+            return;
+        }
+
         //  If this is a generated declaration (negative source line number),
         //  add a line break before
         if (
@@ -5328,7 +5343,7 @@ class cppfront
 
         //  Now, emit our own template parameters
         if (
-            n.template_parameters
+            (n.template_parameters || n.is_specialization())
             && (
                 printer.get_phase() <  printer.phase2_func_defs
                 || n.is_object()
@@ -5346,7 +5361,12 @@ class cppfront
             )
         {
             printer.print_cpp2("template", n.position());
-            emit(*n.template_parameters, false, true);
+            if (n.template_parameters) {
+                emit(*n.template_parameters, false, true);
+            } else {
+                assert(n.is_specialization());
+                printer.print_cpp2("<>", n.position());
+            }
             printer.print_cpp2(" ", n.position());
         }
 
@@ -5369,6 +5389,9 @@ 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);
+                }
 
                 //  Type declaration
                 if (printer.get_phase() == printer.phase0_type_decls) {
@@ -6111,6 +6134,9 @@ class cppfront
             }
             else {
                 emit(*n.identifier);
+                if (n.specialization_template_arguments) {
+                    emit(*n.specialization_template_arguments, false, true, false, false);
+                }
             }
 
             if (

source/parse.h

@@ -2512,6 +2512,7 @@ struct declaration_node
 
     std::vector<std::unique_ptr<id_expression_node>> metafunctions;
     std::unique_ptr<parameter_declaration_list_node> template_parameters;
+    std::unique_ptr<unqualified_id_node>             specialization_template_arguments;
     source_position                                  requires_pos = {};
     std::unique_ptr<logical_or_expression_node>      requires_clause_expression;
 
@@ -2796,6 +2797,8 @@ struct declaration_node
 
     auto is_function_expression () const -> bool
         { return is_function() && !identifier;  }
+    auto is_specialization() const -> bool
+        { return specialization_template_arguments != nullptr;    }
 
     auto is_polymorphic() const // has base types or virtual functions
         -> bool
@@ -6109,6 +6112,7 @@ class parser
     //G
     //G template-argument-list:
     //G     template-argument-list ',' template-argument
+    //G     template-argument
     //G
     //G template-argument:
     //G     # note: < > << >> are not allowed in expressions until new ( is opened
@@ -7606,9 +7610,9 @@ class parser
     //G unnamed-declaration:
     //G     ':' meta-functions-list? template-parameter-declaration-list? function-type requires-clause? '=' statement
     //G     ':' meta-functions-list? template-parameter-declaration-list? function-type statement
-    //G     ':' meta-functions-list? template-parameter-declaration-list? type-id? requires-clause? '=' statement
+    //G     ':' meta-functions-list? template-parameter-declaration-list? template-specialization-argument-list? type-id? requires-clause? '=' statement
     //G     ':' meta-functions-list? template-parameter-declaration-list? type-id
-    //G     ':' meta-functions-list? template-parameter-declaration-list? 'final'? 'type' requires-clause? '=' statement
+    //G     ':' meta-functions-list? template-parameter-declaration-list? template-specialization-argument-list? 'final'? 'type' requires-clause? '=' statement
     //G     ':' 'namespace' '=' statement
     //G
     //G meta-functions-list:
@@ -7620,7 +7624,10 @@ class parser
     //G      'requires' logical-or-expression
     //G
     //G template-parameter-declaration-list
-    //G     '<' parameter-declaration-seq '>'
+    //G     '<' parameter-declaration-seq? '>'
+    //G
+    //G template-specialization-argument-list:
+    //G     'specialize' '<' template-argument-list '>'
     //G
     auto unnamed_declaration(
         source_position                      start,
@@ -7765,6 +7772,21 @@ class parser
             n->template_parameters = std::move(template_parameters);
         }
 
+        //  Next is an optional template specialization argument list
+        if (
+            curr() == "specialize"
+            && peek(1)
+            && peek(1)->type() == lexeme::Less
+            )
+        {
+          auto specialization_template_arguments = unqualified_id();
+          if (!specialization_template_arguments) {
+            error("invalid template specialization argument list");
+            return {};
+          }
+          n->specialization_template_arguments = std::move(specialization_template_arguments);
+        }
+
         auto guard =
             captures_allowed
             ? std::make_unique<capture_groups_stack_guard>(this, &n->captures)