runtime-forin.cc 4.56 KB
Newer Older
1 2 3 4 5
// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/runtime/runtime-utils.h"
6 7

#include "src/arguments.h"
8 9
#include "src/factory.h"
#include "src/isolate-inl.h"
10
#include "src/objects-inl.h"
11 12 13 14

namespace v8 {
namespace internal {

15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
namespace {

// Returns either a FixedArray or, if the given {receiver} has an enum cache
// that contains all enumerable properties of the {receiver} and its prototypes
// have none, the map of the {receiver}. This is used to speed up the check for
// deletions during a for-in.
MaybeHandle<HeapObject> Enumerate(Handle<JSReceiver> receiver) {
  Isolate* const isolate = receiver->GetIsolate();
  // Test if we have an enum cache for {receiver}.
  if (!receiver->IsSimpleEnum()) {
    Handle<FixedArray> keys;
    ASSIGN_RETURN_ON_EXCEPTION(
        isolate, keys, JSReceiver::GetKeys(receiver, JSReceiver::INCLUDE_PROTOS,
                                           ENUMERABLE_STRINGS),
        HeapObject);
    // Test again, since cache may have been built by GetKeys() calls above.
    if (!receiver->IsSimpleEnum()) return keys;
  }
  return handle(receiver->map(), isolate);
}


MaybeHandle<Object> Filter(Handle<JSReceiver> receiver, Handle<Object> key) {
  Isolate* const isolate = receiver->GetIsolate();
  // TODO(turbofan): Fast case for array indices.
  Handle<Name> name;
  ASSIGN_RETURN_ON_EXCEPTION(isolate, name, Object::ToName(isolate, key),
                             Object);
  Maybe<bool> result = JSReceiver::HasProperty(receiver, name);
  MAYBE_RETURN_NULL(result);
  if (result.FromJust()) return name;
  return isolate->factory()->undefined_value();
}

}  // namespace


RUNTIME_FUNCTION(Runtime_ForInEnumerate) {
53 54
  HandleScope scope(isolate);
  DCHECK_EQ(1, args.length());
55 56 57 58 59
  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
  Handle<HeapObject> result;
  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, Enumerate(receiver));
  return *result;
}
60 61


62 63 64 65 66 67 68
RUNTIME_FUNCTION_RETURN_TRIPLE(Runtime_ForInPrepare) {
  HandleScope scope(isolate);
  DCHECK_EQ(1, args.length());
  Handle<JSReceiver> receiver = args.at<JSReceiver>(0);
  Handle<Object> cache_type;
  if (!Enumerate(receiver).ToHandle(&cache_type)) {
    return MakeTriple(isolate->heap()->exception(), nullptr, nullptr);
69 70 71 72
  }
  Handle<FixedArray> cache_array;
  int cache_length;
  if (cache_type->IsMap()) {
73 74 75 76 77
    Handle<Map> cache_map = Handle<Map>::cast(cache_type);
    Handle<DescriptorArray> descriptors(cache_map->instance_descriptors(),
                                        isolate);
    cache_length = cache_map->EnumLength();
    if (cache_length && descriptors->HasEnumCache()) {
78 79 80 81 82 83 84 85
      cache_array = handle(descriptors->GetEnumCache(), isolate);
    } else {
      cache_array = isolate->factory()->empty_fixed_array();
      cache_length = 0;
    }
  } else {
    cache_array = Handle<FixedArray>::cast(cache_type);
    cache_length = cache_array->length();
86
    cache_type = handle(Smi::FromInt(1), isolate);
87 88 89 90 91
  }
  return MakeTriple(*cache_type, *cache_array, Smi::FromInt(cache_length));
}


92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107
RUNTIME_FUNCTION(Runtime_ForInDone) {
  SealHandleScope scope(isolate);
  DCHECK_EQ(2, args.length());
  CONVERT_SMI_ARG_CHECKED(index, 0);
  CONVERT_SMI_ARG_CHECKED(length, 1);
  DCHECK_LE(0, index);
  DCHECK_LE(index, length);
  return isolate->heap()->ToBoolean(index == length);
}


RUNTIME_FUNCTION(Runtime_ForInFilter) {
  HandleScope scope(isolate);
  DCHECK_EQ(2, args.length());
  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
  CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
108 109 110
  Handle<Object> result;
  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, Filter(receiver, key));
  return *result;
111 112 113 114 115 116 117 118 119 120 121
}


RUNTIME_FUNCTION(Runtime_ForInNext) {
  HandleScope scope(isolate);
  DCHECK_EQ(4, args.length());
  CONVERT_ARG_HANDLE_CHECKED(JSReceiver, receiver, 0);
  CONVERT_ARG_HANDLE_CHECKED(FixedArray, cache_array, 1);
  CONVERT_ARG_HANDLE_CHECKED(Object, cache_type, 2);
  CONVERT_SMI_ARG_CHECKED(index, 3);
  Handle<Object> key = handle(cache_array->get(index), isolate);
122 123
  // Don't need filtering if expected map still matches that of the receiver.
  if (receiver->map() == *cache_type) {
124 125
    return *key;
  }
126 127 128
  Handle<Object> result;
  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result, Filter(receiver, key));
  return *result;
129 130 131 132 133 134 135 136 137 138 139 140 141 142
}


RUNTIME_FUNCTION(Runtime_ForInStep) {
  SealHandleScope scope(isolate);
  DCHECK_EQ(1, args.length());
  CONVERT_SMI_ARG_CHECKED(index, 0);
  DCHECK_LE(0, index);
  DCHECK_LT(index, Smi::kMaxValue);
  return Smi::FromInt(index + 1);
}

}  // namespace internal
}  // namespace v8