Create frequently used symbols in the vm isolate

vm/object_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
+#include "vm/symbols.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 TEST_CASE(Class) {
   // Allocate the class first.
-  const String& class_name = String::Handle(String::NewSymbol("MyClass"));
+  const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(
       Class::New(class_name, script, Scanner::kDummyTokenIndex));
 
   // Class has no fields.
   const Array& no_fields = Array::Handle(Array::Empty());
   cls.SetFields(no_fields);
 
   // Create and populate the function arrays.
   const Array& functions = Array::Handle(Array::New(6));
   Function& function = Function::Handle();
   String& function_name = String::Handle();
-  function_name = String::NewSymbol("foo");
+  function_name = Symbols::New("foo");
   function = Function::New(
       function_name, RawFunction::kRegularFunction, false, false, 0);
   functions.SetAt(0, function);
-  function_name = String::NewSymbol("bar");
+  function_name = Symbols::New("bar");
   function = Function::New(
       function_name, RawFunction::kRegularFunction, false, false, 0);
 
   const int kNumFixedParameters = 2;
   const int kNumOptionalParameters = 3;
   function.set_num_fixed_parameters(kNumFixedParameters);
   function.set_num_optional_parameters(kNumOptionalParameters);
   functions.SetAt(1, function);
 
-  function_name = String::NewSymbol("baz");
+  function_name = Symbols::New("baz");
   function = Function::New(
       function_name, RawFunction::kRegularFunction, false, false, 0);
   functions.SetAt(2, function);
 
-  function_name = String::NewSymbol("Foo");
+  function_name = Symbols::New("Foo");
   function = Function::New(
       function_name, RawFunction::kRegularFunction, true, false, 0);
   functions.SetAt(3, function);
-  function_name = String::NewSymbol("Bar");
+  function_name = Symbols::New("Bar");
   function = Function::New(
       function_name, RawFunction::kRegularFunction, true, false, 0);
   functions.SetAt(4, function);
-  function_name = String::NewSymbol("BaZ");
+  function_name = Symbols::New("BaZ");
   function = Function::New(
       function_name, RawFunction::kRegularFunction, true, false, 0);
   functions.SetAt(5, function);
 
   // Setup the functions in the class.
   cls.SetFunctions(functions);
 
   function_name = String::New("Foo");
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(function.IsNull());
@@ skipping 19 matching lines @@
 
   function_name = String::New("bar");
   function = cls.LookupDynamicFunction(function_name);
   EXPECT(!function.IsNull());
   EXPECT_EQ(kNumFixedParameters, function.num_fixed_parameters());
   EXPECT_EQ(kNumOptionalParameters, function.num_optional_parameters());
 
   const Array& interfaces = Array::Handle(Array::New(2));
   Class& interface = Class::Handle();
   String& interface_name = String::Handle();
-  interface_name = String::NewSymbol("Harley");
+  interface_name = Symbols::New("Harley");
   interface = Class::New(interface_name, script, Scanner::kDummyTokenIndex);
   interfaces.SetAt(0, Type::Handle(Type::NewNonParameterizedType(interface)));
-  interface_name = String::NewSymbol("Norton");
+  interface_name = Symbols::New("Norton");
   interface = Class::New(interface_name, script, Scanner::kDummyTokenIndex);
   interfaces.SetAt(1, Type::Handle(Type::NewNonParameterizedType(interface)));
   cls.set_interfaces(interfaces);
   cls.Finalize();
 
   const Array& array = Array::Handle(cls.functions_cache());
   array.SetAt(0, function_name);
   cls.set_functions_cache(array);
   String& test_name = String::Handle();
   test_name ^= Array::Handle(cls.functions_cache()).At(0);
@@ skipping 39 matching lines @@
   iterator.Advance();
   iterator.Advance();  // Advance to '.' token.
   EXPECT_EQ(Token::kPERIOD, iterator.CurrentTokenKind());
   iterator.Advance();  // Advance to end of stream.
   EXPECT_EQ(Token::kEOS, iterator.CurrentTokenKind());
 }
 
 
 TEST_CASE(InstanceClass) {
   // Allocate the class first.
-  String& class_name = String::Handle(String::NewSymbol("EmptyClass"));
+  String& class_name = String::Handle(Symbols::New("EmptyClass"));
   Script& script = Script::Handle();
   const Class& empty_class =
       Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
 
   // No functions and no super class for the EmptyClass.
   const Array& no_fields = Array::Handle(Array::Empty());
   empty_class.SetFields(no_fields);
   empty_class.Finalize();
   EXPECT_EQ(kObjectAlignment, empty_class.instance_size());
   Instance& instance = Instance::Handle(Instance::New(empty_class));
   EXPECT_EQ(empty_class.raw(), instance.clazz());
 
-  class_name = String::NewSymbol("OneFieldClass");
+  class_name = Symbols::New("OneFieldClass");
   const Class& one_field_class =
       Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
 
   // No functions and no super class for the OneFieldClass.
   const Array& one_fields = Array::Handle(Array::New(1));
-  const String& field_name = String::Handle(String::NewSymbol("the_field"));
+  const String& field_name = String::Handle(Symbols::New("the_field"));
   const Field& field = Field::Handle(Field::New(field_name, false, false, 0));
   one_fields.SetAt(0, field);
   one_field_class.SetFields(one_fields);
   one_field_class.Finalize();
   intptr_t header_size = sizeof(RawObject);
   EXPECT_EQ(Utils::RoundUp((header_size + (1 * kWordSize)), kObjectAlignment),
             one_field_class.instance_size());
   EXPECT_EQ(header_size, field.Offset());
 }
 
 
 TEST_CASE(Interface) {
-  String& class_name = String::Handle(String::NewSymbol("EmptyClass"));
+  String& class_name = String::Handle(Symbols::New("EmptyClass"));
   Script& script = Script::Handle();
   const Class& factory_class =
       Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
   const Array& no_fields = Array::Handle(Array::Empty());
   // Finalizes the class.
   factory_class.SetFields(no_fields);
 
-  String& interface_name = String::Handle(String::NewSymbol("MyInterface"));
+  String& interface_name = String::Handle(Symbols::New("MyInterface"));
   const Class& interface = Class::Handle(
       Class::NewInterface(interface_name, script, Scanner::kDummyTokenIndex));
   EXPECT(interface.is_interface());
   EXPECT(!factory_class.is_interface());
   EXPECT(!interface.HasFactoryClass());
   interface.set_factory_class(factory_class);
   EXPECT_EQ(factory_class.raw(), interface.FactoryClass());
 }
 
 
@@ skipping 1440 matching lines @@
 
   const String& substr = String::Handle(String::SubString(str, 1, 2));
   EXPECT(!substr.IsExternalFourByteString());
   EXPECT(substr.IsFourByteString());
   EXPECT_EQ(2, substr.Length());
   EXPECT(substr.Equals("\xF0\x9D\x97\x88\xF0\x9D\x97\x8E"));
 }
 
 
 TEST_CASE(Symbol) {
-  const String& one = String::Handle(String::NewSymbol("Eins"));
+  const String& one = String::Handle(Symbols::New("Eins"));
   EXPECT(one.IsSymbol());
-  const String& two = String::Handle(String::NewSymbol("Zwei"));
-  const String& three = String::Handle(String::NewSymbol("Drei"));
-  const String& four = String::Handle(String::NewSymbol("Vier"));
-  const String& five = String::Handle(String::NewSymbol("Fuenf"));
-  const String& six = String::Handle(String::NewSymbol("Sechs"));
-  const String& seven = String::Handle(String::NewSymbol("Sieben"));
-  const String& eight = String::Handle(String::NewSymbol("Acht"));
-  const String& nine = String::Handle(String::NewSymbol("Neun"));
-  const String& ten = String::Handle(String::NewSymbol("Zehn"));
-  String& eins = String::Handle(String::NewSymbol("Eins"));
+  const String& two = String::Handle(Symbols::New("Zwei"));
+  const String& three = String::Handle(Symbols::New("Drei"));
+  const String& four = String::Handle(Symbols::New("Vier"));
+  const String& five = String::Handle(Symbols::New("Fuenf"));
+  const String& six = String::Handle(Symbols::New("Sechs"));
+  const String& seven = String::Handle(Symbols::New("Sieben"));
+  const String& eight = String::Handle(Symbols::New("Acht"));
+  const String& nine = String::Handle(Symbols::New("Neun"));
+  const String& ten = String::Handle(Symbols::New("Zehn"));
+  String& eins = String::Handle(Symbols::New("Eins"));
   EXPECT_EQ(one.raw(), eins.raw());
   EXPECT(one.raw() != two.raw());
   EXPECT(two.Equals(String::Handle(String::New("Zwei"))));
-  EXPECT_EQ(two.raw(), String::NewSymbol("Zwei"));
-  EXPECT_EQ(three.raw(), String::NewSymbol("Drei"));
-  EXPECT_EQ(four.raw(), String::NewSymbol("Vier"));
-  EXPECT_EQ(five.raw(), String::NewSymbol("Fuenf"));
-  EXPECT_EQ(six.raw(), String::NewSymbol("Sechs"));
-  EXPECT_EQ(seven.raw(), String::NewSymbol("Sieben"));
-  EXPECT_EQ(eight.raw(), String::NewSymbol("Acht"));
-  EXPECT_EQ(nine.raw(), String::NewSymbol("Neun"));
-  EXPECT_EQ(ten.raw(), String::NewSymbol("Zehn"));
+  EXPECT_EQ(two.raw(), Symbols::New("Zwei"));
+  EXPECT_EQ(three.raw(), Symbols::New("Drei"));
+  EXPECT_EQ(four.raw(), Symbols::New("Vier"));
+  EXPECT_EQ(five.raw(), Symbols::New("Fuenf"));
+  EXPECT_EQ(six.raw(), Symbols::New("Sechs"));
+  EXPECT_EQ(seven.raw(), Symbols::New("Sieben"));
+  EXPECT_EQ(eight.raw(), Symbols::New("Acht"));
+  EXPECT_EQ(nine.raw(), Symbols::New("Neun"));
+  EXPECT_EQ(ten.raw(), Symbols::New("Zehn"));
 
   // Make sure to cause symbol table overflow.
   for (int i = 0; i < 1024; i++) {
     char buf[256];
     OS::SNPrint(buf, sizeof(buf), "%d", i);
-    String::NewSymbol(buf);
+    Symbols::New(buf);
   }
-  eins = String::NewSymbol("Eins");
+  eins = Symbols::New("Eins");
   EXPECT_EQ(one.raw(), eins.raw());
-  EXPECT_EQ(two.raw(), String::NewSymbol("Zwei"));
-  EXPECT_EQ(three.raw(), String::NewSymbol("Drei"));
-  EXPECT_EQ(four.raw(), String::NewSymbol("Vier"));
-  EXPECT_EQ(five.raw(), String::NewSymbol("Fuenf"));
-  EXPECT_EQ(six.raw(), String::NewSymbol("Sechs"));
-  EXPECT_EQ(seven.raw(), String::NewSymbol("Sieben"));
-  EXPECT_EQ(eight.raw(), String::NewSymbol("Acht"));
-  EXPECT_EQ(nine.raw(), String::NewSymbol("Neun"));
-  EXPECT_EQ(ten.raw(), String::NewSymbol("Zehn"));
+  EXPECT_EQ(two.raw(), Symbols::New("Zwei"));
+  EXPECT_EQ(three.raw(), Symbols::New("Drei"));
+  EXPECT_EQ(four.raw(), Symbols::New("Vier"));
+  EXPECT_EQ(five.raw(), Symbols::New("Fuenf"));
+  EXPECT_EQ(six.raw(), Symbols::New("Sechs"));
+  EXPECT_EQ(seven.raw(), Symbols::New("Sieben"));
+  EXPECT_EQ(eight.raw(), Symbols::New("Acht"));
+  EXPECT_EQ(nine.raw(), Symbols::New("Neun"));
+  EXPECT_EQ(ten.raw(), Symbols::New("Zehn"));
 
   // Symbols from Strings.
   eins = String::New("Eins");
   EXPECT(!eins.IsSymbol());
-  String& ein_symbol = String::Handle(String::NewSymbol(eins));
+  String& ein_symbol = String::Handle(Symbols::New(eins));
   EXPECT_EQ(one.raw(), ein_symbol.raw());
   EXPECT(one.raw() != eins.raw());
 
   uint32_t char32[] = { 'E', 'l', 'f' };
-  String& elf = String::Handle(String::NewSymbol(char32, 3));
+  String& elf = String::Handle(Symbols::New(char32, 3));
   EXPECT(elf.IsSymbol());
-  EXPECT_EQ(elf.raw(), String::NewSymbol("Elf"));
+  EXPECT_EQ(elf.raw(), Symbols::New("Elf"));
 }
 
 
 TEST_CASE(Bool) {
   const Bool& true_value = Bool::Handle(Bool::True());
   EXPECT(true_value.value());
   const Bool& false_value = Bool::Handle(Bool::False());
   EXPECT(!false_value.value());
 }
 
@@ skipping 582 matching lines @@
   var_c = outer_scope->LocalLookupVariable(c);
   EXPECT(var_c->is_captured());
   EXPECT_EQ(1, var_c->index());
   EXPECT_EQ(parent_scope_context_level - local_scope_context_level,
             var_c->owner()->context_level());  // Adjusted context level.
 }
 
 
 TEST_CASE(Closure) {
   // Allocate the class first.
-  const String& class_name = String::Handle(String::NewSymbol("MyClass"));
+  const String& class_name = String::Handle(Symbols::New("MyClass"));
   const Script& script = Script::Handle();
   const Class& cls =
       Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
   const Array& functions = Array::Handle(Array::New(1));
 
   const Context& context = Context::Handle(Context::New(0));
   Function& parent = Function::Handle();
-  const String& parent_name = String::Handle(String::NewSymbol("foo_papa"));
+  const String& parent_name = String::Handle(Symbols::New("foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
                          false, false, 0);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
   Function& function = Function::Handle();
-  const String& function_name = String::Handle(String::NewSymbol("foo"));
+  const String& function_name = String::Handle(Symbols::New("foo"));
   function = Function::NewClosureFunction(function_name, parent, 0);
   const Class& signature_class = Class::Handle(
       Class::NewSignatureClass(function_name, function, script));
   const Closure& closure = Closure::Handle(Closure::New(function, context));
   const Class& closure_class = Class::Handle(closure.clazz());
   EXPECT(closure_class.IsSignatureClass());
   EXPECT(closure_class.IsCanonicalSignatureClass());
   EXPECT_EQ(closure_class.raw(), signature_class.raw());
   const Function& signature_function =
     Function::Handle(signature_class.signature_function());
@@ skipping 41 matching lines @@
   str3 = OneByteString::null();
   EXPECT(str3.IsString());
   EXPECT(!str3.IsOneByteString());
 }
 
 
 // only ia32 and x64 can run execution tests.
 #if defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64)
 
 static Function* CreateFunction(const char* name) {
-  const String& function_name = String::ZoneHandle(String::NewSymbol(name));
+  const String& function_name = String::ZoneHandle(Symbols::New(name));
   Function& function = Function::ZoneHandle(
       Function::New(function_name, RawFunction::kRegularFunction,
                     true, false, 0));
   return &function;
 }
 
 // Test for Code and Instruction object creation.
 TEST_CASE(Code) {
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
@@ skipping 122 matching lines @@
   EXPECT_EQ(20, pc_descs.TokenIndex(0));
   EXPECT_EQ(3, pc_descs.TryIndex(5));
   EXPECT_EQ(static_cast<uword>(80), pc_descs.PC(5));
   EXPECT_EQ(150, pc_descs.TokenIndex(5));
   EXPECT_EQ(PcDescriptors::kOther, pc_descs.DescriptorKind(0));
   EXPECT_EQ(PcDescriptors::kDeopt, pc_descs.DescriptorKind(1));
 }
 
 
 static RawClass* CreateTestClass(const char* name) {
-  const String& class_name = String::Handle(String::NewSymbol(name));
+  const String& class_name = String::Handle(Symbols::New(name));
   const Class& cls = Class::Handle(
       Class::New(class_name, Script::Handle(), Scanner::kDummyTokenIndex));
   return cls.raw();
 }
 
 
 static RawField* CreateTestField(const char* name) {
   const Class& cls = Class::Handle(CreateTestClass("global:"));
-  const String& field_name = String::Handle(String::NewSymbol(name));
+  const String& field_name = String::Handle(Symbols::New(name));
   const Field& field = Field::Handle(Field::New(field_name, true, false, 0));
   field.set_owner(cls);
   return field.raw();
 }
 
 
 TEST_CASE(ClassDictionaryIterator) {
   Class& ae66 = Class::ZoneHandle(CreateTestClass("Ae6/6"));
   Class& re44 = Class::ZoneHandle(CreateTestClass("Re4/4"));
   Field& ce68 = Field::ZoneHandle(CreateTestField("Ce6/8"));
@@ skipping 10 matching lines @@
   while (iterator.HasNext()) {
     cls = iterator.GetNextClass();
     ASSERT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
   ASSERT(count == 2);
 }
 
 
 static RawFunction* GetDummyTarget(const char* name) {
-  const String& function_name = String::Handle(String::NewSymbol(name));
+  const String& function_name = String::Handle(Symbols::New(name));
   const bool is_static = false;
   const bool is_const = false;
   return Function::New(function_name,
                        RawFunction::kRegularFunction,
                        is_static,
                        is_const,
                        0);
 }
 
 
@@ skipping 44 matching lines @@
   EXPECT_EQ(1, o2.NumberOfChecks());
   o2.GetCheckAt(0, &test_class_ids, &test_target);
   EXPECT_EQ(2, test_class_ids.length());
   EXPECT_EQ(kSmi, test_class_ids[0]);
   EXPECT_EQ(kSmi, test_class_ids[1]);
   EXPECT_EQ(target1.raw(), test_target.raw());
 }
 
 
 TEST_CASE(SubtypeTestCache) {
-  String& class_name = String::Handle(String::NewSymbol("EmptyClass"));
+  String& class_name = String::Handle(Symbols::New("EmptyClass"));
   Script& script = Script::Handle();
   const Class& empty_class =
       Class::Handle(Class::New(class_name, script, Scanner::kDummyTokenIndex));
   SubtypeTestCache& cache = SubtypeTestCache::Handle(SubtypeTestCache::New());
   ASSERT(!cache.IsNull());
   EXPECT_EQ(0, cache.NumberOfChecks());
   const TypeArguments& targ_0 = TypeArguments::Handle(TypeArguments::New(2));
   const TypeArguments& targ_1 = TypeArguments::Handle(TypeArguments::New(3));
   cache.AddCheck(empty_class.id(), targ_0, targ_1, Bool::Handle(Bool::True()));
   EXPECT_EQ(1, cache.NumberOfChecks());
@@ skipping 126 matching lines @@
   // Named double-private constructor mismatch.
   mangled_name = OneByteString::New("foo@12345.named@12345");
   bare_name = OneByteString::New("foo.name");
   EXPECT(!mangled_name.EqualsIgnoringPrivateKey(bare_name));
 }
 
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart