Mirror object properties are always names

test/mjsunit/mirror-object.js

 // 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 22 matching lines @@
   this.refs_ = [];
   for (var i = 0; i < tmp.length; i++) {
     this.refs_[tmp[i].handle] = tmp[i];
   }
 }
 
 MirrorRefCache.prototype.lookup = function(handle) {
   return this.refs_[handle];
 };
 
+function isName(val) {
+  return typeof val === 'string' || typeof val === 'symbol';
+}
+
 function testObjectMirror(obj, cls_name, ctor_name, hasSpecialProperties) {
   // Create mirror and JSON representation.
   var mirror = debug.MakeMirror(obj);
   var serializer = debug.MakeMirrorSerializer();
   var json = JSON.stringify(serializer.serializeValue(mirror));
   var refs = new MirrorRefCache(
       JSON.stringify(serializer.serializeReferencedObjects()));
 
   // Check the mirror hierachy.
   assertTrue(mirror instanceof debug.Mirror, 'Unexpected mirror hierarchy');
@@ skipping 12 matching lines @@
   assertFalse(mirror.hasNamedInterceptor(), 'No named interceptor expected');
   assertFalse(mirror.hasIndexedInterceptor(), 'No indexed interceptor expected');
 
   var names = mirror.propertyNames();
   var properties = mirror.properties();
   assertEquals(names.length, properties.length);
   for (var i = 0; i < properties.length; i++) {
     assertTrue(properties[i] instanceof debug.Mirror, 'Unexpected mirror hierarchy');
     assertTrue(properties[i] instanceof debug.PropertyMirror, 'Unexpected mirror hierarchy');
     assertEquals('property', properties[i].type(), 'Unexpected mirror type');
+    assertTrue(isName(names[i]), "Expected string or symbol property name");
     assertEquals(names[i], properties[i].name(), 'Unexpected property name');
   }
 
   var internalProperties = mirror.internalProperties();
   for (var i = 0; i < internalProperties.length; i++) {
     assertTrue(internalProperties[i] instanceof debug.Mirror, 'Unexpected mirror hierarchy');
     assertTrue(internalProperties[i] instanceof debug.InternalPropertyMirror, 'Unexpected mirror hierarchy');
     assertEquals('internalProperty', internalProperties[i].type(), 'Unexpected mirror type');
   }
 
@@ skipping 19 matching lines @@
   assertEquals(ctor_name, refs.lookup(fromJSON.constructorFunction.ref).name, 'Unexpected constructor function name in JSON');
   assertEquals(mirror.protoObject().handle(), fromJSON.protoObject.ref, 'Unexpected proto object handle in JSON');
   assertEquals(mirror.protoObject().type(), refs.lookup(fromJSON.protoObject.ref).type, 'Unexpected proto object type in JSON');
   assertEquals(mirror.prototypeObject().handle(), fromJSON.prototypeObject.ref, 'Unexpected prototype object handle in JSON');
   assertEquals(mirror.prototypeObject().type(), refs.lookup(fromJSON.prototypeObject.ref).type, 'Unexpected prototype object type in JSON');
   assertEquals(void 0, fromJSON.namedInterceptor, 'No named interceptor expected in JSON');
   assertEquals(void 0, fromJSON.indexedInterceptor, 'No indexed interceptor expected in JSON');
 
   // Check that the serialization contains all properties.
   assertEquals(names.length, fromJSON.properties.length, 'Some properties missing in JSON');
-  for (var i = 0; i < fromJSON.properties.length; i++) {
-    var name = fromJSON.properties[i].name;
-    if (typeof name == 'undefined') name = fromJSON.properties[i].index;
+  for (var j = 0; j < names.length; j++) {
+    var name = names[j];
+    // Serialization of symbol-named properties to JSON doesn't really
+    // work currently, as they don't get a {name: ...} entry.
+    if (typeof name === 'symbol') continue;
     var found = false;
-    for (var j = 0; j < names.length; j++) {
-      if (names[j] == name) {
+    for (var i = 0; i < fromJSON.properties.length; i++) {
+      if (fromJSON.properties[i].name == name) {
         // Check that serialized handle is correct.
         assertEquals(properties[i].value().handle(), fromJSON.properties[i].ref, 'Unexpected serialized handle');
 
         // Check that serialized name is correct.
         assertEquals(properties[i].name(), fromJSON.properties[i].name, 'Unexpected serialized name');
 
         // If property type is normal property type is not serialized.
         if (properties[i].propertyType() != debug.PropertyType.Normal) {
           assertEquals(properties[i].propertyType(), fromJSON.properties[i].propertyType, 'Unexpected serialized property type');
         } else {
@@ skipping 33 matching lines @@
     assertTrue(found, '"' + name + '" not found (' + json + ')');
   }
 }
 
 
 function Point(x,y) {
   this.x_ = x;
   this.y_ = y;
 }
 
+var object_with_symbol = {};
+object_with_symbol[Symbol.iterator] = 42;
+
 // Test a number of different objects.
 testObjectMirror({}, 'Object', 'Object');
 testObjectMirror({'a':1,'b':2}, 'Object', 'Object');
 testObjectMirror({'1':void 0,'2':null,'f':function pow(x,y){return Math.pow(x,y);}}, 'Object', 'Object');
 testObjectMirror(new Point(-1.2,2.003), 'Object', 'Point');
 testObjectMirror(this, 'global', '', true);  // Global object has special properties
 testObjectMirror(this.__proto__, 'Object', '');
 testObjectMirror([], 'Array', 'Array');
 testObjectMirror([1,2], 'Array', 'Array');
 testObjectMirror(Object(17), 'Number', 'Number');
+testObjectMirror(object_with_symbol, 'Object', 'Object');
 
 // Test circular references.
 o = {};
 o.o = o;
 testObjectMirror(o, 'Object', 'Object');
 
 // Test that non enumerable properties are part of the mirror
 global_mirror = debug.MakeMirror(this);
 assertEquals('property', global_mirror.property("Math").type());
 assertFalse(global_mirror.property("Math").isEnum(), "Math is enumerable" + global_mirror.property("Math").attributes());
@@ skipping 64 matching lines @@
 }
 assertTrue("[[BoundThis]]" in property_map);
 assertEquals("function", property_map["[[BoundThis]]"].value().type());
 assertEquals(Array, property_map["[[BoundThis]]"].value().value());
 assertTrue("[[TargetFunction]]" in property_map);
 assertEquals("function", property_map["[[TargetFunction]]"].value().type());
 assertEquals(Number, property_map["[[TargetFunction]]"].value().value());
 assertTrue("[[BoundArgs]]" in property_map);
 assertEquals("object", property_map["[[BoundArgs]]"].value().type());
 assertEquals(1, property_map["[[BoundArgs]]"].value().value().length);