From 5f950df3d4cbfd65cd98221240b39df0bc2653c9 Mon Sep 17 00:00:00 2001 From: Ali Mohammad Pur Date: Sat, 18 Feb 2023 17:14:19 +0330 Subject: Shell: Make Immediate expression invocation fallible This removes a whole bunch of FIXMEs in the immediate expr implementations as well :^) --- Userland/Shell/AST.cpp | 2 +- Userland/Shell/ImmediateFunctions.cpp | 150 +++++++++++++++++----------------- Userland/Shell/Shell.h | 6 +- 3 files changed, 79 insertions(+), 79 deletions(-) diff --git a/Userland/Shell/AST.cpp b/Userland/Shell/AST.cpp index a964b34a7b..ffd263fe2d 100644 --- a/Userland/Shell/AST.cpp +++ b/Userland/Shell/AST.cpp @@ -2048,7 +2048,7 @@ ErrorOr ImmediateExpression::dump(int level) const RefPtr ImmediateExpression::run(RefPtr shell) { - auto node = shell->run_immediate_function(m_function.name, *this, arguments()); + auto node = shell->run_immediate_function(m_function.name, *this, arguments()).release_value_but_fixme_should_propagate_errors(); if (node) return node->run(shell); diff --git a/Userland/Shell/ImmediateFunctions.cpp b/Userland/Shell/ImmediateFunctions.cpp index 7a0d1e2f31..4925c8dbb0 100644 --- a/Userland/Shell/ImmediateFunctions.cpp +++ b/Userland/Shell/ImmediateFunctions.cpp @@ -10,7 +10,7 @@ namespace Shell { -RefPtr Shell::immediate_length_impl(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments, bool across) +ErrorOr> Shell::immediate_length_impl(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments, bool across) { auto name = across ? "length_across" : "length"; if (arguments.size() < 1 || arguments.size() > 2) { @@ -59,18 +59,18 @@ RefPtr Shell::immediate_length_impl(AST::ImmediateExpression& invokin if (expr_node->is_list()) mode = List; else if (expr_node->is_simple_variable()) // "Look inside" variables - mode = const_cast(expr_node)->run(this)->resolve_without_cast(this).release_value_but_fixme_should_propagate_errors()->is_list_without_resolution() ? List : String; + mode = TRY(const_cast(expr_node)->run(this)->resolve_without_cast(this))->is_list_without_resolution() ? List : String; else if (is(expr_node)) mode = List; else mode = String; } - auto value_with_number = [&](auto number) -> NonnullRefPtr { - return AST::make_ref_counted(invoking_node.position(), String::number(number).release_value_but_fixme_should_propagate_errors()); + auto value_with_number = [&](auto number) -> ErrorOr> { + return AST::make_ref_counted(invoking_node.position(), TRY(String::number(number))); }; - auto do_across = [&](StringView mode_name, auto& values) { + auto do_across = [&](StringView mode_name, auto& values) -> ErrorOr> { if (is_inferred) mode_name = "infer"sv; // Translate to a list of applications of `length ` @@ -80,9 +80,9 @@ RefPtr Shell::immediate_length_impl(AST::ImmediateExpression& invokin // ImmediateExpression(length ) resulting_nodes.unchecked_append(AST::make_ref_counted( expr_node->position(), - AST::NameWithPosition { String::from_utf8("length"sv).release_value_but_fixme_should_propagate_errors(), invoking_node.function_position() }, + AST::NameWithPosition { TRY(String::from_utf8("length"sv)), invoking_node.function_position() }, NonnullRefPtrVector { Vector> { - static_cast>(AST::make_ref_counted(expr_node->position(), String::from_utf8(mode_name).release_value_but_fixme_should_propagate_errors())), + static_cast>(AST::make_ref_counted(expr_node->position(), TRY(String::from_utf8(mode_name)))), AST::make_ref_counted(expr_node->position(), NonnullRefPtr(entry)), } }, expr_node->position())); @@ -100,7 +100,7 @@ RefPtr Shell::immediate_length_impl(AST::ImmediateExpression& invokin if (!value) return value_with_number(0); - value = value->resolve_without_cast(this).release_value_but_fixme_should_propagate_errors(); + value = TRY(value->resolve_without_cast(this)); if (auto list = dynamic_cast(value.ptr())) { if (across) @@ -109,7 +109,7 @@ RefPtr Shell::immediate_length_impl(AST::ImmediateExpression& invokin return value_with_number(list->values().size()); } - auto list = value->resolve_as_list(this).release_value_but_fixme_should_propagate_errors(); + auto list = TRY(value->resolve_as_list(this)); if (!across) return value_with_number(list.size()); @@ -145,7 +145,7 @@ RefPtr Shell::immediate_length_impl(AST::ImmediateExpression& invokin if (!value) return value_with_number(0); - value = value->resolve_without_cast(*this).release_value_but_fixme_should_propagate_errors(); + value = TRY(value->resolve_without_cast(*this)); if (auto list = dynamic_cast(value.ptr())) { if (!across) @@ -165,7 +165,7 @@ RefPtr Shell::immediate_length_impl(AST::ImmediateExpression& invokin } // Evaluate the nodes and substitute with the lengths. - auto list = value->resolve_as_list(this).release_value_but_fixme_should_propagate_errors(); + auto list = TRY(value->resolve_as_list(this)); if (!expr_node->is_list()) { if (list.size() == 1) { @@ -189,17 +189,17 @@ RefPtr Shell::immediate_length_impl(AST::ImmediateExpression& invokin } } -RefPtr Shell::immediate_length(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_length(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { return immediate_length_impl(invoking_node, arguments, false); } -RefPtr Shell::immediate_length_across(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_length_across(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { return immediate_length_impl(invoking_node, arguments, true); } -RefPtr Shell::immediate_regex_replace(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_regex_replace(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 3) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 3 arguments to regex_replace", invoking_node.position()); @@ -208,7 +208,7 @@ RefPtr Shell::immediate_regex_replace(AST::ImmediateExpression& invok auto pattern = const_cast(arguments[0]).run(this); auto replacement = const_cast(arguments[1]).run(this); - auto value = const_cast(arguments[2]).run(this)->resolve_without_cast(this).release_value_but_fixme_should_propagate_errors(); + auto value = TRY(const_cast(arguments[2]).run(this)->resolve_without_cast(this)); if (!pattern->is_string()) { raise_error(ShellError::EvaluatedSyntaxError, "Expected the regex_replace pattern to be a string", arguments[0].position()); @@ -225,16 +225,16 @@ RefPtr Shell::immediate_regex_replace(AST::ImmediateExpression& invok return nullptr; } - Regex re { pattern->resolve_as_list(this).release_value_but_fixme_should_propagate_errors().first().to_deprecated_string() }; + Regex re { TRY(pattern->resolve_as_list(this)).first().to_deprecated_string() }; auto result = re.replace( - value->resolve_as_list(this).release_value_but_fixme_should_propagate_errors()[0], - replacement->resolve_as_list(this).release_value_but_fixme_should_propagate_errors()[0], + TRY(value->resolve_as_list(this))[0], + TRY(replacement->resolve_as_list(this))[0], PosixFlags::Global | PosixFlags::Multiline | PosixFlags::Unicode); - return AST::make_ref_counted(invoking_node.position(), String::from_utf8(result).release_value_but_fixme_should_propagate_errors(), AST::StringLiteral::EnclosureType::None); + return AST::make_ref_counted(invoking_node.position(), TRY(String::from_utf8(result)), AST::StringLiteral::EnclosureType::None); } -RefPtr Shell::immediate_remove_suffix(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_remove_suffix(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to remove_suffix", invoking_node.position()); @@ -242,23 +242,23 @@ RefPtr Shell::immediate_remove_suffix(AST::ImmediateExpression& invok } auto suffix = const_cast(arguments[0]).run(this); - auto value = const_cast(arguments[1]).run(this)->resolve_without_cast(this).release_value_but_fixme_should_propagate_errors(); + auto value = TRY(const_cast(arguments[1]).run(this)->resolve_without_cast(this)); if (!suffix->is_string()) { raise_error(ShellError::EvaluatedSyntaxError, "Expected the remove_suffix suffix string to be a string", arguments[0].position()); return nullptr; } - auto suffix_str = suffix->resolve_as_list(this).release_value_but_fixme_should_propagate_errors()[0]; - auto values = value->resolve_as_list(this).release_value_but_fixme_should_propagate_errors(); + auto suffix_str = TRY(suffix->resolve_as_list(this))[0]; + auto values = TRY(value->resolve_as_list(this)); Vector> nodes; for (auto& value_str : values) { - String removed = String::from_utf8(value_str).release_value_but_fixme_should_propagate_errors(); + String removed = TRY(String::from_utf8(value_str)); if (value_str.bytes_as_string_view().ends_with(suffix_str)) - removed = removed.substring_from_byte_offset(0, value_str.bytes_as_string_view().length() - suffix_str.bytes_as_string_view().length()).release_value_but_fixme_should_propagate_errors(); + removed = TRY(removed.substring_from_byte_offset(0, value_str.bytes_as_string_view().length() - suffix_str.bytes_as_string_view().length())); nodes.append(AST::make_ref_counted(invoking_node.position(), move(removed), AST::StringLiteral::EnclosureType::None)); } @@ -266,7 +266,7 @@ RefPtr Shell::immediate_remove_suffix(AST::ImmediateExpression& invok return AST::make_ref_counted(invoking_node.position(), move(nodes)); } -RefPtr Shell::immediate_remove_prefix(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_remove_prefix(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to remove_prefix", invoking_node.position()); @@ -274,30 +274,30 @@ RefPtr Shell::immediate_remove_prefix(AST::ImmediateExpression& invok } auto prefix = const_cast(arguments[0]).run(this); - auto value = const_cast(arguments[1]).run(this)->resolve_without_cast(this).release_value_but_fixme_should_propagate_errors(); + auto value = TRY(const_cast(arguments[1]).run(this)->resolve_without_cast(this)); if (!prefix->is_string()) { raise_error(ShellError::EvaluatedSyntaxError, "Expected the remove_prefix prefix string to be a string", arguments[0].position()); return nullptr; } - auto prefix_str = prefix->resolve_as_list(this).release_value_but_fixme_should_propagate_errors()[0]; - auto values = value->resolve_as_list(this).release_value_but_fixme_should_propagate_errors(); + auto prefix_str = TRY(prefix->resolve_as_list(this))[0]; + auto values = TRY(value->resolve_as_list(this)); Vector> nodes; for (auto& value_str : values) { - String removed = String::from_utf8(value_str).release_value_but_fixme_should_propagate_errors(); + String removed = TRY(String::from_utf8(value_str)); if (value_str.bytes_as_string_view().starts_with(prefix_str)) - removed = removed.substring_from_byte_offset(prefix_str.bytes_as_string_view().length()).release_value_but_fixme_should_propagate_errors(); + removed = TRY(removed.substring_from_byte_offset(prefix_str.bytes_as_string_view().length())); nodes.append(AST::make_ref_counted(invoking_node.position(), move(removed), AST::StringLiteral::EnclosureType::None)); } return AST::make_ref_counted(invoking_node.position(), move(nodes)); } -RefPtr Shell::immediate_split(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_split(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to split", invoking_node.position()); @@ -305,14 +305,14 @@ RefPtr Shell::immediate_split(AST::ImmediateExpression& invoking_node } auto delimiter = const_cast(arguments[0]).run(this); - auto value = const_cast(arguments[1]).run(this)->resolve_without_cast(this).release_value_but_fixme_should_propagate_errors(); + auto value = TRY(const_cast(arguments[1]).run(this)->resolve_without_cast(this)); if (!delimiter->is_string()) { raise_error(ShellError::EvaluatedSyntaxError, "Expected the split delimiter string to be a string", arguments[0].position()); return nullptr; } - auto delimiter_str = delimiter->resolve_as_list(this).release_value_but_fixme_should_propagate_errors()[0]; + auto delimiter_str = TRY(delimiter->resolve_as_list(this))[0]; auto transform = [&](auto const& values) { // Translate to a list of applications of `split ` @@ -338,7 +338,7 @@ RefPtr Shell::immediate_split(AST::ImmediateExpression& invoking_node } // Otherwise, just resolve to a list and transform that. - auto list = value->resolve_as_list(this).release_value_but_fixme_should_propagate_errors(); + auto list = TRY(value->resolve_as_list(this)); if (!value->is_list()) { if (list.is_empty()) return AST::make_ref_counted(invoking_node.position(), NonnullRefPtrVector {}); @@ -349,14 +349,14 @@ RefPtr Shell::immediate_split(AST::ImmediateExpression& invoking_node StringBuilder builder; for (auto code_point : Utf8View { value }) { builder.append_code_point(code_point); - split_strings.append(builder.to_string().release_value_but_fixme_should_propagate_errors()); + split_strings.append(TRY(builder.to_string())); builder.clear(); } } else { auto split = StringView { value }.split_view(delimiter_str, options.inline_exec_keep_empty_segments ? SplitBehavior::KeepEmpty : SplitBehavior::Nothing); split_strings.ensure_capacity(split.size()); for (auto& entry : split) - split_strings.append(String::from_utf8(entry).release_value_but_fixme_should_propagate_errors()); + split_strings.append(TRY(String::from_utf8(entry))); } return AST::make_ref_counted(invoking_node.position(), AST::make_ref_counted(move(split_strings))); } @@ -364,7 +364,7 @@ RefPtr Shell::immediate_split(AST::ImmediateExpression& invoking_node return transform(AST::make_ref_counted(list)->values()); } -RefPtr Shell::immediate_concat_lists(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_concat_lists(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { NonnullRefPtrVector result; @@ -372,12 +372,12 @@ RefPtr Shell::immediate_concat_lists(AST::ImmediateExpression& invoki if (auto* list = dynamic_cast(&argument)) { result.extend(list->list()); } else { - auto list_of_values = const_cast(argument).run(this)->resolve_without_cast(this).release_value_but_fixme_should_propagate_errors(); + auto list_of_values = TRY(const_cast(argument).run(this)->resolve_without_cast(this)); if (auto* list = dynamic_cast(list_of_values.ptr())) { for (auto& entry : static_cast>&>(list->values())) result.append(AST::make_ref_counted(argument.position(), entry)); } else { - auto values = list_of_values->resolve_as_list(this).release_value_but_fixme_should_propagate_errors(); + auto values = TRY(list_of_values->resolve_as_list(this)); for (auto& entry : values) result.append(AST::make_ref_counted(argument.position(), entry, AST::StringLiteral::EnclosureType::None)); } @@ -387,7 +387,7 @@ RefPtr Shell::immediate_concat_lists(AST::ImmediateExpression& invoki return AST::make_ref_counted(invoking_node.position(), move(result)); } -RefPtr Shell::immediate_filter_glob(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_filter_glob(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { // filter_glob string list if (arguments.size() != 2) { @@ -395,7 +395,7 @@ RefPtr Shell::immediate_filter_glob(AST::ImmediateExpression& invokin return nullptr; } - auto glob_list = const_cast(arguments[0]).run(*this)->resolve_as_list(*this).release_value_but_fixme_should_propagate_errors(); + auto glob_list = TRY(const_cast(arguments[0]).run(*this)->resolve_as_list(*this)); if (glob_list.size() != 1) { raise_error(ShellError::EvaluatedSyntaxError, "Expected the argument to filter_glob to be a single string", arguments[0].position()); return nullptr; @@ -431,7 +431,7 @@ RefPtr Shell::immediate_filter_glob(AST::ImmediateExpression& invokin return AST::make_ref_counted(invoking_node.position(), move(result)); } -RefPtr Shell::immediate_join(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_join(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to join", invoking_node.position()); @@ -444,166 +444,166 @@ RefPtr Shell::immediate_join(AST::ImmediateExpression& invoking_node, return nullptr; } - auto value = const_cast(arguments[1]).run(this)->resolve_without_cast(this).release_value_but_fixme_should_propagate_errors(); + auto value = TRY(const_cast(arguments[1]).run(this)->resolve_without_cast(this)); if (!value->is_list()) { raise_error(ShellError::EvaluatedSyntaxError, "Expected the joined list to be a list", arguments[1].position()); return nullptr; } - auto delimiter_str = delimiter->resolve_as_list(this).release_value_but_fixme_should_propagate_errors()[0]; + auto delimiter_str = TRY(delimiter->resolve_as_list(this))[0]; StringBuilder builder; - builder.join(delimiter_str, value->resolve_as_list(*this).release_value_but_fixme_should_propagate_errors()); + builder.join(delimiter_str, TRY(value->resolve_as_list(*this))); - return AST::make_ref_counted(invoking_node.position(), builder.to_string().release_value_but_fixme_should_propagate_errors(), AST::StringLiteral::EnclosureType::None); + return AST::make_ref_counted(invoking_node.position(), TRY(builder.to_string()), AST::StringLiteral::EnclosureType::None); } -RefPtr Shell::immediate_value_or_default(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_value_or_default(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to value_or_default", invoking_node.position()); return nullptr; } - auto name = const_cast(arguments.first()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto name = TRY(const_cast(arguments.first()).run(*this)->resolve_as_string(*this)); if (!local_variable_or(name, ""sv).is_empty()) return make_ref_counted(invoking_node.position(), name); return arguments.last(); } -RefPtr Shell::immediate_assign_default(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_assign_default(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to assign_default", invoking_node.position()); return nullptr; } - auto name = const_cast(arguments.first()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto name = TRY(const_cast(arguments.first()).run(*this)->resolve_as_string(*this)); if (!local_variable_or(name, ""sv).is_empty()) return make_ref_counted(invoking_node.position(), name); - auto value = const_cast(arguments.last()).run(*this)->resolve_without_cast(*this).release_value_but_fixme_should_propagate_errors(); + auto value = TRY(const_cast(arguments.last()).run(*this)->resolve_without_cast(*this)); set_local_variable(name.to_deprecated_string(), value); return make_ref_counted(invoking_node.position(), value); } -RefPtr Shell::immediate_error_if_empty(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_error_if_empty(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to error_if_empty", invoking_node.position()); return nullptr; } - auto name = const_cast(arguments.first()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto name = TRY(const_cast(arguments.first()).run(*this)->resolve_as_string(*this)); if (!local_variable_or(name, ""sv).is_empty()) return make_ref_counted(invoking_node.position(), name); - auto error_value = const_cast(arguments.last()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto error_value = TRY(const_cast(arguments.last()).run(*this)->resolve_as_string(*this)); if (error_value.is_empty()) - error_value = String::formatted("Expected {} to be non-empty", name).release_value_but_fixme_should_propagate_errors(); + error_value = TRY(String::formatted("Expected {} to be non-empty", name)); raise_error(ShellError::EvaluatedSyntaxError, error_value.bytes_as_string_view(), invoking_node.position()); return nullptr; } -RefPtr Shell::immediate_null_or_alternative(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_null_or_alternative(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to null_or_alternative", invoking_node.position()); return nullptr; } - auto value = const_cast(arguments.first()).run(*this)->resolve_without_cast(*this).release_value_but_fixme_should_propagate_errors(); - if ((value->is_string() && value->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors().is_empty()) || (value->is_list() && value->resolve_as_list(*this).release_value_but_fixme_should_propagate_errors().is_empty())) + auto value = TRY(const_cast(arguments.first()).run(*this)->resolve_without_cast(*this)); + if ((value->is_string() && TRY(value->resolve_as_string(*this)).is_empty()) || (value->is_list() && TRY(value->resolve_as_list(*this)).is_empty())) return make_ref_counted(invoking_node.position(), value); return arguments.last(); } -RefPtr Shell::immediate_defined_value_or_default(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_defined_value_or_default(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to defined_value_or_default", invoking_node.position()); return nullptr; } - auto name = const_cast(arguments.first()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto name = TRY(const_cast(arguments.first()).run(*this)->resolve_as_string(*this)); if (!find_frame_containing_local_variable(name)) return arguments.last(); return make_ref_counted(invoking_node.position(), name); } -RefPtr Shell::immediate_assign_defined_default(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_assign_defined_default(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to assign_defined_default", invoking_node.position()); return nullptr; } - auto name = const_cast(arguments.first()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto name = TRY(const_cast(arguments.first()).run(*this)->resolve_as_string(*this)); if (find_frame_containing_local_variable(name)) return make_ref_counted(invoking_node.position(), name); - auto value = const_cast(arguments.last()).run(*this)->resolve_without_cast(*this).release_value_but_fixme_should_propagate_errors(); + auto value = TRY(const_cast(arguments.last()).run(*this)->resolve_without_cast(*this)); set_local_variable(name.to_deprecated_string(), value); return make_ref_counted(invoking_node.position(), value); } -RefPtr Shell::immediate_error_if_unset(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_error_if_unset(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to error_if_unset", invoking_node.position()); return nullptr; } - auto name = const_cast(arguments.first()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto name = TRY(const_cast(arguments.first()).run(*this)->resolve_as_string(*this)); if (find_frame_containing_local_variable(name)) return make_ref_counted(invoking_node.position(), name); - auto error_value = const_cast(arguments.last()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto error_value = TRY(const_cast(arguments.last()).run(*this)->resolve_as_string(*this)); if (error_value.is_empty()) - error_value = String::formatted("Expected {} to be set", name).release_value_but_fixme_should_propagate_errors(); + error_value = TRY(String::formatted("Expected {} to be set", name)); raise_error(ShellError::EvaluatedSyntaxError, error_value.bytes_as_string_view(), invoking_node.position()); return nullptr; } -RefPtr Shell::immediate_null_if_unset_or_alternative(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_null_if_unset_or_alternative(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 2) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 2 arguments to null_if_unset_or_alternative", invoking_node.position()); return nullptr; } - auto name = const_cast(arguments.first()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto name = TRY(const_cast(arguments.first()).run(*this)->resolve_as_string(*this)); if (!find_frame_containing_local_variable(name)) return arguments.last(); return make_ref_counted(invoking_node.position(), name); } -RefPtr Shell::immediate_reexpand(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_reexpand(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 1) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 1 argument to reexpand", invoking_node.position()); return nullptr; } - auto value = const_cast(arguments.first()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto value = TRY(const_cast(arguments.first()).run(*this)->resolve_as_string(*this)); return parse(value, m_is_interactive, false); } -RefPtr Shell::immediate_length_of_variable(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::immediate_length_of_variable(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { if (arguments.size() != 1) { raise_error(ShellError::EvaluatedSyntaxError, "Expected exactly 1 argument to length_of_variable", invoking_node.position()); return nullptr; } - auto name = const_cast(arguments.first()).run(*this)->resolve_as_string(*this).release_value_but_fixme_should_propagate_errors(); + auto name = TRY(const_cast(arguments.first()).run(*this)->resolve_as_string(*this)); auto variable = make_ref_counted(invoking_node.position(), name); return immediate_length_impl( @@ -612,7 +612,7 @@ RefPtr Shell::immediate_length_of_variable(AST::ImmediateExpression& false); } -RefPtr Shell::run_immediate_function(StringView str, AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) +ErrorOr> Shell::run_immediate_function(StringView str, AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const& arguments) { #define __ENUMERATE_SHELL_IMMEDIATE_FUNCTION(name) \ if (str == #name) \ diff --git a/Userland/Shell/Shell.h b/Userland/Shell/Shell.h index 9d3ee04522..dd6a22502c 100644 --- a/Userland/Shell/Shell.h +++ b/Userland/Shell/Shell.h @@ -156,7 +156,7 @@ public: bool run_file(DeprecatedString const&, bool explicitly_invoked = true); ErrorOr run_builtin(const AST::Command&, NonnullRefPtrVector const&, int& retval); bool has_builtin(StringView) const; - RefPtr run_immediate_function(StringView name, AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const&); + ErrorOr> run_immediate_function(StringView name, AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const&); static bool has_immediate_function(StringView); void block_on_job(RefPtr); void block_on_pipeline(RefPtr); @@ -423,13 +423,13 @@ private: virtual void custom_event(Core::CustomEvent&) override; #define __ENUMERATE_SHELL_IMMEDIATE_FUNCTION(name) \ - RefPtr immediate_##name(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const&); + ErrorOr> immediate_##name(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const&); ENUMERATE_SHELL_IMMEDIATE_FUNCTIONS(); #undef __ENUMERATE_SHELL_IMMEDIATE_FUNCTION - RefPtr immediate_length_impl(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const&, bool across); + ErrorOr> immediate_length_impl(AST::ImmediateExpression& invoking_node, NonnullRefPtrVector const&, bool across); #define __ENUMERATE_SHELL_BUILTIN(builtin) \ ErrorOr builtin_##builtin(Main::Arguments); -- cgit v1.2.3