ES6: Add Object.getOwnPropertySymbols

test/mjsunit/harmony/symbols.js

 // Copyright 2013 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 255 matching lines @@
 
 function TestKeyGet(obj) {
   var obj2 = Object.create(obj)
   for (var i in symbols) {
     assertEquals(i|0, obj[symbols[i]])
     assertEquals(i|0, obj2[symbols[i]])
   }
 }
 
 
-function TestKeyHas() {
+function TestKeyHas(obj) {
   for (var i in symbols) {
     assertTrue(symbols[i] in obj)
     assertTrue(Object.hasOwnProperty.call(obj, symbols[i]))
   }
 }
 
 
 function TestKeyEnum(obj) {
   for (var name in obj) {
     assertEquals("string", typeof name)
   }
 }
 
 
 function TestKeyNames(obj) {
   assertEquals(0, Object.keys(obj).length)
 
   var names = Object.getOwnPropertyNames(obj)
   for (var i in names) {
     assertEquals("string", typeof names[i])
   }
 }
 
 
+function TestGetOwnPropertySymbols(obj) {
+  var syms = Object.getOwnPropertySymbols(obj)
+  assertEquals(syms.length, symbols.length)
+  for (var i in syms) {
+    assertEquals("symbol", typeof syms[i])
+  }
+}
+
+
 function TestKeyDescriptor(obj) {
   for (var i in symbols) {
     var desc = Object.getOwnPropertyDescriptor(obj, symbols[i]);
     assertEquals(i|0, desc.value)
     assertTrue(desc.configurable)
     assertEquals(i % 2 == 0, desc.writable)
     assertEquals(i % 2 == 0, desc.enumerable)
     assertEquals(i % 2 == 0,
         Object.prototype.propertyIsEnumerable.call(obj, symbols[i]))
   }
@@ skipping 13 matching lines @@
 var objs = [{}, [], Object.create(null), Object(1), new Map, function(){}]
 
 for (var i in objs) {
   var obj = objs[i]
   TestKeySet(obj)
   TestKeyDefine(obj)
   TestKeyGet(obj)
   TestKeyHas(obj)
   TestKeyEnum(obj)
   TestKeyNames(obj)
+  TestGetOwnPropertySymbols(obj)
   TestKeyDescriptor(obj)
   TestKeyDelete(obj)
 }
 
 
 function TestCachedKeyAfterScavenge() {
   gc();
   // Keyed property lookup are cached.  Hereby we assume that the keys are
   // tenured, so that we only have to clear the cache between mark compacts,
   // but not between scavenges.  This must also apply for symbol keys.
   var key = Symbol("key");
   var a = {};
   a[key] = "abc";
 
   for (var i = 0; i < 100000; i++) {
     a[key] += "a";  // Allocations cause a scavenge.
   }
 }
 TestCachedKeyAfterScavenge();
+
+
+function TestGetOwnPropertySymbolsWithProto() {
+  // We need to be have fast properties to have insertion order for property
+  // keys. The current limit is currently 30 properties.
+  var syms = symbols.slice(0, 30);
+  var proto = {}
+  var object = Object.create(proto)
+  for (var i = 0; i < syms.length; i++) {
+    // Even on object, odd on proto.
+    if (i % 2) {
+      proto[syms[i]] = i
+    } else {
+      object[syms[i]] = i
+    }
+  }
+
+  assertTrue(%HasFastProperties(object));
+
+  var objectOwnSymbols = Object.getOwnPropertySymbols(object)
+  assertEquals(objectOwnSymbols.length, syms.length / 2)
+
+  for (var i = 0; i < objectOwnSymbols.length; i++) {
+    assertEquals(objectOwnSymbols[i], syms[i * 2])
+  }
+}
+TestGetOwnPropertySymbolsWithProto()
+
+
+function TestGetOwnPropertySymbolsWithPrivateSymbols() {
+  var privateSymbol = %CreatePrivateSymbol("private")
+  var publicSymbol = Symbol()
+  var publicSymbol2 = Symbol()
+  var obj = {}
+  obj[publicSymbol] = 1
+  obj[privateSymbol] = 2
+  obj[publicSymbol2] = 3
+  var syms = Object.getOwnPropertySymbols(obj)
+  assertEquals(syms, [publicSymbol, publicSymbol2])
+}
+TestGetOwnPropertySymbolsWithPrivateSymbols()