Merge branch 'main' of https://github.com/hsutter/cppfront

Author: hsutter

regression-tests/pure2-concept-definition.cpp2

@@ -0,0 +1,5 @@
+arithmetic: <T> concept = std::integral<T> || std::floating_point<T>;
+main: ()                = {
+  [[assert Testing: arithmetic<i32>]]
+  [[assert Testing: arithmetic<float>]]
+}

regression-tests/test-results/clang-18/pure2-concept-definition.cpp.execution

@@ -0,0 +1,26 @@
+
+#define CPP2_USE_MODULES         Yes
+
+//=== Cpp2 type declarations ====================================================
+
+
+#include "cpp2util.h"
+
+
+
+//=== Cpp2 type definitions and function declarations ===========================
+
+#line 1 "pure2-concept-definition.cpp2"
+template<typename T> concept arithmetic = std::integral<T> || std::floating_point<T>; 
+auto main() -> int;
+  
+
+//=== Cpp2 function definitions =================================================
+
+
+#line 2 "pure2-concept-definition.cpp2"
+  auto main() -> int    {
+  cpp2::Testing.expects(arithmetic<cpp2::i32>, "");
+  cpp2::Testing.expects(arithmetic<float>, "");
+}
+

regression-tests/test-results/clang-18/pure2-concept-definition.cpp.output

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

regression-tests/test-results/pure2-concept-definition.cpp

@@ -5133,6 +5133,10 @@ class cppfront
                     && printer.get_phase() == printer.phase2_func_defs
                     )
                 )
+            && (
+                !n.is_concept()
+                || printer.get_phase() == printer.phase1_type_defs_func_decls
+                )
             )
         {
             printer.print_cpp2("template", n.position());
@@ -5804,10 +5808,18 @@ class cppfront
             )
         {
             auto& type = std::get<declaration_node::an_object>(n.type);
+            if (
+                printer.get_phase() == printer.phase2_func_defs
+                && type->is_concept()
+               )
+            {
+                return;
+            }
 
             if (
                 printer.get_phase() != printer.phase2_func_defs
                 && n.parent_is_namespace()
+                && !type->is_concept()
                 )
             {
                 printer.print_cpp2( "extern ", n.position() );
@@ -5871,6 +5883,7 @@ class cppfront
             if (
                 n.parent_is_namespace()
                 && printer.get_phase() != printer.phase2_func_defs
+                && !type->is_concept()
                 )
             {
                 printer.print_cpp2( ";", n.position());
@@ -5882,14 +5895,20 @@ class cppfront
             {
                 in_non_rvalue_context.push_back(true);
                 printer.add_pad_in_this_line(-100);
-                printer.print_cpp2( " {", n.position() );
+                if (type->is_concept()) {
+                    printer.print_cpp2( " = ", n.position() );
+                } else {
+                    printer.print_cpp2( " {", n.position() );
+                }
 
                 push_need_expression_list_parens(false);
                 assert( n.initializer );
                 emit( *n.initializer, false );
                 pop_need_expression_list_parens();
 
-                printer.print_cpp2( "}", n.position() );
+                if (!type->is_concept()) {
+                    printer.print_cpp2( "}", n.position() );
+                }
                 in_non_rvalue_context.pop_back();
             }
 

regression-tests/test-results/pure2-concept-definition.cpp2.output

@@ -1046,6 +1046,13 @@ struct type_id_node
         return false;
     }
 
+    auto is_concept() const
+        -> bool
+    {
+        auto tok = get_token();
+        return tok && *tok == "concept";
+    }
+
     auto template_args_count() const
         -> int
     {
@@ -2488,6 +2495,8 @@ struct declaration_node
         { return type.index() == a_function;  }
     auto is_object   () const -> bool
         { return type.index() == an_object;   }
+    auto is_concept  () const -> bool
+        { return type.index() == an_object && get<an_object>(type)->is_concept();   }
     auto is_type     () const -> bool
         { return type.index() == a_type;      }
     auto is_namespace() const -> bool