improve diagnostics

Author: Tsche

include/rsl/_impl/default_construct.hpp

@@ -4,7 +4,7 @@
 #include <concepts>
 #include <ranges>
 #include <algorithm>
-#include <tuple> // use rsl::tuple?
+#include <tuple>  // use rsl::tuple?
 #include <utility>
 #include <stdexcept>
 
@@ -14,10 +14,7 @@ namespace rsl::_impl {
 template <std::meta::info R>
 consteval std::meta::info make_arg_tuple() {
   std::vector<std::meta::info> args;
-  auto make_optional = [](auto r) {
-    return substitute(^^std::optional, {
-                                           r});
-  };
+  auto make_optional = [](auto r) { return substitute(^^std::optional, {r}); };
 
   if constexpr (is_function(R)) {
     for (auto& arg : parameters_of(R)) {
@@ -33,8 +30,7 @@ consteval std::meta::info make_arg_tuple() {
     constexpr auto ctx = std::meta::access_context::current();
     for (auto&& base : bases_of(dealias(R), ctx)) {
       args.push_back(extract<std::meta::info (*)()>(
-          substitute(^^make_arg_tuple, {
-                                           reflect_constant(type_of(base))}))());
+          substitute(^^make_arg_tuple, {reflect_constant(type_of(base))}))());
     }
     for (auto&& arg : nonstatic_data_members_of(R, ctx)) {
       args.push_back(make_optional(type_of(arg)));
@@ -53,12 +49,14 @@ namespace _default_impl {
 consteval std::size_t required_args_count(std::meta::info reflection) {
   if (is_function(reflection)) {
     auto members = parameters_of(reflection);
-    return std::count_if(members.begin(), members.end(),
-                         [](auto x) { return !has_default_argument(x); });
+    return std::count_if(members.begin(), members.end(), [](auto x) {
+      return !has_default_argument(x);
+    });
   } else if (is_type(reflection)) {
     auto members = nonstatic_data_members_of(reflection, std::meta::access_context::current());
-    return std::count_if(members.begin(), members.end(),
-                         [](auto x) { return !has_default_member_initializer(x); });
+    return std::count_if(members.begin(), members.end(), [](auto x) {
+      return !has_default_member_initializer(x);
+    });
   } else {
     return {};
   }
@@ -76,13 +74,13 @@ decltype(auto) do_visit(F visitor, std::size_t index, Args&&... extra_args) {
 
 template <std::size_t Bases, std::size_t Required, typename T, typename F, typename... Args>
 decltype(auto) visit(F visitor, ArgumentTuple<T> const& args, Args&&... extra_args) {
-  constexpr static int size = std::tuple_size_v<ArgumentTuple<T>>;
-  constexpr static int optional_min = Bases + Required;
-  constexpr static int branches = size - optional_min;
+  constexpr static std::size_t size         = std::tuple_size_v<ArgumentTuple<T>>;
+  constexpr static std::size_t optional_min = Bases + Required;
+  constexpr static std::size_t branches     = size - optional_min;
 
   std::size_t index = 0;
-  template for(constexpr auto Idx : std::views::iota(0zu, size - Bases)) {
-    if (get<Bases + Idx>(args).has_value()) {
+  template for (constexpr auto Idx : std::views::iota(Bases, size)) {
+    if (get<Idx>(args).has_value()) {
       ++index;
     } else {
       break;
@@ -91,15 +89,16 @@ decltype(auto) visit(F visitor, ArgumentTuple<T> const& args, Args&&... extra_ar
 
   if (index < Required) {
     // fail more gracefully
-    throw std::runtime_error("not all required arguments are given");
+    throw std::runtime_error(std::format("expected {} arguments, got {}", size, index));
   }
 
   if constexpr (branches == 0) {
     // no optional arguments
     return visitor(std::make_index_sequence<size - Bases>(), std::forward<Args>(extra_args)...);
   } else {
-    return do_visit<Required, branches>(
-        visitor, index - Required, std::forward<Args>(extra_args)...);
+    return do_visit<Required, branches>(visitor,
+                                        index - Required,
+                                        std::forward<Args>(extra_args)...);
   }
 }
 
@@ -109,27 +108,30 @@ template <std::meta::info R>
 constexpr inline std::size_t required_arg_count = _default_impl::required_args_count(R);
 
 template <typename T>
-constexpr inline std::size_t base_count = bases_of(^^T, std::meta::access_context::current()).size();
+constexpr inline std::size_t base_count =
+    bases_of(^^T, std::meta::access_context::current()).size();
 
 template <typename T>
   requires(std::is_aggregate_v<T> && !std::is_array_v<T>)
 T default_construct(ArgumentTuple<T> const& args) {
   constexpr static auto num_bases = base_count<T>;
-  constexpr static auto ctx = std::meta::access_context::current();
+  constexpr static auto ctx       = std::meta::access_context::current();
 
   return _default_impl::visit<num_bases, required_arg_count<dealias(^^T)>, T>(
       [&]<std::size_t... Idx, std::size_t... BIdx>(std::index_sequence<Idx...>,
                                                    std::index_sequence<BIdx...>) {
-        return T{default_construct<typename [:type_of(bases_of(^^T, ctx)[BIdx]):]>(get<BIdx>(args))...,
-                 *get<num_bases + Idx>(args)...};
+        return T{
+            default_construct<typename[:type_of(bases_of(^^T, ctx)[BIdx]):]>(get<BIdx>(args))...,
+            *get<num_bases + Idx>(args)...};
       },
-      args, std::make_index_sequence<num_bases>());
+      args,
+      std::make_index_sequence<num_bases>());
 }
 
 template <std::meta::info R>
   requires(meta::function<R> || meta::static_member_function<R>)
-decltype(auto) default_invoke(ArgumentTuple<typename [:type_of(R):]> const& args) {
-  return _default_impl::visit<0, required_arg_count<R>, typename [:type_of(R):]>(
+decltype(auto) default_invoke(ArgumentTuple<typename[:type_of(R):]> const& args) {
+  return _default_impl::visit<0, required_arg_count<R>, typename[:type_of(R):]>(
       [&]<std::size_t... Idx>(std::index_sequence<Idx...>) { return [:R:](*get<Idx>(args)...); },
       args);
 }
@@ -141,11 +143,11 @@ decltype(auto) default_invoke() =
 
 template <std::meta::info R, typename T>
   requires(meta::nonstatic_member_function<R>)
-decltype(auto) default_invoke(T&& self, ArgumentTuple<typename [:type_of(R):]> const& args) {
-  static_assert(std::convertible_to<std::remove_cvref_t<T>, typename [:parent_of(R):]>,
+decltype(auto) default_invoke(T&& self, ArgumentTuple<typename[:type_of(R):]> const& args) {
+  static_assert(std::convertible_to<std::remove_cvref_t<T>, typename[:parent_of(R):]>,
                 "wrong type for self argument");
 
-  return _default_impl::visit<0, required_arg_count<R>, typename [:type_of(R):]>(
+  return _default_impl::visit<0, required_arg_count<R>, typename[:type_of(R):]>(
       [&]<std::size_t... Idx>(std::index_sequence<Idx...>) {
         std::forward<T>(self).[:R:](*get<Idx>(args)...);
       },

include/rsl/cli/option.hpp

@@ -41,7 +41,7 @@ struct Option {
 
   Unevaluated::handler_type _impl_handler = nullptr;
   rsl::string_view name;
-  // rsl::string_view description = "";
+  rsl::string_view description;
   rsl::span<Argument const> arguments;
 
   std::optional<Unevaluated> parse(ArgParser& parser) {
@@ -74,9 +74,10 @@ struct Option {
 
   consteval Option(std::string_view name, std::meta::info reflection)
       : name(std::define_static_string(name)) {
-    // if (auto desc = annotation_of_type<annotations::Description>(reflection); desc) {
-    //   description = desc->data;
-    // }
+    if (auto desc = annotation_of_type<annotations::Description>(reflection); desc) {
+      description = std::define_static_string(desc->data);
+    }
+
     std::vector<Argument> args;
     std::size_t index = 0;
     if (is_object_type(type_of(reflection))) {

include/rsl/config

@@ -37,8 +37,8 @@ class config {
                          std::string_view description);
 
 public:
-  static constexpr auto option     = annotations::option;
-  static constexpr auto value      = rsl::placeholders::_0;
+  static constexpr auto option = annotations::option;
+  static constexpr auto value  = rsl::placeholders::_0;
 
   using shorthand   = annotations::Shorthand;
   using description = annotations::Description;
@@ -59,6 +59,7 @@ public:
 
 class cli : public config {
   static std::string& get_config_path();
+
 public:
   static constexpr auto option     = annotations::option;
   static constexpr auto positional = annotations::positional;
@@ -70,8 +71,7 @@ public:
   static std::string_view config_path() { return get_config_path(); }
 
   template <typename T>
-  [[= option]] 
-  static void config_path(std::string new_path) {
+  [[= option]] static void config_path(std::string new_path) {
     get_config_path() = new_path;
   }
 
@@ -99,16 +99,22 @@ T load_config(std::vector<std::string_view> args_in) {
   auto config = json5::load(T::config_path());
   config.template update_argtuple<T>(args_tuple);
 
-  
   for (auto argument : parsed_args) {
     argument(&args_tuple);
   }
 
-  // for (auto arg : spec.arguments | std::views::drop(parsed_args.size())) {
-  //   if (!arg.is_optional) {
-  //     parser.fail("Missing required argument `{}`", arg.name);
-  //   }
-  // }
+  constexpr auto ctx            = std::meta::access_context::current();
+  constexpr static auto members = std::define_static_array(nonstatic_data_members_of(^^T, ctx));
+  constexpr auto base_count     = bases_of(^^T, ctx).size();
+
+  template for (constexpr auto Idx : std::views::iota(0zu, members.size())) {
+    constexpr static bool has_default = has_default_member_initializer(members[Idx]);
+    constexpr static auto name        = std::define_static_string(identifier_of(members[Idx]));
+
+    if (!get<base_count + Idx>(args_tuple).has_value() && !has_default) {
+      parser.fail("Missing required argument `{}`", name);
+    }
+  }
 
   T object = _impl::default_construct<T>(args_tuple);
 
@@ -122,7 +128,7 @@ T load_config(std::vector<std::string_view> args_in) {
 
 template <typename T>
 T load_config(int argc, char** argv) {
-  return load_config<T>({argv, argv+argc});
+  return load_config<T>({argv, argv + argc});
 }
 
 }  // namespace rsl