Fix bad assumption in object literal interpretation.

src/ast.cc

 // Copyright 2010 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 219 matching lines @@
     ObjectLiteral::Property* property = this->properties()->at(i);
     Literal* literal = property->key();
     Handle<Object> handle = literal->handle();
 
     if (handle->IsNull()) {
       continue;
     }
 
     uint32_t hash;
     HashMap* table;
     void* key;

[fschneider, 2011/01/24 14:47:52]

Could this be made an Object** since that's what .location() returns?

[Lasse Reichstein, 2011/01/25 07:48:13]

Not without some reinterpret-casts.
There isn't a simple conversion from String** (which is what this location()
returns) or Smi** to Object**. The use of the value is in table->Lookup which
expects a void*.

     uint32_t index;
+    Smi* smi_key_location;
     if (handle->IsSymbol()) {
       Handle<String> name(String::cast(*handle));
-      ASSERT(!name->AsArrayIndex(&index));
-      key = name.location();
-      hash = name->Hash();
-      table = &properties;
+      if (name->AsArrayIndex(&index)) {
+        smi_key_location = Smi::FromInt(index);
+        key = &smi_key_location;
+        hash = index;
+        table = &elements;
+      } else {
+        key = name.location();
+        hash = name->Hash();
+        table = &properties;
+      }
     } else if (handle->ToArrayIndex(&index)) {
       key = handle.location();
       hash = index;
       table = &elements;
     } else {
       ASSERT(handle->IsNumber());
       double num = handle->Number();
       char arr[100];
       Vector<char> buffer(arr, ARRAY_SIZE(arr));
       const char* str = DoubleToCString(num, buffer);
@@ skipping 782 matching lines @@
 
 CaseClause::CaseClause(Expression* label,
                        ZoneList<Statement*>* statements,
                        int pos)
     : label_(label),
       statements_(statements),
       position_(pos),
       compare_type_(NONE) {}
 
 } }  // namespace v8::internal