[stubs] Implementing CodeStubAssembler::GetOwnProperty().

test/cctest/test-code-stub-assembler.cc

 // 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/base/utils/random-number-generator.h"
 #include "src/ic/stub-cache.h"
 #include "src/isolate.h"
 #include "test/cctest/compiler/code-assembler-tester.h"
 #include "test/cctest/compiler/function-tester.h"
 
@@ skipping 214 matching lines @@
 
   enum Result { kFound, kNotFound };
   {
     Node* dictionary = m.Parameter(0);
     Node* unique_name = m.Parameter(1);
     Node* expected_result = m.Parameter(2);
     Node* expected_arg = m.Parameter(3);
 
     Label passed(&m), failed(&m);
     Label if_found(&m), if_not_found(&m);
-    Variable var_entry(&m, MachineRepresentation::kWord32);
+    Variable var_name_index(&m, MachineRepresentation::kWord32);
 
     m.NameDictionaryLookup<Dictionary>(dictionary, unique_name, &if_found,
-                                       &var_entry, &if_not_found);
+                                       &var_name_index, &if_not_found);
     m.Bind(&if_found);
     m.GotoUnless(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kFound))),
         &failed);
-    m.Branch(m.Word32Equal(m.SmiToWord32(expected_arg), var_entry.value()),
+    m.Branch(m.Word32Equal(m.SmiToWord32(expected_arg), var_name_index.value()),
              &passed, &failed);
 
     m.Bind(&if_not_found);
     m.Branch(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
         &passed, &failed);
 
     m.Bind(&passed);
     m.Return(m.BooleanConstant(true));
 
@@ skipping 23 matching lines @@
       factory->NewPrivateSymbol(),
   };
 
   for (size_t i = 0; i < arraysize(keys); i++) {
     Handle<Object> value = factory->NewPropertyCell();
     dictionary = Dictionary::Add(dictionary, keys[i], value, fake_details);
   }
 
   for (size_t i = 0; i < arraysize(keys); i++) {
     int entry = dictionary->FindEntry(keys[i]);
+    int name_index =
+        Dictionary::EntryToIndex(entry) + Dictionary::kEntryKeyIndex;
     CHECK_NE(Dictionary::kNotFound, entry);
 
-    Handle<Object> expected_entry(Smi::FromInt(entry), isolate);
-    ft.CheckTrue(dictionary, keys[i], expect_found, expected_entry);
+    Handle<Object> expected_name_index(Smi::FromInt(name_index), isolate);
+    ft.CheckTrue(dictionary, keys[i], expect_found, expected_name_index);
   }
 
   Handle<Name> non_existing_keys[] = {
       factory->InternalizeUtf8String("1"),
       factory->InternalizeUtf8String("-42"),
       factory->InternalizeUtf8String("153"),
       factory->InternalizeUtf8String("-1.0"),
       factory->InternalizeUtf8String("1.3"),
       factory->InternalizeUtf8String("a"),
       factory->InternalizeUtf8String("boom"),
@@ skipping 110 matching lines @@
 }
 
 TEST(UnseededNumberDictionaryLookup) {
   TestNumberDictionaryLookup<UnseededNumberDictionary>();
 }
 
 namespace {
 
 void AddProperties(Handle<JSObject> object, Handle<Name> names[],
                    size_t count) {
-  Handle<Object> value(Smi::FromInt(42), object->GetIsolate());
+  Isolate* isolate = object->GetIsolate();
   for (size_t i = 0; i < count; i++) {
+    Handle<Object> value(Smi::FromInt(static_cast<int>(42 + i)), isolate);
     JSObject::AddProperty(object, names[i], value, NONE);
   }
 }
 
+Handle<AccessorPair> CreateAccessorPair(FunctionTester* ft,
+                                        const char* getter_body,
+                                        const char* setter_body) {
+  Handle<AccessorPair> pair = ft->isolate->factory()->NewAccessorPair();
+  if (getter_body) {
+    pair->set_getter(*ft->NewFunction(getter_body));
+  }
+  if (setter_body) {
+    pair->set_setter(*ft->NewFunction(setter_body));
+  }
+  return pair;
+}
+
+void AddProperties(Handle<JSObject> object, Handle<Name> names[],
+                   size_t names_count, Handle<Object> values[],
+                   size_t values_count, int seed = 0) {
+  Isolate* isolate = object->GetIsolate();
+  for (size_t i = 0; i < names_count; i++) {
+    Handle<Object> value = values[(seed + i) % values_count];
+    if (value->IsAccessorPair()) {
+      Handle<AccessorPair> pair = Handle<AccessorPair>::cast(value);
+      Handle<Object> getter(pair->getter(), isolate);
+      Handle<Object> setter(pair->setter(), isolate);
+      JSObject::DefineAccessor(object, names[i], getter, setter, NONE).Check();
+    } else {
+      JSObject::AddProperty(object, names[i], value, NONE);
+    }
+  }
+}
+
 }  // namespace
 
-TEST(TryLookupProperty) {
+TEST(TryHasOwnProperty) {
   typedef CodeStubAssembler::Label Label;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
   const int kNumParams = 4;
   CodeStubAssemblerTester m(isolate, kNumParams);
 
   enum Result { kFound, kNotFound, kBailout };
   {
     Node* object = m.Parameter(0);
     Node* unique_name = m.Parameter(1);
     Node* expected_result = m.Parameter(2);
 
     Label passed(&m), failed(&m);
     Label if_found(&m), if_not_found(&m), if_bailout(&m);
 
     Node* map = m.LoadMap(object);
     Node* instance_type = m.LoadMapInstanceType(map);
 
-    m.TryLookupProperty(object, map, instance_type, unique_name, &if_found,
+    m.TryHasOwnProperty(object, map, instance_type, unique_name, &if_found,
                         &if_not_found, &if_bailout);
 
     m.Bind(&if_found);
     m.Branch(m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kFound))),
              &passed, &failed);
 
     m.Bind(&if_not_found);
     m.Branch(
         m.WordEqual(expected_result, m.SmiConstant(Smi::FromInt(kNotFound))),
         &passed, &failed);
@@ skipping 69 matching lines @@
       for (size_t name_index = 0; name_index < arraysize(names); name_index++) {
         Handle<Name> name = names[name_index];
         CHECK(JSReceiver::HasProperty(object, name).FromJust());
         ft.CheckTrue(object, name, expect_found);
       }
     }
   }
 
   {
     Handle<Name> non_existing_names[] = {
+        factory->NewSymbol(),
         factory->InternalizeUtf8String("ne_a"),
         factory->InternalizeUtf8String("ne_bb"),
+        factory->NewPrivateSymbol(),
         factory->InternalizeUtf8String("ne_ccc"),
         factory->InternalizeUtf8String("ne_dddd"),
     };
     for (Handle<JSObject> object : objects) {
       for (size_t key_index = 0; key_index < arraysize(non_existing_names);
            key_index++) {
-        Handle<Name> key = non_existing_names[key_index];
-        CHECK(!JSReceiver::HasProperty(object, key).FromJust());
-        ft.CheckTrue(object, key, expect_not_found);
+        Handle<Name> name = non_existing_names[key_index];
+        CHECK(!JSReceiver::HasProperty(object, name).FromJust());
+        ft.CheckTrue(object, name, expect_not_found);
       }
     }
   }
 
   {
     Handle<JSFunction> function = factory->NewFunction(factory->empty_string());
     Handle<JSProxy> object = factory->NewJSProxy(function, objects[0]);
     CHECK_EQ(JS_PROXY_TYPE, object->map()->instance_type());
     ft.CheckTrue(object, names[0], expect_bailout);
   }
 
   {
     Handle<JSObject> object = isolate->global_proxy();
     CHECK_EQ(JS_GLOBAL_PROXY_TYPE, object->map()->instance_type());
     ft.CheckTrue(object, names[0], expect_bailout);
   }
 }
 
+TEST(TryGetOwnProperty) {
+  typedef CodeStubAssembler::Label Label;
+  typedef CodeStubAssembler::Variable Variable;
+  Isolate* isolate(CcTest::InitIsolateOnce());
+  Factory* factory = isolate->factory();
+
+  const int kNumParams = 2;
+  CodeStubAssemblerTester m(isolate, kNumParams);
+
+  Handle<Symbol> not_found_symbol = factory->NewSymbol();
+  Handle<Symbol> bailout_symbol = factory->NewSymbol();
+  {
+    Node* object = m.Parameter(0);
+    Node* unique_name = m.Parameter(1);
+    Node* context = m.Parameter(kNumParams + 2);
+
+    Variable var_value(&m, MachineRepresentation::kTagged);
+    Label if_found(&m), if_not_found(&m), if_bailout(&m);
+
+    Node* map = m.LoadMap(object);
+    Node* instance_type = m.LoadMapInstanceType(map);
+
+    m.TryGetOwnProperty(context, object, object, map, instance_type,
+                        unique_name, &if_found, &var_value, &if_not_found,
+                        &if_bailout);
+
+    m.Bind(&if_found);
+    m.Return(var_value.value());
+
+    m.Bind(&if_not_found);
+    m.Return(m.HeapConstant(not_found_symbol));
+
+    m.Bind(&if_bailout);
+    m.Return(m.HeapConstant(bailout_symbol));
+  }
+
+  Handle<Code> code = m.GenerateCode();
+  FunctionTester ft(code, kNumParams);
+
+  Handle<Name> deleted_property_name =
+      factory->InternalizeUtf8String("deleted");
+
+  Handle<Name> names[] = {
+      factory->InternalizeUtf8String("bb"),
+      factory->NewSymbol(),
+      factory->InternalizeUtf8String("a"),
+      factory->InternalizeUtf8String("ccc"),
+      factory->InternalizeUtf8String("esajefe"),
+      factory->NewPrivateSymbol(),
+      factory->InternalizeUtf8String("eeeee"),
+      factory->InternalizeUtf8String("p1"),
+      factory->InternalizeUtf8String("acshw23e"),
+      factory->InternalizeUtf8String(""),
+      factory->InternalizeUtf8String("dddd"),
+      factory->NewPrivateSymbol(),
+      factory->InternalizeUtf8String("name"),
+      factory->InternalizeUtf8String("p2"),
+      factory->InternalizeUtf8String("p3"),
+      factory->InternalizeUtf8String("p4"),
+      factory->NewPrivateSymbol(),
+  };
+  Handle<Object> values[] = {
+      factory->NewFunction(factory->empty_string()),
+      factory->NewSymbol(),
+      factory->InternalizeUtf8String("a"),
+      CreateAccessorPair(&ft, "() => 188;", "() => 199;"),
+      factory->NewFunction(factory->InternalizeUtf8String("bb")),
+      factory->InternalizeUtf8String("ccc"),
+      CreateAccessorPair(&ft, "() => 88;", nullptr),
+      handle(Smi::FromInt(1), isolate),
+      factory->InternalizeUtf8String(""),
+      CreateAccessorPair(&ft, nullptr, "() => 99;"),
+      factory->NewHeapNumber(4.2),
+      handle(Smi::FromInt(153), isolate),
+      factory->NewJSObject(factory->NewFunction(factory->empty_string())),
+      factory->NewPrivateSymbol(),
+  };
+  STATIC_ASSERT(arraysize(values) < arraysize(names));
+
+  base::RandomNumberGenerator rand_gen(FLAG_random_seed);
+
+  std::vector<Handle<JSObject>> objects;
+
+  if (false) {
+    // Fast object, no inobject properties.
+    int inobject_properties = 0;
+    Handle<Map> map = Map::Create(isolate, inobject_properties);
+    Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+    AddProperties(object, names, arraysize(names), values, arraysize(values),
+                  rand_gen.NextInt());
+    CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+    CHECK_EQ(inobject_properties, object->map()->GetInObjectProperties());
+    CHECK(!object->map()->is_dictionary_map());
+    objects.push_back(object);
+  }
+
+  {
+    // Fast object, all inobject properties.
+    int inobject_properties = arraysize(names) * 2;
+    Handle<Map> map = Map::Create(isolate, inobject_properties);
+    Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+    AddProperties(object, names, arraysize(names), values, arraysize(values),
+                  rand_gen.NextInt());
+    CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+    CHECK_EQ(inobject_properties, object->map()->GetInObjectProperties());
+    CHECK(!object->map()->is_dictionary_map());
+    objects.push_back(object);
+  }
+
+  {
+    // Fast object, half inobject properties.
+    int inobject_properties = arraysize(names) / 2;
+    Handle<Map> map = Map::Create(isolate, inobject_properties);
+    Handle<JSObject> object = factory->NewJSObjectFromMap(map);
+    AddProperties(object, names, arraysize(names), values, arraysize(values),
+                  rand_gen.NextInt());
+    CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+    CHECK_EQ(inobject_properties, object->map()->GetInObjectProperties());
+    CHECK(!object->map()->is_dictionary_map());
+    objects.push_back(object);
+  }
+
+  {
+    // Dictionary mode object.
+    Handle<JSFunction> function = factory->NewFunction(factory->empty_string());
+    Handle<JSObject> object = factory->NewJSObject(function);
+    AddProperties(object, names, arraysize(names), values, arraysize(values),
+                  rand_gen.NextInt());
+    JSObject::NormalizeProperties(object, CLEAR_INOBJECT_PROPERTIES, 0, "test");
+
+    JSObject::AddProperty(object, deleted_property_name, object, NONE);
+    CHECK(JSObject::DeleteProperty(object, deleted_property_name, SLOPPY)
+              .FromJust());
+
+    CHECK_EQ(JS_OBJECT_TYPE, object->map()->instance_type());
+    CHECK(object->map()->is_dictionary_map());
+    objects.push_back(object);
+  }
+
+  {
+    // Global mode object.
+    Handle<JSGlobalObject> object = isolate->global_object();
+    AddProperties(object, names, arraysize(names), values, arraysize(values),
+                  rand_gen.NextInt());
+
+    JSObject::AddProperty(object, deleted_property_name, object, NONE);
+    CHECK(JSObject::DeleteProperty(object, deleted_property_name, SLOPPY)
+              .FromJust());
+
+    CHECK_EQ(JS_GLOBAL_OBJECT_TYPE, object->map()->instance_type());
+    CHECK(object->map()->is_dictionary_map());
+    objects.push_back(object);
+  }
+
+  // TODO(ishell): test proxy and interceptors when they are supported.
+
+  {
+    for (Handle<JSObject> object : objects) {
+      for (size_t name_index = 0; name_index < arraysize(names); name_index++) {
+        Handle<Name> name = names[name_index];
+        Handle<Object> expected_value =
+            JSReceiver::GetProperty(object, name).ToHandleChecked();
+        Handle<Object> value = ft.Call(object, name).ToHandleChecked();
+        CHECK(expected_value->SameValue(*value));
+      }
+    }
+  }
+
+  {
+    Handle<Name> non_existing_names[] = {
+        factory->NewSymbol(),
+        factory->InternalizeUtf8String("ne_a"),
+        factory->InternalizeUtf8String("ne_bb"),
+        factory->NewPrivateSymbol(),
+        factory->InternalizeUtf8String("ne_ccc"),
+        factory->InternalizeUtf8String("ne_dddd"),
+        deleted_property_name,
+    };
+    for (Handle<JSObject> object : objects) {
+      for (size_t key_index = 0; key_index < arraysize(non_existing_names);
+           key_index++) {
+        Handle<Name> name = non_existing_names[key_index];
+        Handle<Object> expected_value =
+            JSReceiver::GetProperty(object, name).ToHandleChecked();
+        CHECK(expected_value->IsUndefined(isolate));
+        Handle<Object> value = ft.Call(object, name).ToHandleChecked();
+        CHECK_EQ(*not_found_symbol, *value);
+      }
+    }
+  }
+
+  {
+    Handle<JSFunction> function = factory->NewFunction(factory->empty_string());
+    Handle<JSProxy> object = factory->NewJSProxy(function, objects[0]);
+    CHECK_EQ(JS_PROXY_TYPE, object->map()->instance_type());
+    Handle<Object> value = ft.Call(object, names[0]).ToHandleChecked();
+    // Proxies are not supported yet.
+    CHECK_EQ(*bailout_symbol, *value);
+  }
+
+  {
+    Handle<JSObject> object = isolate->global_proxy();
+    CHECK_EQ(JS_GLOBAL_PROXY_TYPE, object->map()->instance_type());
+    // Global proxies are not supported yet.
+    Handle<Object> value = ft.Call(object, names[0]).ToHandleChecked();
+    CHECK_EQ(*bailout_symbol, *value);
+  }
+}
+
 namespace {
 
 void AddElement(Handle<JSObject> object, uint32_t index, Handle<Object> value,
                 PropertyAttributes attributes = NONE) {
   JSObject::AddDataElement(object, index, value, attributes).ToHandleChecked();
 }
 
 }  // namespace
 
 TEST(TryLookupElement) {
   typedef CodeStubAssembler::Label Label;
   Isolate* isolate(CcTest::InitIsolateOnce());
 
-  const int kNumParams = 4;
+  const int kNumParams = 3;
   CodeStubAssemblerTester m(isolate, kNumParams);
 
   enum Result { kFound, kNotFound, kBailout };
   {
     Node* object = m.Parameter(0);
     Node* index = m.SmiToWord32(m.Parameter(1));
     Node* expected_result = m.Parameter(2);
 
     Label passed(&m), failed(&m);
     Label if_found(&m), if_not_found(&m), if_bailout(&m);
@@ skipping 487 matching lines @@
 
     Handle<Code> expected_handler(handler, isolate);
     ft.CheckTrue(receiver, name, expected_handler);
   }
   // Ensure we performed both kind of queries.
   CHECK(queried_existing && queried_non_existing);
 }
 
 }  // namespace internal
 }  // namespace v8