fix url pattern constructor error

include/ada/unicode.h

@@ -124,6 +124,13 @@ ada_really_inline constexpr bool is_alnum_plus(char c) noexcept;
  */
 ada_really_inline constexpr bool is_ascii_hex_digit(char c) noexcept;
 
+/**
+ * @private
+ * @details If a char is between U+0000 and U+007F inclusive, then it's an ASCII
+ * character.
+ */
+ada_really_inline constexpr bool is_ascii(uint16_t c) noexcept;
+
 /**
  * @private
  * Checks if the input is a C0 control or space character.

include/ada/url_pattern_helpers-inl.h

@@ -266,7 +266,7 @@ inline bool constructor_string_parser::is_port_prefix() {
 inline void Tokenizer::get_next_code_point() {
   // Set tokenizer’s code point to the Unicode code point in tokenizer’s input
   // at the position indicated by tokenizer’s next index.
-  code_point = &input[next_index];
+  code_point = input[next_index];
   // Increment tokenizer’s next index by 1.
   next_index++;
 }
@@ -321,7 +321,7 @@ Tokenizer::process_tokenizing_error(size_t next_position,
 }
 
 // @see https://urlpattern.spec.whatwg.org/#is-a-valid-name-code-point
-inline bool is_valid_name_code_point(char cp, bool first) {
+inline bool is_valid_name_code_point(uint16_t cp, bool first) {
   // If first is true return the result of checking if code point is contained
   // in the IdentifierStart set of code points. Otherwise return the result of
   // checking if code point is contained in the IdentifierPart set of code

include/ada/url_pattern_helpers.h

@@ -126,7 +126,7 @@ class Tokenizer {
   // has an associated next index, a number, initially 0.
   size_t next_index = 0;
   // has an associated code point, a Unicode code point, initially null.
-  std::string_view code_point{};
+  uint16_t code_point{};
 };
 
 // @see https://urlpattern.spec.whatwg.org/#constructor-string-parser
@@ -333,7 +333,7 @@ std::string generate_segment_wildcard_regexp(
     url_pattern_compile_component_options options);
 
 // @see https://urlpattern.spec.whatwg.org/#is-a-valid-name-code-point
-bool is_valid_name_code_point(char code_point, bool first);
+bool is_valid_name_code_point(uint16_t code_point, bool first);
 
 }  // namespace ada::url_pattern_helpers
 

src/parser.cpp

@@ -911,26 +911,26 @@ tl::expected<url_pattern, url_pattern_errors> parse_url_pattern_impl(
     // Set init to the result of running parse a constructor string given input.
     auto parse_result = url_pattern_helpers::constructor_string_parser::parse(
         std::get<std::string_view>(input));
-    if (!parse_result.has_value()) {
+    if (!parse_result) {
       return tl::unexpected(parse_result.error());
     }
     init = *parse_result;
 
     // If baseURL is null and init["protocol"] does not exist, then throw a
     // TypeError.
-    if (base_url == nullptr && !init.protocol.has_value()) {
+    if (!base_url && !init.protocol) {
       return tl::unexpected(url_pattern_errors::type_error);
     }
 
     // If baseURL is not null, set init["baseURL"] to baseURL.
-    if (base_url != nullptr) {
+    if (base_url) {
       init.base_url = std::string(*base_url);
     }
   } else {
     // Assert: input is a URLPatternInit.
     ADA_ASSERT_TRUE(std::holds_alternative<url_pattern_init>(input));
     // If baseURL is not null, then throw a TypeError.
-    if (base_url != nullptr) {
+    if (base_url) {
       return tl::unexpected(url_pattern_errors::type_error);
     }
     // Optimization: Avoid copy by moving the input value.
@@ -950,6 +950,7 @@ tl::expected<url_pattern, url_pattern_errors> parse_url_pattern_impl(
   // For each componentName of « "protocol", "username", "password", "hostname",
   // "port", "pathname", "search", "hash" If processedInit[componentName] does
   // not exist, then set processedInit[componentName] to "*".
+  ADA_ASSERT_TRUE(processed_init.has_value());
   if (!processed_init->protocol) processed_init->protocol = "*";
   if (!processed_init->username) processed_init->username = "*";
   if (!processed_init->username) processed_init->username = "*";
@@ -963,26 +964,16 @@ tl::expected<url_pattern, url_pattern_errors> parse_url_pattern_impl(
   // If processedInit["protocol"] is a special scheme and processedInit["port"]
   // is a string which represents its corresponding default port in radix-10
   // using ASCII digits then set processedInit["port"] to the empty string.
-  if (scheme::is_special(*processed_init->protocol)) {
-    // TODO: Implement this.
+  // TODO: Optimization opportunity.
+  if (scheme::is_special(*processed_init->protocol) &&
+      std::to_string(scheme::get_special_port(*processed_init->protocol)) ==
+          processed_init->port) {
     processed_init->port = "";
   }
 
   // Let urlPattern be a new URL pattern.
   auto url_pattern_ = url_pattern{};
 
-  // Set urlPattern’s username component to the result of compiling a component
-  // given processedInit["username"], canonicalize a username, and default
-  // options.
-  auto username_component = url_pattern_component::compile(
-      processed_init->username.value(),
-      url_pattern_helpers::canonicalize_username,
-      url_pattern_compile_component_options::DEFAULT);
-  if (!username_component) {
-    return tl::unexpected(username_component.error());
-  }
-  url_pattern_.username_component = std::move(*username_component);
-
   // Set urlPattern’s protocol component to the result of compiling a component
   // given processedInit["protocol"], canonicalize a protocol, and default
   // options.
@@ -995,6 +986,18 @@ tl::expected<url_pattern, url_pattern_errors> parse_url_pattern_impl(
   }
   url_pattern_.protocol_component = std::move(*protocol_component);
 
+  // Set urlPattern’s username component to the result of compiling a component
+  // given processedInit["username"], canonicalize a username, and default
+  // options.
+  auto username_component = url_pattern_component::compile(
+      processed_init->username.value(),
+      url_pattern_helpers::canonicalize_username,
+      url_pattern_compile_component_options::DEFAULT);
+  if (!username_component) {
+    return tl::unexpected(username_component.error());
+  }
+  url_pattern_.username_component = std::move(*username_component);
+
   // Set urlPattern’s password component to the result of compiling a component
   // given processedInit["password"], canonicalize a password, and default
   // options.

src/unicode.cpp

@@ -272,6 +272,11 @@ ada_really_inline constexpr bool is_ascii_hex_digit(const char c) noexcept {
          (c >= 'a' && c <= 'f');
 }
 
+ada_really_inline constexpr bool is_ascii(const uint16_t c) noexcept {
+  // If code point is between U+0000 and U+007F inclusive, then return true.
+  return c <= 0x7F;
+}
+
 ada_really_inline constexpr bool is_c0_control_or_space(const char c) noexcept {
   return (unsigned char)c <= ' ';
 }

src/url_pattern_helpers.cpp

@@ -504,23 +504,23 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
     tokenizer.seek_and_get_next_code_point(tokenizer.index);
 
     // If tokenizer’s code point is U+002A (*):
-    if (tokenizer.code_point == "*") {
+    if (tokenizer.code_point == '*') {
       // Run add a token with default position and length given tokenizer and
       // "asterisk".
       tokenizer.add_token_with_defaults(token_type::ASTERISK);
       continue;
     }
 
     // If tokenizer’s code point is U+002B (+) or U+003F (?):
-    if (tokenizer.code_point == "+" || tokenizer.code_point == "?") {
+    if (tokenizer.code_point == '+' || tokenizer.code_point == '?') {
       // Run add a token with default position and length given tokenizer and
       // "other-modifier".
       tokenizer.add_token_with_defaults(token_type::OTHER_MODIFIER);
       continue;
     }
 
     // If tokenizer’s code point is U+005C (\):
-    if (tokenizer.code_point == "\\") {
+    if (tokenizer.code_point == '\\') {
       // If tokenizer’s index is equal to tokenizer’s input's code point length
       // − 1:
       if (tokenizer.index == tokenizer.input.size() - 1) {
@@ -546,23 +546,23 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
     }
 
     // If tokenizer’s code point is U+007B ({):
-    if (tokenizer.code_point == "{") {
+    if (tokenizer.code_point == '{') {
       // Run add a token with default position and length given tokenizer and
       // "open".
       tokenizer.add_token_with_defaults(token_type::OPEN);
       continue;
     }
 
     // If tokenizer’s code point is U+007D (}):
-    if (tokenizer.code_point == "}") {
+    if (tokenizer.code_point == '}') {
       // Run add a token with default position and length given tokenizer and
       // "close".
       tokenizer.add_token_with_defaults(token_type::CLOSE);
       continue;
     }
 
     // If tokenizer’s code point is U+003A (:):
-    if (tokenizer.code_point == ":") {
+    if (tokenizer.code_point == ':') {
       // Let name position be tokenizer’s next index.
       auto name_position = tokenizer.next_index;
       // Let name start be name position.
@@ -577,8 +577,8 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
         bool first_code_point = name_position == name_start;
         // Let valid code point be the result of running is a valid name code
         // point given tokenizer’s code point and first code point.
-        auto valid_code_point = is_valid_name_code_point(
-            tokenizer.code_point.at(0), first_code_point);
+        auto valid_code_point =
+            is_valid_name_code_point(tokenizer.code_point, first_code_point);
         // If valid code point is false break.
         if (!valid_code_point) break;
         // Set name position to tokenizer’s next index.
@@ -603,7 +603,7 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
     }
 
     // If tokenizer’s code point is U+0028 (():
-    if (tokenizer.code_point == "(") {
+    if (tokenizer.code_point == '(') {
       // Let depth be 1.
       size_t depth = 1;
       // Let regexp position be tokenizer’s next index.
@@ -622,8 +622,8 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
 
         // TODO: Optimization opportunity: The next 2 if statements can be
         // merged. If the result of running is ASCII given tokenizer’s code
-        // point is false:
-        if (!idna::is_ascii(tokenizer.code_point)) {
+        // point is false:i
+        if (!unicode::is_ascii(tokenizer.code_point)) {
           // Run process a tokenizing error given tokenizer, regexp start, and
           // tokenizer’s index.
           if (auto process_error = tokenizer.process_tokenizing_error(
@@ -638,7 +638,7 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
 
         // If regexp position equals regexp start and tokenizer’s code point is
         // U+003F (?):
-        if (regexp_position == regexp_start && tokenizer.code_point == "?") {
+        if (regexp_position == regexp_start && tokenizer.code_point == '?') {
           // Run process a tokenizing error given tokenizer, regexp start, and
           // tokenizer’s index.
           if (auto process_error = tokenizer.process_tokenizing_error(
@@ -652,7 +652,7 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
         }
 
         // If tokenizer’s code point is U+005C (\):
-        if (tokenizer.code_point == "\\") {
+        if (tokenizer.code_point == '\\') {
           // If regexp position equals tokenizer’s input's code point length − 1
           if (regexp_position == tokenizer.input.size() - 1) {
             // Run process a tokenizing error given tokenizer, regexp start, and
@@ -670,7 +670,7 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
           tokenizer.get_next_code_point();
           // If the result of running is ASCII given tokenizer’s code point is
           // false:
-          if (!idna::is_ascii(tokenizer.code_point)) {
+          if (!unicode::is_ascii(tokenizer.code_point)) {
             // Run process a tokenizing error given tokenizer, regexp start, and
             // tokenizer’s index.
             if (auto process_error = tokenizer.process_tokenizing_error(
@@ -688,15 +688,15 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
         }
 
         // If tokenizer’s code point is U+0029 ()):
-        if (tokenizer.code_point == ")") {
+        if (tokenizer.code_point == ')') {
           // Decrement depth by 1.
           depth--;
           if (depth == 0) {
             // Set regexp position to tokenizer’s next index.
             regexp_position = tokenizer.next_index;
             break;
           }
-        } else if (tokenizer.code_point == "(") {
+        } else if (tokenizer.code_point == '(') {
           // Otherwise if tokenizer’s code point is U+0028 (():
           // Increment depth by 1.
           depth++;
@@ -719,7 +719,7 @@ tl::expected<std::vector<Token>, url_pattern_errors> tokenize(
           // Run get the next code point given tokenizer.
           tokenizer.get_next_code_point();
           // If tokenizer’s code point is not U+003F (?):
-          if (tokenizer.code_point != "?") {
+          if (tokenizer.code_point != '?') {
             // Run process a tokenizing error given tokenizer, regexp start, and
             // tokenizer’s index.
             if (auto process_error = tokenizer.process_tokenizing_error(