arkcompiler_ets_runtime/ecmascript/js_map_iterator.cpp
zhangyukun8 cba971f0e7 Impl for-of and for-in HIR lowering
1.Inline getnextpropname HIR of for-in
2.profile iterator type of for-of
3.Inline getiterator and next(call) of for-of
4.Update detector when set prototype

Issue: https://gitee.com/openharmony/arkcompiler_ets_runtime/issues/I89SMQ?from=project-issue
Signed-off-by: zhangyukun8 <zhangyukun8@huawei.com>
Change-Id: Ib18d8b9529c41ec435d5d2d97839d82c389267b6
2023-10-26 15:40:03 +08:00

173 lines
7.5 KiB
C++

/*
* Copyright (c) 2021-2022 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "ecmascript/js_map_iterator.h"
#include "ecmascript/builtins/builtins_errors.h"
#include "ecmascript/js_array.h"
#include "ecmascript/js_map.h"
#include "ecmascript/linked_hash_table.h"
#include "ecmascript/object_factory.h"
namespace panda::ecmascript {
using BuiltinsBase = base::BuiltinsBase;
JSTaggedValue JSMapIterator::Next(EcmaRuntimeCallInfo *argv)
{
ASSERT(argv);
JSThread *thread = argv->GetThread();
[[maybe_unused]] EcmaHandleScope handleScope(thread);
// 1.Let O be the this value
JSHandle<JSTaggedValue> thisObj(BuiltinsBase::GetThis(argv));
return NextInternal(thread, thisObj);
}
JSTaggedValue JSMapIterator::NextInternal(JSThread *thread, JSHandle<JSTaggedValue> thisObj)
{
// 3.If O does not have all of the internal slots of a Map Iterator Instance (23.1.5.3), throw a TypeError
// exception.
if (!thisObj->IsJSMapIterator()) {
THROW_TYPE_ERROR_AND_RETURN(thread, "this value is not a map iterator", JSTaggedValue::Exception());
}
JSHandle<JSMapIterator> iter(thisObj);
iter->Update(thread);
JSHandle<JSTaggedValue> undefinedHandle(thread, JSTaggedValue::Undefined());
// 4.Let m be O.[[IteratedMap]].
JSHandle<JSTaggedValue> iteratedMap(thread, iter->GetIteratedMap());
// 5.Let index be O.[[MapNextIndex]].
int index = static_cast<int>(iter->GetNextIndex());
IterationKind itemKind = iter->GetIterationKind();
// 7.If m is undefined, return CreateIterResultObject(undefined, true).
if (iteratedMap->IsUndefined()) {
return JSIterator::CreateIterResultObject(thread, undefinedHandle, true).GetTaggedValue();
};
JSHandle<LinkedHashMap> map(iteratedMap);
int totalElements = map->NumberOfElements() + map->NumberOfDeletedElements();
JSMutableHandle<JSTaggedValue> keyHandle(thread, JSTaggedValue::Undefined());
while (index < totalElements) {
JSTaggedValue key = map->GetKey(index);
if (!key.IsHole()) {
iter->SetNextIndex(index + 1);
keyHandle.Update(key);
// If itemKind is key, let result be e.[[Key]]
if (itemKind == IterationKind::KEY) {
return JSIterator::CreateIterResultObject(thread, keyHandle, false).GetTaggedValue();
}
JSHandle<JSTaggedValue> value(thread, map->GetValue(index));
// Else if itemKind is value, let result be e.[[Value]].
if (itemKind == IterationKind::VALUE) {
return JSIterator::CreateIterResultObject(thread, value, false).GetTaggedValue();
}
// Else
ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
JSHandle<TaggedArray> array(factory->NewTaggedArray(2)); // 2 means the length of array
array->Set(thread, 0, keyHandle);
array->Set(thread, 1, value);
JSHandle<JSTaggedValue> keyAndValue(JSArray::CreateArrayFromList(thread, array));
return JSIterator::CreateIterResultObject(thread, keyAndValue, false).GetTaggedValue();
}
index++;
}
// 13.Set O.[[IteratedMap]] to undefined.
iter->SetIteratedMap(thread, JSTaggedValue::Undefined());
return JSIterator::CreateIterResultObject(thread, undefinedHandle, true).GetTaggedValue();
}
void JSMapIterator::Update(const JSThread *thread)
{
[[maybe_unused]] DisallowGarbageCollection noGc;
JSTaggedValue iteratedMap = GetIteratedMap();
if (iteratedMap.IsUndefined()) {
return;
}
LinkedHashMap *map = LinkedHashMap::Cast(iteratedMap.GetTaggedObject());
if (map->GetNextTable().IsHole()) {
return;
}
int index = static_cast<int>(GetNextIndex());
JSTaggedValue nextTable = map->GetNextTable();
while (!nextTable.IsHole()) {
index -= map->GetDeletedElementsAt(index);
map = LinkedHashMap::Cast(nextTable.GetTaggedObject());
nextTable = map->GetNextTable();
}
SetIteratedMap(thread, JSTaggedValue(map));
SetNextIndex(index);
}
JSHandle<JSTaggedValue> JSMapIterator::CreateMapIterator(JSThread *thread, const JSHandle<JSTaggedValue> &obj,
IterationKind kind)
{
ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
if (!obj->IsJSMap()) {
JSHandle<JSTaggedValue> undefinedHandle(thread, JSTaggedValue::Undefined());
THROW_TYPE_ERROR_AND_RETURN(thread, "obj is not JSMap", undefinedHandle);
}
JSHandle<JSTaggedValue> iter(factory->NewJSMapIterator(JSHandle<JSMap>(obj), kind));
return iter;
}
JSTaggedValue JSMapIterator::MapIteratorToList(JSThread *thread, JSHandle<JSTaggedValue> &items,
JSHandle<JSTaggedValue> &method)
{
JSTaggedValue newArray = JSArray::ArrayCreate(thread, JSTaggedNumber(0)).GetTaggedValue();
RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
JSHandle<JSObject> newArrayHandle(thread, newArray);
JSHandle<JSTaggedValue> iterator = JSIterator::GetIterator(thread, items, method);
RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
JSHandle<JSMapIterator> iter(iterator);
JSHandle<JSTaggedValue> iteratedMap(thread, iter->GetIteratedMap());
if (iteratedMap->IsUndefined()) {
return newArrayHandle.GetTaggedValue();
}
IterationKind itemKind = iter->GetIterationKind();
JSHandle<LinkedHashMap> map(iteratedMap);
int totalElements = map->NumberOfElements() + map->NumberOfDeletedElements();
int index = static_cast<int>(iter->GetNextIndex());
int k = 0;
JSMutableHandle<JSTaggedValue> keyHandle(thread, JSTaggedValue::Undefined());
JSMutableHandle<JSTaggedValue> valueHandle(thread, JSTaggedValue::Undefined());
ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
JSHandle<TaggedArray> oldElements(thread, newArrayHandle->GetElements());
JSHandle<TaggedArray> elements = factory->ExtendArray(oldElements, totalElements);
while (index < totalElements) {
JSTaggedValue key = map->GetKey(index);
if (!key.IsHole()) {
keyHandle.Update(key);
valueHandle.Update(map->GetValue(index));
if (itemKind == IterationKind::KEY) {
elements->Set(thread, k, keyHandle);
} else if (itemKind == IterationKind::VALUE) {
elements->Set(thread, k, valueHandle);
} else {
JSHandle<TaggedArray> array(factory->NewTaggedArray(2)); // 2 means the length of array
array->Set(thread, 0, keyHandle);
array->Set(thread, 1, valueHandle);
JSHandle<JSTaggedValue> keyAndValue(JSArray::CreateArrayFromList(thread, array));
elements->Set(thread, k, keyAndValue);
}
k++;
}
index++;
}
JSHandle<JSArray>(newArrayHandle)->SetArrayLength(thread, k);
newArrayHandle->SetElements(thread, elements);
return newArrayHandle.GetTaggedValue();
}
} // namespace panda::ecmascript