[es2015] Precompute the descriptive string for symbols.

src/factory.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/factory.h"
 
 #include "src/accessors.h"
 #include "src/allocation-site-scopes.h"
 #include "src/ast/ast.h"
 #include "src/base/bits.h"
 #include "src/bootstrapper.h"
 #include "src/compiler.h"
 #include "src/conversions.h"
 #include "src/isolate-inl.h"
 #include "src/macro-assembler.h"
 #include "src/objects/frame-array-inl.h"
 #include "src/objects/module-info.h"
 #include "src/objects/scope-info.h"
+#include "src/string-builder.h"
 
 namespace v8 {
 namespace internal {
 
 
 // Calls the FUNCTION_CALL function and retries it up to three times
 // to guarantee that any allocations performed during the call will
 // succeed if there's enough memory.
 //
 // Warning: Do not use the identifiers __object__, __maybe_object__,
@@ skipping 873 matching lines @@
   return iterator;
 }
 
 Handle<Symbol> Factory::NewSymbol() {
   CALL_HEAP_FUNCTION(
       isolate(),
       isolate()->heap()->AllocateSymbol(),
       Symbol);
 }
 
+MaybeHandle<Symbol> Factory::NewSymbol(Handle<Object> name) {
+  DCHECK(name->IsString() || name->IsUndefined(isolate()));
+  Handle<Symbol> symbol = NewSymbol();
+  if (name->IsString()) {
+    // Compute the descriptive string for the {symbol}.
+    Handle<String> descriptive_string;
+    IncrementalStringBuilder builder(isolate());
+    builder.AppendCString("Symbol(");
+    builder.AppendString(Handle<String>::cast(name));
+    builder.AppendCharacter(')');
+    ASSIGN_RETURN_ON_EXCEPTION(isolate(), descriptive_string, builder.Finish(),
+                               Symbol);
+
+    // Make sure those strings are flattened.
+    name = String::Flatten(Handle<String>::cast(name), TENURED);
+    descriptive_string = String::Flatten(descriptive_string, TENURED);
+
+    symbol->set_name(String::cast(*name));
+    symbol->set_descriptive_string(*descriptive_string);
+  }
+  return symbol;
+}
 
 Handle<Symbol> Factory::NewPrivateSymbol() {
   Handle<Symbol> symbol = NewSymbol();
   symbol->set_is_private(true);
   return symbol;
 }
 
+MaybeHandle<Symbol> Factory::NewPrivateSymbol(Handle<Object> name) {
+  Handle<Symbol> symbol;
+  ASSIGN_RETURN_ON_EXCEPTION(isolate(), symbol, NewSymbol(name), Symbol);
+  symbol->set_is_private(true);
+  return symbol;
+}
+
 Handle<JSPromise> Factory::NewJSPromise() {
   Handle<JSFunction> constructor(
       isolate()->native_context()->promise_function(), isolate());
   DCHECK(constructor->has_initial_map());
   Handle<Map> map(constructor->initial_map(), isolate());
 
   DCHECK(!map->is_prototype_map());
   Handle<JSObject> promise_obj = NewJSObjectFromMap(map);
   Handle<JSPromise> promise = Handle<JSPromise>::cast(promise_obj);
   promise->set_status(v8::Promise::kPending);
@@ skipping 2023 matching lines @@
     Handle<AccessorInfo> prototype =
         Accessors::FunctionPrototypeInfo(isolate(), rw_attribs);
     Descriptor d = Descriptor::AccessorConstant(
         Handle<Name>(Name::cast(prototype->name())), prototype, rw_attribs);
     map->AppendDescriptor(&d);
   }
 }
 
 }  // namespace internal
 }  // namespace v8