merge error enums

Author: anonrig

include/ada/implementation.h

@@ -17,7 +17,7 @@
 #include "ada/url_aggregator.h"
 
 namespace ada {
-enum class errors { generic_error };
+enum class errors : uint8_t { type_error };
 
 template <class result_type = ada::url_aggregator>
 using result = tl::expected<result_type, ada::errors>;
@@ -58,7 +58,7 @@ bool can_parse(std::string_view input,
  * @param options an optional url_pattern_options struct
  * @return url_pattern instance
  */
-ada_warn_unused tl::expected<url_pattern, url_pattern_errors> parse_url_pattern(
+ada_warn_unused tl::expected<url_pattern, errors> parse_url_pattern(
     std::variant<std::string_view, url_pattern_init> input,
     const std::string_view* base_url = nullptr,
     const url_pattern_options* options = nullptr);

include/ada/parser.h

@@ -19,7 +19,7 @@ struct url;
 class url_pattern;
 struct url_pattern_options;
 struct url_pattern_init;
-enum class url_pattern_errors : uint8_t;
+enum class errors : uint8_t;
 }  // namespace ada
 
 /**
@@ -51,7 +51,7 @@ extern template url_aggregator parse_url_impl<url_aggregator>(
 extern template url parse_url_impl<url>(std::string_view user_input,
                                         const url* base_url);
 
-tl::expected<url_pattern, url_pattern_errors> parse_url_pattern_impl(
+tl::expected<url_pattern, errors> parse_url_pattern_impl(
     std::variant<std::string_view, url_pattern_init> input,
     const std::string_view* base_url, const url_pattern_options* options);
 

include/ada/url_aggregator.h

@@ -222,7 +222,7 @@ struct url_aggregator : url_base {
   friend url_aggregator parser::parse_url_impl<url_aggregator, false>(
       std::string_view, const url_aggregator *);
   // url_pattern methods
-  friend tl::expected<url_pattern, url_pattern_errors> parse_url_pattern_impl(
+  friend tl::expected<url_pattern, errors> parse_url_pattern_impl(
       std::variant<std::string_view, url_pattern_init> input,
       const std::string_view *base_url, const url_pattern_options *options);
 

include/ada/url_pattern.h

@@ -15,12 +15,10 @@
 
 namespace ada {
 
-enum class url_pattern_errors : uint8_t { type_error };
-
 namespace parser {
 template <typename result_type, typename url_pattern_init,
           typename url_pattern_options>
-tl::expected<result_type, url_pattern_errors> parse_url_pattern_impl(
+tl::expected<result_type, errors> parse_url_pattern_impl(
     std::variant<std::string_view, url_pattern_init> input,
     const std::string_view* base_url, const url_pattern_options* options);
 }
@@ -30,7 +28,7 @@ tl::expected<result_type, url_pattern_errors> parse_url_pattern_impl(
 // std::nullopt or a parameter with default value)
 template <typename F>
 concept url_pattern_encoding_callback = requires(F f, std::string_view sv) {
-  { f(sv) } -> std::same_as<tl::expected<std::string, url_pattern_errors>>;
+  { f(sv) } -> std::same_as<tl::expected<std::string, errors>>;
 };
 
 // A structure providing matching patterns for individual components
@@ -41,7 +39,7 @@ concept url_pattern_encoding_callback = requires(F f, std::string_view sv) {
 // API is defined as part of the URLPattern specification.
 struct url_pattern_init {
   // @see https://urlpattern.spec.whatwg.org/#process-a-urlpatterninit
-  static tl::expected<url_pattern_init, url_pattern_errors> process(
+  static tl::expected<url_pattern_init, errors> process(
       url_pattern_init init, std::string_view type,
       std::optional<std::string_view> protocol = std::nullopt,
       std::optional<std::string_view> username = std::nullopt,
@@ -53,36 +51,36 @@ struct url_pattern_init {
       std::optional<std::string_view> hash = std::nullopt);
 
   // @see https://urlpattern.spec.whatwg.org/#process-protocol-for-init
-  static tl::expected<std::string, url_pattern_errors> process_protocol(
+  static tl::expected<std::string, errors> process_protocol(
       std::string_view value, std::string_view type);
 
   // @see https://urlpattern.spec.whatwg.org/#process-username-for-init
-  static tl::expected<std::string, url_pattern_errors> process_username(
+  static tl::expected<std::string, errors> process_username(
       std::string_view value, std::string_view type);
 
   // @see https://urlpattern.spec.whatwg.org/#process-password-for-init
-  static tl::expected<std::string, url_pattern_errors> process_password(
+  static tl::expected<std::string, errors> process_password(
       std::string_view value, std::string_view type);
 
   // @see https://urlpattern.spec.whatwg.org/#process-hostname-for-init
-  static tl::expected<std::string, url_pattern_errors> process_hostname(
+  static tl::expected<std::string, errors> process_hostname(
       std::string_view value, std::string_view type);
 
   // @see https://urlpattern.spec.whatwg.org/#process-port-for-init
-  static tl::expected<std::string, url_pattern_errors> process_port(
+  static tl::expected<std::string, errors> process_port(
       std::string_view port, std::string_view protocol, std::string_view type);
 
   // @see https://urlpattern.spec.whatwg.org/#process-pathname-for-init
-  static tl::expected<std::string, url_pattern_errors> process_pathname(
+  static tl::expected<std::string, errors> process_pathname(
       std::string_view value, std::string_view protocol, std::string_view type);
 
   // @see https://urlpattern.spec.whatwg.org/#process-search-for-init
-  static tl::expected<std::string, url_pattern_errors> process_search(
+  static tl::expected<std::string, errors> process_search(
       std::string_view value, std::string_view type);
 
   // @see https://urlpattern.spec.whatwg.org/#process-hash-for-init
-  static tl::expected<std::string, url_pattern_errors> process_hash(
-      std::string_view value, std::string_view type);
+  static tl::expected<std::string, errors> process_hash(std::string_view value,
+                                                        std::string_view type);
 
   [[nodiscard]] std::string to_string() const;
 
@@ -210,7 +208,7 @@ class url_pattern_component {
 
   // @see https://urlpattern.spec.whatwg.org/#compile-a-component
   template <url_pattern_encoding_callback F>
-  static tl::expected<url_pattern_component, url_pattern_errors> compile(
+  static tl::expected<url_pattern_component, errors> compile(
       std::string_view input, F& encoding_callback,
       url_pattern_compile_component_options& options);
 
@@ -263,7 +261,7 @@ class url_pattern {
                        std::optional<url_pattern_options>&& options);
 
   // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-exec
-  tl::expected<std::optional<url_pattern_result>, url_pattern_errors> exec(
+  tl::expected<std::optional<url_pattern_result>, errors> exec(
       url_pattern_input&& input, std::string_view* base_url);
   // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-test
   bool test(url_pattern_input&& input, std::string_view* base_url);
@@ -272,7 +270,7 @@ class url_pattern {
    * @see https://urlpattern.spec.whatwg.org/#url-pattern-match
    * This function expects a valid UTF-8 string if input is a string.
    */
-  tl::expected<std::optional<url_pattern_result>, url_pattern_errors> match(
+  tl::expected<std::optional<url_pattern_result>, errors> match(
       url_pattern_input&& input, std::string_view* base_url_string);
 
   // @see https://urlpattern.spec.whatwg.org/#dom-urlpattern-protocol
@@ -313,8 +311,7 @@ class url_pattern {
 
   template <typename result_type, typename url_pattern_init,
             typename url_pattern_options>
-  friend tl::expected<result_type, url_pattern_errors>
-  parser::parse_url_pattern_impl(
+  friend tl::expected<result_type, errors> parser::parse_url_pattern_impl(
       std::variant<std::string_view, url_pattern_init> input,
       const std::string_view* base_url, const url_pattern_options* options);
 };

include/ada/url_pattern_helpers-inl.h

@@ -9,6 +9,7 @@
 #include "ada/expected.h"
 #include "ada/url_pattern.h"
 #include "ada/url_pattern_helpers.h"
+#include "ada/implementation.h"
 
 namespace ada::url_pattern_helpers {
 inline std::string to_string(token_type type) {
@@ -400,14 +401,14 @@ inline void Tokenizer::add_token_with_defaults(token_type type) {
   add_token_with_default_length(type, next_index, index);
 }
 
-inline ada_warn_unused std::optional<url_pattern_errors>
+inline ada_warn_unused std::optional<errors>
 Tokenizer::process_tokenizing_error(size_t next_position,
                                     size_t value_position) {
   // If tokenizer’s policy is "strict", then throw a TypeError.
   if (policy == token_policy::STRICT) {
     ada_log("process_tokenizing_error failed with next_position=",
             next_position, " value_position=", value_position);
-    return url_pattern_errors::type_error;
+    return errors::type_error;
   }
   // Assert: tokenizer’s policy is "lenient".
   ADA_ASSERT_TRUE(policy == token_policy::LENIENT);
@@ -493,7 +494,7 @@ bool url_pattern_parser<F>::consume_required_token(token_type type) {
 }
 
 template <url_pattern_encoding_callback F>
-std::optional<url_pattern_errors>
+std::optional<errors>
 url_pattern_parser<F>::maybe_add_part_from_the_pending_fixed_value() {
   // If parser’s pending fixed value is the empty string, then return.
   if (pending_fixed_value.empty()) {
@@ -519,7 +520,7 @@ url_pattern_parser<F>::maybe_add_part_from_the_pending_fixed_value() {
 }
 
 template <url_pattern_encoding_callback F>
-std::optional<url_pattern_errors> url_pattern_parser<F>::add_part(
+std::optional<errors> url_pattern_parser<F>::add_part(
     std::string_view prefix, Token* name_token, Token* regexp_or_wildcard_token,
     std::string_view suffix, Token* modifier_token) {
   // Let modifier be "none".
@@ -616,7 +617,7 @@ std::optional<url_pattern_errors> url_pattern_parser<F>::add_part(
   // true, then throw a TypeError.
   if (std::ranges::any_of(
           parts, [&name](const auto& part) { return part.name == name; })) {
-    return url_pattern_errors::type_error;
+    return errors::type_error;
   }
   // Let encoded prefix be the result of running parser’s encoding callback
   // given prefix.
@@ -636,10 +637,9 @@ std::optional<url_pattern_errors> url_pattern_parser<F>::add_part(
 }
 
 template <url_pattern_encoding_callback F>
-tl::expected<std::vector<url_pattern_part>, url_pattern_errors>
-parse_pattern_string(std::string_view input,
-                     url_pattern_compile_component_options& options,
-                     F& encoding_callback) {
+tl::expected<std::vector<url_pattern_part>, errors> parse_pattern_string(
+    std::string_view input, url_pattern_compile_component_options& options,
+    F& encoding_callback) {
   ada_log("parse_pattern_string input=", input);
   // Let parser be a new pattern parser whose encoding callback is encoding
   // callback and segment wildcard regexp is the result of running generate a
@@ -732,7 +732,7 @@ parse_pattern_string(std::string_view input,
       // Run consume a required token given parser and "close".
       if (!parser.consume_required_token(token_type::CLOSE)) {
         ada_log("parser.consume_required_token failed");
-        return tl::unexpected(url_pattern_errors::type_error);
+        return tl::unexpected(errors::type_error);
       }
       // Set modifier token to the result of running try to consume a modifier
       // token given parser.
@@ -754,7 +754,7 @@ parse_pattern_string(std::string_view input,
     }
     // Run consume a required token given parser and "end".
     if (!parser.consume_required_token(token_type::END)) {
-      return tl::unexpected(url_pattern_errors::type_error);
+      return tl::unexpected(errors::type_error);
     }
   }
   ada_log("parser.parts size is: ", parser.parts.size());

include/ada/url_pattern_helpers.h

@@ -78,13 +78,13 @@ class url_pattern_parser {
   bool consume_required_token(token_type type);
   // @see
   // https://urlpattern.spec.whatwg.org/#maybe-add-a-part-from-the-pending-fixed-value
-  std::optional<url_pattern_errors>
-  maybe_add_part_from_the_pending_fixed_value() ada_warn_unused;
+  std::optional<errors> maybe_add_part_from_the_pending_fixed_value()
+      ada_warn_unused;
   // @see https://urlpattern.spec.whatwg.org/#add-a-part
-  std::optional<url_pattern_errors> add_part(
-      std::string_view prefix, Token* name_token,
-      Token* regexp_or_wildcard_token, std::string_view suyffix,
-      Token* modifier_token) ada_warn_unused;
+  std::optional<errors> add_part(std::string_view prefix, Token* name_token,
+                                 Token* regexp_or_wildcard_token,
+                                 std::string_view suyffix,
+                                 Token* modifier_token) ada_warn_unused;
 
   std::vector<Token> tokens{};
   F& encoding_callback;
@@ -121,7 +121,7 @@ class Tokenizer {
   void add_token_with_defaults(token_type type);
 
   // @see https://urlpattern.spec.whatwg.org/#process-a-tokenizing-error
-  std::optional<url_pattern_errors> process_tokenizing_error(
+  std::optional<errors> process_tokenizing_error(
       size_t next_position, size_t value_position) ada_warn_unused;
 
   // has an associated input, a pattern string, initially the empty string.
@@ -154,8 +154,7 @@ struct constructor_string_parser {
   bool is_search_prefix();
 
   // @see https://urlpattern.spec.whatwg.org/#parse-a-constructor-string
-  static tl::expected<url_pattern_init, url_pattern_errors> parse(
-      std::string_view input);
+  static tl::expected<url_pattern_init, errors> parse(std::string_view input);
 
   // @see https://urlpattern.spec.whatwg.org/#constructor-string-parser-state
   enum class State {
@@ -186,8 +185,7 @@ struct constructor_string_parser {
 
   // @see
   // https://urlpattern.spec.whatwg.org/#compute-protocol-matches-a-special-scheme-flag
-  std::optional<url_pattern_errors>
-  compute_protocol_matches_special_scheme_flag();
+  std::optional<errors> compute_protocol_matches_special_scheme_flag();
 
   // @see https://urlpattern.spec.whatwg.org/#next-is-authority-slashes
   bool next_is_authority_slashes();
@@ -247,52 +245,44 @@ struct constructor_string_parser {
 };
 
 // @see https://urlpattern.spec.whatwg.org/#canonicalize-a-protocol
-tl::expected<std::string, url_pattern_errors> canonicalize_protocol(
-    std::string_view input);
+tl::expected<std::string, errors> canonicalize_protocol(std::string_view input);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-a-username
-tl::expected<std::string, url_pattern_errors> canonicalize_username(
-    std::string_view input);
+tl::expected<std::string, errors> canonicalize_username(std::string_view input);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-a-password
-tl::expected<std::string, url_pattern_errors> canonicalize_password(
-    std::string_view input);
+tl::expected<std::string, errors> canonicalize_password(std::string_view input);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-a-password
-tl::expected<std::string, url_pattern_errors> canonicalize_hostname(
-    std::string_view input);
+tl::expected<std::string, errors> canonicalize_hostname(std::string_view input);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-an-ipv6-hostname
-tl::expected<std::string, url_pattern_errors> canonicalize_ipv6_hostname(
+tl::expected<std::string, errors> canonicalize_ipv6_hostname(
     std::string_view input);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-a-port
-tl::expected<std::string, url_pattern_errors> canonicalize_port(
-    std::string_view input);
+tl::expected<std::string, errors> canonicalize_port(std::string_view input);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-a-port
-tl::expected<std::string, url_pattern_errors> canonicalize_port_with_protocol(
+tl::expected<std::string, errors> canonicalize_port_with_protocol(
     std::string_view input, std::string_view protocol);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-a-pathname
-tl::expected<std::string, url_pattern_errors> canonicalize_pathname(
-    std::string_view input);
+tl::expected<std::string, errors> canonicalize_pathname(std::string_view input);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-an-opaque-pathname
-tl::expected<std::string, url_pattern_errors> canonicalize_opaque_pathname(
+tl::expected<std::string, errors> canonicalize_opaque_pathname(
     std::string_view input);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-a-search
-tl::expected<std::string, url_pattern_errors> canonicalize_search(
-    std::string_view input);
+tl::expected<std::string, errors> canonicalize_search(std::string_view input);
 
 // @see https://wicg.github.io/urlpattern/#canonicalize-a-hash
-tl::expected<std::string, url_pattern_errors> canonicalize_hash(
-    std::string_view input);
+tl::expected<std::string, errors> canonicalize_hash(std::string_view input);
 
 // @see https://urlpattern.spec.whatwg.org/#tokenize
-tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
-    std::string_view input, token_policy policy);
+tl::expected<std::vector<Token>, errors> tokenize(std::string_view input,
+                                                  token_policy policy);
 
 // @see https://urlpattern.spec.whatwg.org/#process-a-base-url-string
 std::string process_base_url_string(std::string_view input,
@@ -310,10 +300,9 @@ constexpr bool is_absolute_pathname(std::string_view input,
 
 // @see https://urlpattern.spec.whatwg.org/#parse-a-pattern-string
 template <url_pattern_encoding_callback F>
-tl::expected<std::vector<url_pattern_part>, url_pattern_errors>
-parse_pattern_string(std::string_view input,
-                     url_pattern_compile_component_options& options,
-                     F& encoding_callback);
+tl::expected<std::vector<url_pattern_part>, errors> parse_pattern_string(
+    std::string_view input, url_pattern_compile_component_options& options,
+    F& encoding_callback);
 
 // @see https://urlpattern.spec.whatwg.org/#generate-a-pattern-string
 std::string generate_pattern_string(

src/implementation.cpp

@@ -9,12 +9,12 @@
 namespace ada {
 
 template <class result_type>
-ada_warn_unused tl::expected<result_type, ada::errors> parse(
+ada_warn_unused tl::expected<result_type, errors> parse(
     std::string_view input, const result_type* base_url) {
   result_type u =
       ada::parser::parse_url_impl<result_type, true>(input, base_url);
   if (!u.is_valid) {
-    return tl::unexpected(errors::generic_error);
+    return tl::unexpected(errors::type_error);
   }
   return u;
 }
@@ -79,7 +79,7 @@ ada_warn_unused std::string to_string(ada::encoding_type type) {
   }
 }
 
-ada_warn_unused tl::expected<url_pattern, url_pattern_errors> parse_url_pattern(
+ada_warn_unused tl::expected<url_pattern, errors> parse_url_pattern(
     std::variant<std::string_view, url_pattern_init> input,
     const std::string_view* base_url, const url_pattern_options* options) {
   return parser::parse_url_pattern_impl(std::move(input), base_url, options);