ES6 symbols: turn symbols into a proper primitive type

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 16 matching lines @@
 
 // Flags: --harmony-symbols --harmony-collections
 // Flags: --expose-gc --allow-natives-syntax
 
 var symbols = []
 
 // Test different forms of constructor calls, all equivalent.
 function TestNew() {
   function IndirectSymbol() { return new Symbol }
   function indirect() { return new IndirectSymbol() }
-  for (var i = 0; i < 10; ++i) {
-    symbols.push(new Symbol)
-    symbols.push(new Symbol())
-    symbols.push(Symbol())
-    symbols.push(indirect())
-  }
-  %OptimizeFunctionOnNextCall(indirect)
-  indirect()  // Call once before GC throws away type feedback.
-  gc()        // Promote existing symbols and then allocate some more.
-  for (var i = 0; i < 10; ++i) {
-    symbols.push(new Symbol)
-    symbols.push(new Symbol())
-    symbols.push(Symbol())
-    symbols.push(indirect())
+  for (var i = 0; i < 2; ++i) {
+    for (var j = 0; j < 5; ++j) {
+      symbols.push(Symbol())
+      symbols.push(Symbol(Symbol()))
+      symbols.push((new Symbol).valueOf())
+      symbols.push((new Symbol()).valueOf())
+      symbols.push((new Symbol(Symbol())).valueOf())
+      symbols.push(Object(Symbol()).valueOf())
+      symbols.push((indirect()).valueOf())
+    }
+    %OptimizeFunctionOnNextCall(indirect)
+    indirect()  // Call once before GC throws away type feedback.
+    gc()        // Promote existing symbols and then allocate some more.
   }
 }
 TestNew()
 
 
 function TestType() {
   for (var i in symbols) {
-    assertTrue(%_IsSymbol(symbols[i]))
-    assertEquals("object", typeof symbols[i])
-    assertTrue(typeof symbols[i] === "object")
-    assertEquals("[object Symbol]", Object.prototype.toString.call(symbols[i]))
+    assertEquals("symbol", typeof symbols[i])
+    assertTrue(typeof symbols[i] === "symbol")
+    assertEquals(null, %_ClassOf(symbols[i]))
+    assertEquals("Symbol", %_ClassOf(new Symbol(symbols[i])))
+    assertEquals("Symbol", %_ClassOf(Object(symbols[i])))
   }
 }
 TestType()
 
 
+function TestPrototype() {
+  assertSame(Object.prototype, Symbol.prototype.__proto__)
+  assertSame(Symbol.prototype, Symbol().__proto__)
+  assertSame(Symbol.prototype, Symbol(Symbol()).__proto__)
+  assertSame(Symbol.prototype, (new Symbol).__proto__)
+  assertSame(Symbol.prototype, (new Symbol()).__proto__)
+  assertSame(Symbol.prototype, (new Symbol(Symbol())).__proto__)
+  assertSame(Symbol.prototype, Object(Symbol()).__proto__)
+  for (var i in symbols) {
+    assertSame(Symbol.prototype, symbols[i].__proto__)
+  }
+}
+TestPrototype()
+
+
+function TestToString() {
+  for (var i in symbols) {
+    assertThrows(function() { String(symbols[i]) }, TypeError)
+    assertThrows(function() { symbols[i] + "" }, TypeError)
+    assertThrows(function() { symbols[i].toString() }, TypeError)
+    assertThrows(function() { (new Symbol(symbols[i])).toString() }, TypeError)
+    assertThrows(function() { Object(symbols[i]).toString() }, TypeError)
+    assertEquals("[object Symbol]", Object.prototype.toString.call(symbols[i]))
+  }
+}
+TestToString()
+
+
+function TestToBoolean() {
+  for (var i in symbols) {
+    assertTrue(Boolean(symbols[i]).valueOf())
+    assertFalse(!symbols[i])
+    assertTrue(!!symbols[i])
+    assertTrue(symbols[i] && true)
+    assertFalse(!symbols[i] && false)
+    assertTrue(!symbols[i] || true)
+    assertEquals(1, symbols[i] ? 1 : 2)
+    assertEquals(2, !symbols[i] ? 1 : 2)
+    if (!symbols[i]) assertUnreachable();
+    if (symbols[i]) {} else assertUnreachable();
+  }
+}
+TestToBoolean()
+
+
+function TestToNumber() {
+  for (var i in symbols) {
+    assertSame(NaN, Number(symbols[i]).valueOf())
+    assertSame(NaN, symbols[i] + 0)
+  }
+}
+TestToNumber()
+
+
 function TestEquality() {
   // Every symbol should equal itself.
   for (var i in symbols) {
     assertSame(symbols[i], symbols[i])
     assertEquals(symbols[i], symbols[i])
     assertTrue(Object.is(symbols[i], symbols[i]))
     assertTrue(symbols[i] === symbols[i])
     assertTrue(symbols[i] == symbols[i])
   }
 
   // All symbols should be distinct.
   for (var i = 0; i < symbols.length; ++i) {
     for (var j = i + 1; j < symbols.length; ++j) {
       assertFalse(Object.is(symbols[i], symbols[j]))
       assertFalse(symbols[i] === symbols[j])
       assertFalse(symbols[i] == symbols[j])
     }
   }
 }
 TestEquality()
 
 
 function TestGet() {
   for (var i in symbols) {
-    assertEquals("[object Symbol]", symbols[i].toString())
-    assertEquals(undefined, symbols[i].valueOf)
+    assertThrows(function() { symbols[i].toString() }, TypeError)
+    assertEquals(symbols[i], symbols[i].valueOf())
     assertEquals(undefined, symbols[i].a)
     assertEquals(undefined, symbols[i]["a" + "b"])
     assertEquals(undefined, symbols[i]["" + "1"])
     assertEquals(undefined, symbols[i][62])
   }
 }
 TestGet()
 
 
 function TestSet() {
   for (var i in symbols) {
     symbols[i].toString = 0
-    assertEquals("[object Symbol]", symbols[i].toString())
+    assertThrows(function() { symbols[i].toString() }, TypeError)
+    symbols[i].valueOf = 0
+    assertEquals(symbols[i], symbols[i].valueOf())
     symbols[i].a = 0
     assertEquals(undefined, symbols[i].a)
     symbols[i]["a" + "b"] = 0
     assertEquals(undefined, symbols[i]["a" + "b"])
     symbols[i][62] = 0
     assertEquals(undefined, symbols[i][62])
   }
 }
 TestSet()
 
@@ skipping 56 matching lines @@
 function TestKeyHas() {
   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) {
-    assertFalse(%_IsSymbol(name))
+    assertTrue(typeof name !== "symbol")
   }
 }
 
 
 function TestKeyNames(obj) {
   assertEquals(0, Object.keys(obj).length)
 
   var names = Object.getOwnPropertyNames(obj)
   assertTrue(symbols.length <= names.length)
   // TODO(rossberg): once we have iterators, the following would be:
   //   var expected = new Set(symbols)
   var expected = new Set
   for (var i = 0; i < symbols.length; ++i) expected.add(symbols[i])
   for (var i = 0; i < names.length; ++i) {
     var name = names[i]
-    var asString = String(name)
-    if (asString !== name) {
-      assertEquals("[object Symbol]", asString)
+    if (typeof name === 'symbol') {
       assertTrue(expected.has(name))
       expected.delete(name)
     }
   }
   assertEquals(0, expected.size)
 }
 
 
 function TestKeyDescriptor(obj) {
   for (var i in symbols) {
@@ skipping 24 matching lines @@
   var obj = objs[i]
   TestKeySet(obj)
   TestKeyDefine(obj)
   TestKeyGet(obj)
   TestKeyHas(obj)
   TestKeyEnum(obj)
   TestKeyNames(obj)
   TestKeyDescriptor(obj)
   TestKeyDelete(obj)
 }