Get rid of the TRANSITION PropertyType and consistently use CanHoldValue().

src/runtime.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 5198 matching lines @@
 
 
 // Return property without being observable by accessors or interceptors.
 RUNTIME_FUNCTION(MaybeObject*, Runtime_GetDataProperty) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 2);
   CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
   CONVERT_ARG_HANDLE_CHECKED(Name, key, 1);
   LookupResult lookup(isolate);
   object->LookupRealNamedProperty(*key, &lookup);
-  if (!lookup.IsFound()) return isolate->heap()->undefined_value();
-  switch (lookup.type()) {
-    case NORMAL:
-      return lookup.holder()->GetNormalizedProperty(&lookup);
-    case FIELD:
-      return lookup.holder()->FastPropertyAt(
-          lookup.representation(),
-          lookup.GetFieldIndex().field_index());
-    case CONSTANT:
-      return lookup.GetConstant();
-    case CALLBACKS:
-    case HANDLER:
-    case INTERCEPTOR:
-    case TRANSITION:
-      return isolate->heap()->undefined_value();
-    case NONEXISTENT:
-      UNREACHABLE();
+  if (lookup.IsFound() && !lookup.IsTransition()) {
+    switch (lookup.type()) {
+      case NORMAL:
+        return lookup.holder()->GetNormalizedProperty(&lookup);
+      case FIELD:
+        return lookup.holder()->FastPropertyAt(
+            lookup.representation(),
+            lookup.GetFieldIndex().field_index());
+      case CONSTANT:
+        return lookup.GetConstant();
+      case CALLBACKS:
+      case HANDLER:
+      case INTERCEPTOR:
+        break;
+      case NONEXISTENT:
+        UNREACHABLE();
+    }
   }
   return isolate->heap()->undefined_value();
 }
 
 
 Handle<Object> Runtime::SetObjectProperty(Isolate* isolate,
                                           Handle<Object> object,
                                           Handle<Object> key,
                                           Handle<Object> value,
                                           PropertyAttributes attr,
@@ skipping 5527 matching lines @@
   return isolate->heap()->undefined_value();
 }
 
 
 static MaybeObject* DebugLookupResultValue(Heap* heap,
                                            Object* receiver,
                                            Name* name,
                                            LookupResult* result,
                                            bool* caught_exception) {
   Object* value;
+  if (result->IsTransition()) return heap->undefined_value();
   switch (result->type()) {
     case NORMAL:
       value = result->holder()->GetNormalizedProperty(result);
       if (value->IsTheHole()) {
         return heap->undefined_value();
       }
       return value;
     case FIELD: {
       Object* value;
       MaybeObject* maybe_value =
@@ skipping 23 matching lines @@
           heap->isolate()->clear_pending_exception();
           if (caught_exception != NULL) *caught_exception = true;
           return exception;
         }
         return *value;
       } else {
         return heap->undefined_value();
       }
     }
     case INTERCEPTOR:
-    case TRANSITION:
       return heap->undefined_value();
     case HANDLER:
     case NONEXISTENT:
       UNREACHABLE();
       return heap->undefined_value();
   }
   UNREACHABLE();  // keep the compiler happy
   return heap->undefined_value();
 }
 
@@ skipping 4385 matching lines @@
   }
 }
 
 
 void Runtime::OutOfMemory() {
   Heap::FatalProcessOutOfMemory("CALL_AND_RETRY_LAST", true);
   UNREACHABLE();
 }
 
 } }  // namespace v8::internal