LibJS: Add argument(i) and argument_count() to Interpreter

Add some convenience accessors for retrieving arguments from the
current call frame.

Libraries/LibJS/Interpreter.h

···
     void pop_call_frame() { m_call_stack.take_last(); }
     const CallFrame& call_frame() { return m_call_stack.last(); }
 
+    size_t argument_count() const
+    {
+        if (m_call_stack.is_empty())
+            return 0;
+        return m_call_stack.last().arguments.size();
+    }
+
+    Value argument(size_t index) const
+    {
+        if (m_call_stack.is_empty())
+            return {};
+        auto& arguments = m_call_stack.last().arguments;
+        return index < arguments.size() ? arguments[index] : js_undefined();
+    }
+
     Value this_value() const
     {
         if (m_call_stack.is_empty())

Libraries/LibJS/Runtime/ArrayPrototype.cpp

···
     if (!this_object)
         return {};
     ASSERT(this_object->is_array());
-    if (interpreter.call_frame().arguments.is_empty())
+    if (!interpreter.argument_count())
         return js_undefined();
-    static_cast<Array*>(this_object)->push(interpreter.call_frame().arguments[0]);
+    static_cast<Array*>(this_object)->push(interpreter.argument(0));
     return Value(static_cast<const Array*>(this_object)->length());
 }
 

Libraries/LibJS/Runtime/ConsoleObject.cpp

···
 
 Value ConsoleObject::log(Interpreter& interpreter)
 {
-    for (size_t i = 0; i < interpreter.call_frame().arguments.size(); ++i) {
-        printf("%s", interpreter.call_frame().arguments[i].to_string().characters());
-        if (i != interpreter.call_frame().arguments.size() - 1)
+    for (size_t i = 0; i < interpreter.argument_count(); ++i) {
+        printf("%s", interpreter.argument(i).to_string().characters());
+        if (i != interpreter.argument_count() - 1)
             putchar(' ');
     }
     putchar('\n');

Libraries/LibJS/Runtime/GlobalObject.cpp

···
 
 Value GlobalObject::is_nan(Interpreter& interpreter)
 {
-    if (interpreter.call_frame().arguments.size() < 1)
+    if (interpreter.argument_count() < 1)
         return js_undefined();
-    return Value(interpreter.call_frame().arguments[0].to_number().is_nan());
+    return Value(interpreter.argument(0).to_number().is_nan());
 }
 
 }

Libraries/LibJS/Runtime/MathObject.cpp

···
 
 Value MathObject::abs(Interpreter& interpreter)
 {
-    if (interpreter.call_frame().arguments.is_empty())
+    if (!interpreter.argument_count())
         return js_nan();
 
-    auto number = interpreter.call_frame().arguments[0].to_number();
+    auto number = interpreter.argument(0).to_number();
     if (number.is_nan())
         return js_nan();
     return Value(number.as_double() >= 0 ? number.as_double() : -number.as_double());

Libraries/LibJS/Runtime/ObjectConstructor.cpp

···
 
 Value ObjectConstructor::get_own_property_names(Interpreter& interpreter)
 {
-    if (interpreter.call_frame().arguments.size() < 1)
+    if (!interpreter.argument_count())
         return {};
-    auto* object = interpreter.call_frame().arguments[0].to_object(interpreter.heap());
+    auto* object = interpreter.argument(0).to_object(interpreter.heap());
     if (interpreter.exception())
         return {};
     auto* result = interpreter.heap().allocate<Array>();
···
 
 Value ObjectConstructor::get_prototype_of(Interpreter& interpreter)
 {
-    if (interpreter.call_frame().arguments.size() < 1)
+    if (!interpreter.argument_count())
         return {};
-    auto* object = interpreter.call_frame().arguments[0].to_object(interpreter.heap());
+    auto* object = interpreter.argument(0).to_object(interpreter.heap());
     if (interpreter.exception())
         return {};
     return object->prototype();
···
 
 Value ObjectConstructor::set_prototype_of(Interpreter& interpreter)
 {
-    if (interpreter.call_frame().arguments.size() < 2)
+    if (interpreter.argument_count() < 2)
         return {};
-    if (!interpreter.call_frame().arguments[1].is_object())
+    if (!interpreter.argument(0).is_object())
         return {};
-    auto* object = interpreter.call_frame().arguments[0].to_object(interpreter.heap());
+    auto* object = interpreter.argument(0).to_object(interpreter.heap());
     if (interpreter.exception())
         return {};
-    object->set_prototype(&const_cast<Object&>(interpreter.call_frame().arguments[1].as_object()));
+    object->set_prototype(&const_cast<Object&>(interpreter.argument(1).as_object()));
     return {};
 }
 

Libraries/LibJS/Runtime/ObjectPrototype.cpp

···
     auto* this_object = interpreter.this_value().to_object(interpreter.heap());
     if (!this_object)
         return {};
-    if (interpreter.call_frame().arguments.is_empty())
-        return js_undefined();
-    return Value(this_object->has_own_property(interpreter.call_frame().arguments[0].to_string()));
+    if (!interpreter.argument_count())
+        return {};
+    return Value(this_object->has_own_property(interpreter.argument(0).to_string()));
 }
 
 Value ObjectPrototype::to_string(Interpreter& interpreter)

Libraries/LibJS/Runtime/StringPrototype.cpp

···
     if (!this_object)
         return {};
     i32 index = 0;
-    if (!interpreter.call_frame().arguments.is_empty())
-        index = interpreter.call_frame().arguments[0].to_i32();
+    if (interpreter.argument_count())
+        index = interpreter.argument(0).to_i32();
     ASSERT(this_object->is_string_object());
     auto underlying_string = static_cast<const StringObject*>(this_object)->primitive_string()->string();
     if (index < 0 || index >= static_cast<i32>(underlying_string.length()))
···
     if (!this_object)
         return {};
     ASSERT(this_object->is_string_object());
-    if (interpreter.call_frame().arguments.is_empty())
+    if (!interpreter.argument_count())
         return js_string(interpreter.heap(), String::empty());
     i32 count = 0;
-    count = interpreter.call_frame().arguments[0].to_i32();
+    count = interpreter.argument(0).to_i32();
     if (count < 0) {
         // FIXME: throw RangeError
-        return js_undefined();
+        return {};
     }
     auto* string_object = static_cast<StringObject*>(this_object);
     StringBuilder builder;
···
     auto* this_object = interpreter.this_value().to_object(interpreter.heap());
     if (!this_object)
         return {};
-    if (interpreter.call_frame().arguments.is_empty())
+    if (!interpreter.argument_count())
         return Value(false);
-    auto search_string = interpreter.call_frame().arguments[0].to_string();
+    auto search_string = interpreter.argument(0).to_string();
     auto search_string_length = static_cast<i32>(search_string.length());
     i32 position = 0;
-    if (interpreter.call_frame().arguments.size() > 1) {
-        auto number = interpreter.call_frame().arguments[1].to_number();
+    if (interpreter.argument_count() > 1) {
+        auto number = interpreter.argument(1).to_number();
         if (!number.is_nan())
             position = number.to_i32();
     }

Userland/js.cpp

···
 
 JS::Value ReplObject::exit_interpreter(JS::Interpreter& interpreter)
 {
-    if (interpreter.call_frame().arguments.is_empty())
+    if (!interpreter.argument_count())
         exit(0);
-    int exit_code = interpreter.call_frame().arguments[0].to_number().as_double();
+    int exit_code = interpreter.argument(0).to_number().as_double();
     exit(exit_code);
     return JS::js_undefined();
 }
···
 
 JS::Value ReplObject::load_file(JS::Interpreter& interpreter)
 {
-    if (interpreter.call_frame().arguments.is_empty())
+    if (!interpreter.argument_count())
         return JS::Value(false);
-    Vector<JS::Value> files = interpreter.call_frame().arguments;
-    for (JS::Value file : files) {
+
+    for (auto& file : interpreter.call_frame().arguments) {
         String file_name = file.as_string()->string();
         auto js_file = Core::File::construct(file_name);
         if (!js_file->open(Core::IODevice::ReadOnly)) {