Remove LookupTransitionOrDescriptor altogether.

src/objects.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2132 matching lines @@
     TransitionArray* transition_array = transitions();
     int number = transition_array->Search(name);
     if (number != TransitionArray::kNotFound) {
       return result->TransitionResult(holder, number);
     }
   }
   result->NotFound();
 }
 
 
-void Map::LookupTransitionOrDescriptor(JSObject* holder,
-                                       String* name,
-                                       LookupResult* result) {
-  // AccessorPairs containing both a Descriptor and a Transition are shared
-  // between the DescriptorArray and the Transition array. This is why looking
-  // up the AccessorPair solely in the DescriptorArray works.
-  // TODO(verwaest) This should be implemented differently so the
-  // DescriptorArray is free of transitions; and so we can freely share it.
-  this->LookupDescriptor(holder, name, result);
-  if (result->IsFound()) return;
-  this->LookupTransition(holder, name, result);
-}
-
-
 static bool ContainsMap(MapHandleList* maps, Handle<Map> map) {
   ASSERT(!map.is_null());
   for (int i = 0; i < maps->length(); ++i) {
     if (!maps->at(i).is_null() && maps->at(i).is_identical_to(map)) return true;
   }
   return false;
 }
 
 
 template <class T>
@@ skipping 2018 matching lines @@
   if (js_object->HasNamedInterceptor() &&
       !heap->isolate()->bootstrapper()->IsActive()) {
     result->InterceptorResult(js_object);
     return;
   }
 
   js_object->LocalLookupRealNamedProperty(name, result);
 }
 
 
-void JSReceiver::Lookup(String* name,
-                        LookupResult* result) {
+void JSReceiver::Lookup(String* name, LookupResult* result) {
   // Ecma-262 3rd 8.6.2.4
   Heap* heap = GetHeap();
   for (Object* current = this;
        current != heap->null_value();
        current = JSObject::cast(current)->GetPrototype()) {
     JSReceiver::cast(current)->LocalLookup(name, result);
     if (result->IsFound()) return;
   }
   result->NotFound();
 }
@@ skipping 8321 matching lines @@
   int number_of_allocated_fields =
       number_of_fields + unused_property_fields - inobject_props;
   if (number_of_allocated_fields < 0) {
     // There is enough inobject space for all fields (including unused).
     number_of_allocated_fields = 0;
     unused_property_fields = inobject_props - number_of_fields;
   }
 
   // Allocate the fixed array for the fields.
   Object* fields;
-  { MaybeObject* maybe_fields =
-        heap->AllocateFixedArray(number_of_allocated_fields);
-    if (!maybe_fields->ToObject(&fields)) return maybe_fields;
-  }
+  MaybeObject* maybe_fields =

[Sven Panne, 2012/07/17 05:54:41]

Even if it is too late, I'd like to comment on this kind of change: I strongly
dislike removing these scopes, because this actively destroys very useful
information. Using a tiny scope makes it crystal-clear what is going on (namely
a bind operation in the Maybe monad) and that the MaybeObject* is only used
locally. I wouldn't argue much if all our functions were in the 10-lines range,
but given our usual monstrous code chunks, the scope really has a value when
trying to understand/refactor things.

We should make reading our code *easier*, not harder...

+      heap->AllocateFixedArray(number_of_allocated_fields);
+  if (!maybe_fields->ToObject(&fields)) return maybe_fields;
 
   // Fill in the instance descriptor and the fields.
   int next_descriptor = 0;
   int current_offset = 0;
   for (int i = 0; i < capacity; i++) {
     Object* k = KeyAt(i);
     if (IsKey(k)) {
       Object* value = ValueAt(i);
       // Ensure the key is a symbol before writing into the instance descriptor.
       String* key;
@@ skipping 555 matching lines @@
   set_year(Smi::FromInt(year), SKIP_WRITE_BARRIER);
   set_month(Smi::FromInt(month), SKIP_WRITE_BARRIER);
   set_day(Smi::FromInt(day), SKIP_WRITE_BARRIER);
   set_weekday(Smi::FromInt(weekday), SKIP_WRITE_BARRIER);
   set_hour(Smi::FromInt(hour), SKIP_WRITE_BARRIER);
   set_min(Smi::FromInt(min), SKIP_WRITE_BARRIER);
   set_sec(Smi::FromInt(sec), SKIP_WRITE_BARRIER);
 }
 
 } }  // namespace v8::internal