std::unique_ptr<ExpressionEvaluator> source_array,

std::unique_ptr<ExpressionEvaluator> source_index)

: source_array_(std::move(source_array)),

source_index_(std::move(source_index)) {

ReadersFactory* readers_factory,

FormatMessageModel* error_message) {

if (!source_array_->Compile(readers_factory, error_message) ||

!source_index_->Compile(readers_factory, error_message)) {

return false;

}

if (!IsArrayObjectType(source_array_->GetStaticType())) {

*error_message = {

ArrayTypeExpected,

{ TypeNameFromSignature(source_array_->GetStaticType()) }

};

return false;

}

return_type_ = GetArrayElementJSignature(source_array_->GetStaticType());

if (return_type_.type == JType::Void) {

*error_message = INTERNAL_ERROR_MESSAGE;

return false;

}

array_reader_ = readers_factory->CreateArrayReader(

source_array_->GetStaticType());

if (array_reader_ == nullptr) {

*error_message = INTERNAL_ERROR_MESSAGE;

return false;

}

if (!IsIntegerType(source_index_->GetStaticType().type)) {

*error_message = {

ArrayIndexNotInteger,

{ TypeNameFromSignature(source_index_->GetStaticType()) }

};

return false;

}

if (!ApplyNumericCast<jlong>(&source_index_, error_message)) {

*error_message = INTERNAL_ERROR_MESSAGE;

return false;

}

return true;

const EvaluationContext& evaluation_context) const {

ErrorOr<JVariant> array = source_array_->Evaluate(evaluation_context);

if (array.is_error()) {

return array;

}

ErrorOr<JVariant> index = source_index_->Evaluate(evaluation_context);

if (index.is_error()) {

return index;

}

return array_reader_->ReadValue(array.value(), index.value());