ES6 symbols: implement name property

src/runtime.cc

Index: src/runtime.cc
diff --git a/src/runtime.cc b/src/runtime.cc
index 8ca8d58a45bddbedc6efdb218b398301da4c0a28..8e695d67f12f88beb8e33fa7eee4a822a4e6e38c 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -683,9 +683,23 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_CreateArrayLiteralShallow) {
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_CreateSymbol) {
+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
+  Handle<Object> name(args[0], isolate);

[Michael Starzinger, 2013/03/22 12:03:25]

If you use the following instead, you can get by without allocating a handle and
hence with a NoHandleAllocation scope instead.

Handle<Object> name = args.at<Object>(0);

We might even support the following by now, not sure though. I would prefer the
second if possible.

CONVERT_ARG_HANDLE_CHECKED(Object, name, 0);

[rossberg, 2013/03/22 13:02:42]

Done.

+  RUNTIME_ASSERT(name->IsString() || name->IsUndefined());
+  Symbol* symbol;
+  MaybeObject* maybe = isolate->heap()->AllocateSymbol();
+  if (!maybe->To(&symbol)) return maybe;
+  if (name->IsString()) symbol->set_name(*name);
+  return symbol;
+}
+
+
+RUNTIME_FUNCTION(MaybeObject*, Runtime_SymbolName) {
   NoHandleAllocation ha(isolate);
-  ASSERT(args.length() == 0);
-  return isolate->heap()->AllocateSymbol();
+  ASSERT(args.length() == 1);
+  CONVERT_ARG_CHECKED(Symbol, symbol, 0);
+  return symbol->name();
 }