Everywhere: Use to_number<T> instead of to_{int,uint,float,double}

In a bunch of cases, this actually ends up simplifying the code as
to_number will handle something such as:

```
Optional<I> opt;
if constexpr (IsSigned<I>)
    opt = view.to_int<I>();
else
    opt = view.to_uint<I>();
```

For us.

The main goal here however is to have a single generic number conversion
API between all of the String classes.

Userland/Utilities/asctl.cpp

@@ -105,7 +105,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
             }
             auto& variable = command_arguments[i];
             if (variable.is_one_of("v"sv, "volume"sv)) {
-                auto volume = command_arguments[++i].to_int();
+                auto volume = command_arguments[++i].to_number<int>();
                 if (!volume.has_value()) {
                     warnln("Error: {} is not an integer volume", command_arguments[i - 1]);
                     return 1;
@@ -128,7 +128,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
                 }
                 values_to_set.set(AudioVariable::Mute, mute);
             } else if (variable.is_one_of("r"sv, "samplerate"sv)) {
-                auto sample_rate = command_arguments[++i].to_int();
+                auto sample_rate = command_arguments[++i].to_number<int>();
                 if (!sample_rate.has_value()) {
                     warnln("Error: {} is not an integer sample rate", command_arguments[i - 1]);
                     return 1;

Userland/Utilities/bt.cpp

@@ -33,7 +33,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     }
 
     while (iterator.has_next()) {
-        pid_t tid = iterator.next_path().to_int().value();
+        pid_t tid = iterator.next_path().to_number<pid_t>().value();
         outln("thread: {}", tid);
         outln("frames:");
         auto symbols = Symbolication::symbolicate_thread(pid, tid);

Userland/Utilities/chgrp.cpp

@@ -31,7 +31,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         return 1;
     }
 
-    auto number = gid_arg.to_uint();
+    auto number = gid_arg.to_number<unsigned>();
     if (number.has_value()) {
         new_gid = number.value();
     } else {

Userland/Utilities/chown.cpp

@@ -44,7 +44,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         return 1;
     }
 
-    auto number = parts[0].to_uint();
+    auto number = parts[0].to_number<uid_t>();
     if (number.has_value()) {
         new_uid = number.value();
     } else {
@@ -57,7 +57,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     }
 
     if (parts.size() == 2) {
-        auto number = parts[1].to_uint();
+        auto number = parts[1].to_number<gid_t>();
         if (number.has_value()) {
             new_gid = number.value();
         } else {

Userland/Utilities/cut.cpp

@@ -49,7 +49,7 @@ static bool expand_list(ByteString& list, Vector<Range>& ranges)
         }
 
         if (token[0] == '-') {
-            auto index = token.substring(1, token.length() - 1).to_uint();
+            auto index = token.substring(1, token.length() - 1).to_number<unsigned>();
             if (!index.has_value()) {
                 warnln("cut: invalid byte/character position '{}'", token);
                 return false;
@@ -62,7 +62,7 @@ static bool expand_list(ByteString& list, Vector<Range>& ranges)
 
             ranges.append({ 1, index.value() });
         } else if (token[token.length() - 1] == '-') {
-            auto index = token.substring(0, token.length() - 1).to_uint();
+            auto index = token.substring(0, token.length() - 1).to_number<unsigned>();
             if (!index.has_value()) {
                 warnln("cut: invalid byte/character position '{}'", token);
                 return false;
@@ -77,13 +77,13 @@ static bool expand_list(ByteString& list, Vector<Range>& ranges)
         } else {
             auto range = token.split('-', SplitBehavior::KeepEmpty);
             if (range.size() == 2) {
-                auto index1 = range[0].to_uint();
+                auto index1 = range[0].to_number<unsigned>();
                 if (!index1.has_value()) {
                     warnln("cut: invalid byte/character position '{}'", range[0]);
                     return false;
                 }
 
-                auto index2 = range[1].to_uint();
+                auto index2 = range[1].to_number<unsigned>();
                 if (!index2.has_value()) {
                     warnln("cut: invalid byte/character position '{}'", range[1]);
                     return false;
@@ -99,7 +99,7 @@ static bool expand_list(ByteString& list, Vector<Range>& ranges)
 
                 ranges.append({ index1.value(), index2.value() });
             } else if (range.size() == 1) {
-                auto index = range[0].to_uint();
+                auto index = range[0].to_number<unsigned>();
                 if (!index.has_value()) {
                     warnln("cut: invalid byte/character position '{}'", range[0]);
                     return false;

Userland/Utilities/date.cpp

@@ -31,7 +31,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     args_parser.parse(arguments);
 
     if (!set_date.is_empty()) {
-        auto number = set_date.to_uint();
+        auto number = set_date.to_number<unsigned>();
 
         if (!number.has_value()) {
             warnln("date: Invalid timestamp value");

Userland/Utilities/dd.cpp

@@ -116,7 +116,7 @@ static int handle_size_arguments(size_t& numeric_value, StringView argument)
         break;
     }
 
-    Optional<unsigned> numeric_optional = value.to_uint();
+    Optional<unsigned> numeric_optional = value.to_number<unsigned>();
     if (!numeric_optional.has_value()) {
         warnln("Invalid size-value: {}", value);
         return -1;

Userland/Utilities/errno.cpp

@@ -55,7 +55,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         return 0;
     }
 
-    if (auto maybe_error_code = keyword.to_int(); maybe_error_code.has_value()) {
+    if (auto maybe_error_code = keyword.to_number<int>(); maybe_error_code.has_value()) {
         auto error_code = maybe_error_code.value();
         auto error = strerror(error_code);
         if (error == "Unknown error"sv) {

Userland/Utilities/expr.cpp

@@ -90,7 +90,7 @@ private:
         case Type::Integer:
             return as_integer;
         case Type::String:
-            if (auto converted = as_string.to_int(); converted.has_value())
+            if (auto converted = as_string.to_number<int>(); converted.has_value())
                 return converted.value();
             fail("Not an integer: '{}'", as_string);
         }
@@ -371,7 +371,7 @@ private:
     {
         if (m_op == StringOperation::Substring || m_op == StringOperation::Match) {
             auto substr = string();
-            if (auto integer = substr.to_int(); integer.has_value())
+            if (auto integer = substr.to_number<int>(); integer.has_value())
                 return integer.value();
             else
                 fail("Not an integer: '{}'", substr);

Userland/Utilities/find.cpp

@@ -133,7 +133,7 @@ public:
             arg = arg.substring_view(1);
         }
 
-        auto maybe_value = arg.to_uint<T>();
+        auto maybe_value = arg.to_number<T>();
         if (!maybe_value.has_value())
             return Error::from_errno(EINVAL);
 
@@ -192,7 +192,7 @@ public:
     MaxDepthCommand(char const* arg)
     {
         auto max_depth_string = StringView { arg, strlen(arg) };
-        auto maybe_max_depth = max_depth_string.to_uint<u32>();
+        auto maybe_max_depth = max_depth_string.to_number<u32>();
         if (!maybe_max_depth.has_value())
             fatal_error("-maxdepth: '{}' is not a valid non-negative integer", arg);
 
@@ -210,7 +210,7 @@ public:
     MinDepthCommand(char const* arg)
     {
         auto min_depth_string = StringView { arg, strlen(arg) };
-        auto maybe_min_depth = min_depth_string.to_uint<u32>();
+        auto maybe_min_depth = min_depth_string.to_number<u32>();
         if (!maybe_min_depth.has_value())
             fatal_error("-mindepth: '{}' is not a valid non-negative integer", arg);
 
@@ -296,7 +296,7 @@ public:
             m_uid = passwd->pw_uid;
         } else {
             // Attempt to parse it as decimal UID.
-            auto number = StringView { arg, strlen(arg) }.to_uint<uid_t>();
+            auto number = StringView { arg, strlen(arg) }.to_number<uid_t>();
             if (!number.has_value())
                 fatal_error("Invalid user: \033[1m{}", arg);
             m_uid = number.value();
@@ -320,7 +320,7 @@ public:
             m_gid = gr->gr_gid;
         } else {
             // Attempt to parse it as decimal GID.
-            auto number = StringView { arg, strlen(arg) }.to_uint<gid_t>();
+            auto number = StringView { arg, strlen(arg) }.to_number<gid_t>();
             if (!number.has_value())
                 fatal_error("Invalid group: \033[1m{}", arg);
             m_gid = number.value();

Userland/Utilities/id.cpp

@@ -50,7 +50,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
 
     Optional<Core::Account> account;
     if (!user_str.is_empty()) {
-        if (auto user_id = user_str.to_uint(); user_id.has_value())
+        if (auto user_id = user_str.to_number<uid_t>(); user_id.has_value())
             account = TRY(Core::Account::from_uid(user_id.value(), Core::Account::Read::PasswdOnly));
         else
             account = TRY(Core::Account::from_name(user_str, Core::Account::Read::PasswdOnly));

Userland/Utilities/json.cpp

@@ -141,7 +141,7 @@ JsonValue query(JsonValue const& value, Vector<StringView>& key_parts, size_t ke
     if (value.is_object()) {
         result = value.as_object().get(key).value_or({});
     } else if (value.is_array()) {
-        auto key_as_index = key.to_int();
+        auto key_as_index = key.to_number<int>();
         if (key_as_index.has_value())
             result = value.as_array().at(key_as_index.value());
     }

Userland/Utilities/kill.cpp

@@ -61,7 +61,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         }
 
         if (!number.has_value())
-            number = strings[1].substring_view(1).to_uint();
+            number = strings[1].substring_view(1).to_number<unsigned>();
 
         if (!number.has_value()) {
             warnln("'{}' is not a valid signal name or number", &strings[1][1]);
@@ -69,7 +69,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         }
         signum = number.value();
     }
-    auto pid_opt = strings[pid_argi].to_int();
+    auto pid_opt = strings[pid_argi].to_number<pid_t>();
     if (!pid_opt.has_value()) {
         warnln("'{}' is not a valid PID", strings[pid_argi]);
         return 3;

Userland/Utilities/killall.cpp

@@ -56,7 +56,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         }
 
         if (!number.has_value())
-            number = arguments.strings[1].substring_view(1).to_uint();
+            number = arguments.strings[1].substring_view(1).to_number<unsigned>();
 
         if (!number.has_value()) {
             warnln("'{}' is not a valid signal name or number", &arguments.argv[1][1]);

Userland/Utilities/less.cpp

@@ -616,7 +616,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
 
         auto const& sequence = sequence_value.value();
 
-        if (sequence.to_uint().has_value()) {
+        if (sequence.to_number<unsigned>().has_value()) {
             modifier_buffer.append(sequence);
         } else {
             if (sequence == "" || sequence == "q" || sequence == "Q") {
@@ -624,28 +624,28 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
             } else if (sequence == "j" || sequence == "\e[B" || sequence == "\n") {
                 if (!emulate_more) {
                     if (!modifier_buffer.is_empty())
-                        pager.down_n(modifier_buffer.to_byte_string().to_uint().value_or(1));
+                        pager.down_n(modifier_buffer.to_byte_string().to_number<unsigned>().value_or(1));
                     else
                         pager.down();
                 }
             } else if (sequence == "k" || sequence == "\e[A") {
                 if (!emulate_more) {
                     if (!modifier_buffer.is_empty())
-                        pager.up_n(modifier_buffer.to_byte_string().to_uint().value_or(1));
+                        pager.up_n(modifier_buffer.to_byte_string().to_number<unsigned>().value_or(1));
                     else
                         pager.up();
                 }
             } else if (sequence == "g") {
                 if (!emulate_more) {
                     if (!modifier_buffer.is_empty())
-                        pager.go_to_line(modifier_buffer.to_byte_string().to_uint().value());
+                        pager.go_to_line(modifier_buffer.to_byte_string().to_number<unsigned>().value());
                     else
                         pager.top();
                 }
             } else if (sequence == "G") {
                 if (!emulate_more) {
                     if (!modifier_buffer.is_empty())
-                        pager.go_to_line(modifier_buffer.to_byte_string().to_uint().value());
+                        pager.go_to_line(modifier_buffer.to_byte_string().to_number<unsigned>().value());
                     else
                         pager.bottom();
                 }

Userland/Utilities/lsof.cpp

@@ -136,7 +136,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     }
     {
         // try convert UID to int
-        auto arg = ByteString(arg_uid).to_int();
+        auto arg = ByteString(arg_uid).to_number<int>();
         if (arg.has_value())
             arg_uid_int = arg.value();
     }

Userland/Utilities/mknod.cpp

@@ -60,8 +60,8 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         return 1;
     }
 
-    auto maybe_major = major_string.to_int();
-    auto maybe_minor = minor_string.to_int();
+    auto maybe_major = major_string.to_number<int>();
+    auto maybe_minor = minor_string.to_number<int>();
     dev_t device;
     if (type == 'p') {
         if (maybe_major.has_value() || maybe_minor.has_value()) {

Userland/Utilities/pgrep.cpp

@@ -48,7 +48,7 @@ ErrorOr<int> serenity_main(Main::Arguments args)
         .short_name = 'O',
         .value_name = "seconds",
         .accept_value = [&display_if_older_than](StringView seconds_string) {
-            auto number = seconds_string.to_uint<u64>();
+            auto number = seconds_string.to_number<u64>();
 
             if (number.has_value() && number.value() <= NumericLimits<i64>::max()) {
                 auto now_time = UnixDateTime::now();
@@ -66,7 +66,7 @@ ErrorOr<int> serenity_main(Main::Arguments args)
         .value_name = "uid-list",
         .accept_value = [&uids_to_filter_by](StringView comma_separated_users) {
             for (auto user_string : comma_separated_users.split_view(',')) {
-                auto maybe_uid = user_string.to_uint<uid_t>();
+                auto maybe_uid = user_string.to_number<uid_t>();
                 if (maybe_uid.has_value()) {
                     uids_to_filter_by.set(maybe_uid.value());
                 } else {

Userland/Utilities/pidof.cpp

@@ -71,7 +71,7 @@ ErrorOr<int> serenity_main(Main::Arguments args)
                 return true;
             }
 
-            auto number = omit_pid_value.to_uint();
+            auto number = omit_pid_value.template to_number<pid_t>();
             if (!number.has_value())
                 return false;
 

Userland/Utilities/ping.cpp

@@ -76,7 +76,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
             if (interval_in_seconds_string.is_empty())
                 return false;
 
-            auto interval_in_seconds = interval_in_seconds_string.to_double();
+            auto interval_in_seconds = interval_in_seconds_string.to_number<double>();
             if (!interval_in_seconds.has_value() || interval_in_seconds.value() <= 0 || interval_in_seconds.value() > UINT32_MAX)
                 return false;
 

Userland/Utilities/pixelflut.cpp

@@ -43,7 +43,7 @@ ErrorOr<NonnullRefPtr<Client>> Client::create(StringView image_path, StringView
 {
     // Extract hostname and port and connect to server.
     auto parts = server.split_view(':');
-    auto maybe_port = parts.take_last().to_uint();
+    auto maybe_port = parts.take_last().to_number<unsigned>();
     if (!maybe_port.has_value())
         return Error::from_string_view("Invalid port number"sv);
 
@@ -60,8 +60,8 @@ ErrorOr<NonnullRefPtr<Client>> Client::create(StringView image_path, StringView
         return Error::from_string_view("Server didn't return size correctly"sv);
 
     auto size_parts = size_line.split_view(' ');
-    auto maybe_width = size_parts[1].to_uint();
-    auto maybe_height = size_parts[2].to_uint();
+    auto maybe_width = size_parts[1].to_number<unsigned>();
+    auto maybe_height = size_parts[2].to_number<unsigned>();
     if (!maybe_width.has_value() || !maybe_height.has_value())
         return Error::from_string_view("Width or height invalid"sv);
 

Userland/Utilities/pkill.cpp

@@ -50,7 +50,7 @@ ErrorOr<int> serenity_main(Main::Arguments args)
         .short_name = 'O',
         .value_name = "seconds",
         .accept_value = [&display_if_older_than](StringView seconds_string) {
-            auto number = seconds_string.to_uint<u64>();
+            auto number = seconds_string.to_number<u64>();
 
             if (number.has_value() && number.value() <= NumericLimits<i64>::max()) {
                 auto now_time = UnixDateTime::now();
@@ -72,7 +72,7 @@ ErrorOr<int> serenity_main(Main::Arguments args)
 
             if (is_ascii_alpha(signal_string[0]))
                 signal = getsignalbyname(&signal_string[0]);
-            else if (auto maybe_signal = signal_string.to_int(); maybe_signal.has_value())
+            else if (auto maybe_signal = signal_string.to_number<int>(); maybe_signal.has_value())
                 signal = maybe_signal.value();
 
             if (signal <= 0 || signal >= NSIG)
@@ -89,7 +89,7 @@ ErrorOr<int> serenity_main(Main::Arguments args)
         .value_name = "uid-list",
         .accept_value = [&uids_to_filter_by](StringView comma_separated_users) {
             for (auto user_string : comma_separated_users.split_view(',')) {
-                auto maybe_uid = user_string.to_uint<uid_t>();
+                auto maybe_uid = user_string.to_number<uid_t>();
                 if (maybe_uid.has_value()) {
                     uids_to_filter_by.set(maybe_uid.value());
                 } else {

Userland/Utilities/pmemdump.cpp

@@ -22,10 +22,10 @@
 static bool try_set_offset_and_length_parameters(ByteString const& arg_offset, ByteString const& arg_length, u64& offset, u64& length)
 {
     // TODO: Add support for hex values
-    auto possible_offset = arg_offset.to_uint<u64>();
+    auto possible_offset = arg_offset.to_number<u64>();
     if (!possible_offset.has_value())
         return false;
-    auto possible_length = arg_length.to_uint<u64>();
+    auto possible_length = arg_length.to_number<u64>();
     if (!possible_length.has_value())
         return false;
     offset = possible_offset.value();

Userland/Utilities/profile.cpp

@@ -130,5 +130,5 @@ static Optional<pid_t> determine_pid_to_profile(StringView pid_argument, bool al
     }
 
     // pid_argument is guaranteed to have a value
-    return pid_argument.to_int();
+    return pid_argument.to_number<pid_t>();
 }

Userland/Utilities/ps.cpp

@@ -248,21 +248,21 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     }));
     args_parser.add_option(make_list_option(pid_list, "Show processes with a matching PID. (Comma- or space-separated list)", nullptr, 'p', "pid-list", [&](StringView pid_string) {
         provided_filtering_option = true;
-        auto pid = pid_string.to_int();
+        auto pid = pid_string.to_number<int>();
         if (!pid.has_value())
             warnln("Could not parse '{}' as a PID.", pid_string);
         return pid;
     }));
     args_parser.add_option(make_list_option(parent_pid_list, "Show processes with a matching PPID. (Comma- or space-separated list.)", "ppid", {}, "pid-list", [&](StringView pid_string) {
         provided_filtering_option = true;
-        auto pid = pid_string.to_int();
+        auto pid = pid_string.to_number<int>();
         if (!pid.has_value())
             warnln("Could not parse '{}' as a PID.", pid_string);
         return pid;
     }));
     args_parser.add_option(make_list_option(pid_list, "Show processes with a matching PID. (Comma- or space-separated list.) Processes will be listed in the order given.", nullptr, 'q', "pid-list", [&](StringView pid_string) {
         provided_quick_pid_list = true;
-        auto pid = pid_string.to_int();
+        auto pid = pid_string.to_number<int>();
         if (!pid.has_value())
             warnln("Could not parse '{}' as a PID.", pid_string);
         return pid;
@@ -278,7 +278,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
     }));
     args_parser.add_option(make_list_option(uid_list, "Show processes with a matching user ID or login name. (Comma- or space-separated list.)", nullptr, 'u', "user-list", [&](StringView user_string) -> Optional<uid_t> {
         provided_filtering_option = true;
-        if (auto uid = user_string.to_uint<uid_t>(); uid.has_value()) {
+        if (auto uid = user_string.to_number<uid_t>(); uid.has_value()) {
             return uid.value();
         }
 

Userland/Utilities/route.cpp

@@ -182,7 +182,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         }
 
         Optional<IPv4Address> genmask;
-        if (auto cidr_int = cidr.to_int(); cidr_int.has_value())
+        if (auto cidr_int = cidr.to_number<int>(); cidr_int.has_value())
             genmask = AK::IPv4Address::netmask_from_cidr(cidr_int.value());
         else
             genmask = AK::IPv4Address::from_string(value_netmask_address);

Userland/Utilities/seq.cpp

@@ -28,7 +28,7 @@ static void print_usage(FILE* stream)
 
 static double get_double(char const* name, StringView d_string, size_t* number_of_decimals)
 {
-    auto d = d_string.to_double();
+    auto d = d_string.to_number<double>();
     if (!d.has_value()) {
         warnln("{}: invalid argument \"{}\"", name, d_string);
         print_usage(stderr);

Userland/Utilities/sort.cpp

@@ -82,7 +82,7 @@ static ErrorOr<void> load_file(Options const& options, StringView filename, Stri
             }
         }
 
-        Line l = { key, key.to_int().value_or(0), line, options.numeric };
+        Line l = { key, key.to_number<int>().value_or(0), line, options.numeric };
 
         if (!options.unique || !seen.contains(l)) {
             lines.append(l);

Userland/Utilities/stty.cpp

@@ -298,14 +298,14 @@ Result<void, int> apply_modes(size_t parameter_count, char** raw_parameters, ter
         parameters.append(StringView { raw_parameters[i], strlen(raw_parameters[i]) });
 
     auto parse_baud = [&](size_t idx) -> Optional<speed_t> {
-        auto maybe_numeric_value = parameters[idx].to_uint<uint32_t>();
+        auto maybe_numeric_value = parameters[idx].to_number<uint32_t>();
         if (maybe_numeric_value.has_value())
             return numeric_value_to_speed(maybe_numeric_value.value());
         return {};
     };
 
     auto parse_number = [&](size_t idx) -> Optional<cc_t> {
-        return parameters[idx].to_uint<cc_t>();
+        return parameters[idx].to_number<cc_t>();
     };
 
     auto looks_like_stty_readable = [&](size_t idx) {
@@ -355,7 +355,7 @@ Result<void, int> apply_modes(size_t parameter_count, char** raw_parameters, ter
             }
             return value;
         } else if (is_ascii_digit(parameters[idx][0])) {
-            auto maybe_value = parameters[idx].to_uint<cc_t>();
+            auto maybe_value = parameters[idx].to_number<cc_t>();
             if (!maybe_value.has_value()) {
                 warnln("Invalid decimal character code {}", parameters[idx]);
                 return {};

Userland/Utilities/syscall.cpp

@@ -175,7 +175,7 @@ static FlatPtr parse_from(ArgIter& iter)
         return parse_parameter_buffer(iter);
 
     // Is it a number?
-    if (auto l = this_arg_string.to_uint(); l.has_value())
+    if (auto l = this_arg_string.to_number<unsigned>(); l.has_value())
         return *l;
 
     // Then it must be a string:

Userland/Utilities/test.cpp

@@ -306,8 +306,8 @@ public:
     NumericCompare(ByteString lhs, ByteString rhs, Mode mode)
         : m_mode(mode)
     {
-        auto lhs_option = lhs.trim_whitespace().to_int();
-        auto rhs_option = rhs.trim_whitespace().to_int();
+        auto lhs_option = lhs.trim_whitespace().to_number<int>();
+        auto rhs_option = rhs.trim_whitespace().to_number<int>();
 
         if (!lhs_option.has_value())
             fatal_error("expected integer expression: '%s'", lhs.characters());

Userland/Utilities/top.cpp

@@ -179,7 +179,7 @@ static void parse_args(Main::Arguments arguments, TopOption& top_option)
         .short_name = 'p',
         .accept_value = [&pids](auto comma_separated_pids) {
             for (auto pid : comma_separated_pids.split_view(',')) {
-                auto maybe_integer = pid.to_int();
+                auto maybe_integer = pid.template to_number<pid_t>();
                 if (!maybe_integer.has_value())
                     return false;
 

Userland/Utilities/touch.cpp

@@ -54,7 +54,7 @@ static void parse_time(StringView input_time, timespec& atime, timespec& mtime)
         auto literal = lexer.consume(2);
         if (literal.length() < 2)
             err("invalid time format '{}' -- expected 2 digits per parameter", input_time);
-        auto maybe_parameter = literal.to_uint();
+        auto maybe_parameter = literal.to_number<unsigned>();
         if (maybe_parameter.has_value())
             parameters.append(maybe_parameter.value());
         else
@@ -102,7 +102,7 @@ static void parse_datetime(StringView input_datetime, timespec& atime, timespec&
     StringView time_zone;
 
     auto lex_number = [&](unsigned& value, size_t n) {
-        auto maybe_value = lexer.consume(n).to_uint();
+        auto maybe_value = lexer.consume(n).to_number<unsigned>();
         if (!maybe_value.has_value())
             err("invalid datetime format '{}' -- expected number at index {}", input_datetime, lexer.tell());
         else

Userland/Utilities/truncate.cpp

@@ -76,7 +76,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
             }
         }
 
-        auto size_opt = resize.to_int<off_t>();
+        auto size_opt = resize.to_number<off_t>();
         if (!size_opt.has_value() || Checked<off_t>::multiplication_would_overflow(size_opt.value(), multiplier)) {
             args_parser.print_usage(stderr, arguments.strings[0]);
             return 1;

Userland/Utilities/useradd.cpp

@@ -31,7 +31,7 @@ constexpr auto DEFAULT_SHELL = "/bin/sh"sv;
 
 static Optional<gid_t> group_string_to_gid(StringView group)
 {
-    auto maybe_gid = group.to_uint<gid_t>();
+    auto maybe_gid = group.to_number<gid_t>();
     auto maybe_group_or_error = maybe_gid.has_value()
         ? Core::System::getgrgid(maybe_gid.value())
         : Core::System::getgrnam(group);

Userland/Utilities/usermod.cpp

@@ -17,7 +17,7 @@
 
 static Optional<gid_t> group_string_to_gid(StringView group)
 {
-    auto maybe_gid = group.to_uint<gid_t>();
+    auto maybe_gid = group.to_number<gid_t>();
     auto maybe_group_or_error = maybe_gid.has_value()
         ? Core::System::getgrgid(maybe_gid.value())
         : Core::System::getgrnam(group);

Userland/Utilities/wasm.cpp

@@ -122,7 +122,7 @@ static bool pre_interpret_hook(Wasm::Configuration& config, Wasm::InstructionPoi
                     warnln("print what memory?");
                     continue;
                 }
-                auto value = args[2].to_uint<u64>();
+                auto value = args[2].to_number<u64>();
                 if (!value.has_value()) {
                     warnln("invalid memory index {}", args[2]);
                     continue;
@@ -144,7 +144,7 @@ static bool pre_interpret_hook(Wasm::Configuration& config, Wasm::InstructionPoi
                     warnln("print what function?");
                     continue;
                 }
-                auto value = args[2].to_uint<u64>();
+                auto value = args[2].to_number<u64>();
                 if (!value.has_value()) {
                     warnln("invalid function index {}", args[2]);
                     continue;
@@ -170,7 +170,7 @@ static bool pre_interpret_hook(Wasm::Configuration& config, Wasm::InstructionPoi
                 continue;
             }
             Optional<Wasm::FunctionAddress> address;
-            auto index = args[1].to_uint<u64>();
+            auto index = args[1].to_number<u64>();
             if (index.has_value()) {
                 address = config.frame().module().functions()[index.value()];
             } else {
@@ -203,7 +203,7 @@ static bool pre_interpret_hook(Wasm::Configuration& config, Wasm::InstructionPoi
             Vector<u64> values_to_push;
             Vector<Wasm::Value> values;
             for (size_t index = 2; index < args.size(); ++index)
-                values_to_push.append(args[index].to_uint().value_or(0));
+                values_to_push.append(args[index].to_number<u64>().value_or(0));
             for (auto& param : type.parameters())
                 values.append(Wasm::Value { param, values_to_push.take_last() });
 
@@ -332,7 +332,7 @@ ErrorOr<int> serenity_main(Main::Arguments arguments)
         .short_name = 0,
         .value_name = "u64",
         .accept_value = [&](StringView str) -> bool {
-            if (auto v = str.to_uint<u64>(); v.has_value()) {
+            if (auto v = str.to_number<u64>(); v.has_value()) {
                 values_to_push.append(v.value());
                 return true;
             }