feat(reflect): add function_declaration API to set initializer and inspect parameters (#831)

* feat(reflect): add `function_declaration::get_parameters`

* feat(reflect): add `function_declaration::add_initializer`

* fix(reflect): actually return the parent

* feat(reflect): add `declaration::get_arguments`

* feat(reflect): add `get_member_functions_needing_initializer`

* Pre-merge review pass

Johel, can you give this a try in your test code and make sure your test code still works as expected? I had to create a little test to exercise it, since the new functions aren't used in this PR.

* Restore preconditions for `add_initializer`

And:
- Add proper early returns for failed null checks
- Disable the `contract_group` default constructor, since we aren't checking the handler before trying to invoke it.

* Second review: Add graceful termination for a metafunction precondition violation

And restore `source` string to error output, and make it just come out routinely as soon as a parse error is detected

* Report original source string on parse errors

* regenerate `reflect.h`

---------

Signed-off-by: Herb Sutter <[email protected]>
Co-authored-by: Herb Sutter <[email protected]>

Author: JohelEGP

include/cpp2util.h

@@ -391,7 +391,7 @@ class contract_group {
 public:
     using handler = void (*)(CPP2_MESSAGE_PARAM msg CPP2_SOURCE_LOCATION_PARAM);
 
-    constexpr contract_group  (handler h = {})  : reporter(h) { }
+    constexpr contract_group  (handler h) : reporter{h} { }
     constexpr auto set_handler(handler h);
     constexpr auto get_handler() const -> handler { return reporter; }
     constexpr auto expects    (bool b, CPP2_MESSAGE_PARAM msg = "" CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAULT)

source/parse.h

@@ -2987,7 +2987,7 @@ struct declaration_node
     }
 
 
-    auto add_type_member( std::unique_ptr<statement_node> statement )
+    auto add_type_member( std::unique_ptr<statement_node>&& statement )
         -> bool
     {
         if (
@@ -3019,6 +3019,23 @@ struct declaration_node
     }
 
 
+    auto add_function_initializer( std::unique_ptr<statement_node>&& statement )
+        -> bool
+    {
+        if (
+            !is_function()
+            || initializer
+            )
+        {
+            return false;
+        }
+
+        //  Adopt it as our initializer statement
+        initializer = std::move( statement );
+        return true;
+    }
+
+
     auto get_decl_if_type_scope_object_name_before_a_base_type( std::string_view s ) const
         -> declaration_node const*
     {
@@ -3388,6 +3405,20 @@ struct declaration_node
         return false;
     }
 
+    auto get_function_parameters()
+        -> std::vector<parameter_declaration_node const*>
+    {
+        if (!is_function()) {
+            return {};
+        }
+        // else
+        auto ret = std::vector<parameter_declaration_node const*>{};
+        for (auto& param : std::get<a_function>(type)->parameters->parameters) {
+            ret.push_back( param.get() );
+        }
+        return ret;
+    }
+
     auto unnamed_return_type_to_string() const
         -> std::string
     {
@@ -5281,17 +5312,22 @@ class parser
         tokens           = &tokens_;
         generated_tokens = &generated_tokens_;
 
-        //  Parse one declaration - we succeed if the parse succeeded,
-        //  and there were no new errors, and all tokens were consumed
-        auto errors_size = std::ssize(errors);
-        pos = 0;
-        if (auto d = statement();
-            d
-            && std::ssize(errors) == errors_size
-            && done()
-            )
-        {
-            return d;
+        try {
+            //  Parse one declaration - we succeed if the parse succeeded,
+            //  and there were no new errors, and all tokens were consumed
+            auto errors_size = std::ssize(errors);
+            pos = 0;
+            if (auto d = statement();
+                d
+                && std::ssize(errors) == errors_size
+                && done()
+                )
+            {
+                return d;
+            }
+        }
+        catch(std::runtime_error& e) {
+            error(e.what(), true, {}, true);
         }
 
         return {};