Create frequently used symbols in the vm isolate

vm/parser_test.cc

 // Copyright (c) 2011, 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 "vm/ast_printer.h"
 #include "vm/class_finalizer.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/parser.h"
+#include "vm/symbols.h"
 #include "vm/unit_test.h"
 
 namespace dart {
 
 
 void DumpFunction(const Library& lib, const char* cname, const char* fname) {
-  const String& classname = String::Handle(String::NewSymbol(cname));
+  const String& classname = String::Handle(Symbols::New(cname));
   Class& cls = Class::Handle(lib.LookupClass(classname));
   EXPECT(!cls.IsNull());
 
   String& funcname = String::Handle(String::New(fname));
   Function& function = Function::Handle(cls.LookupStaticFunction(funcname));
   EXPECT(!function.IsNull());
 
   bool retval;
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
@@ skipping 13 matching lines @@
   EXPECT(retval);
   isolate->set_long_jump_base(base);
 }
 
 
 void CheckField(const Library& lib,
                 const char* class_name,
                 const char* field_name,
                 bool expect_static,
                 bool is_final) {
-  const String& classname = String::Handle(String::NewSymbol(class_name));
+  const String& classname = String::Handle(Symbols::New(class_name));
   Class& cls = Class::Handle(lib.LookupClass(classname));
   EXPECT(!cls.IsNull());
 
   String& fieldname = String::Handle(String::New(field_name));
   String& functionname = String::Handle();
   Function& function = Function::Handle();
   Field& field = Field::Handle();
   if (expect_static) {
     field ^= cls.LookupStaticField(fieldname);
     functionname ^= Field::GetterName(fieldname);
@@ skipping 14 matching lines @@
   EXPECT(!field.IsNull());
 
   EXPECT_EQ(field.is_static(), expect_static);
 }
 
 
 void CheckFunction(const Library& lib,
                    const char* class_name,
                    const char* function_name,
                    bool expect_static) {
-  const String& classname = String::Handle(String::NewSymbol(class_name));
+  const String& classname = String::Handle(Symbols::New(class_name));
   Class& cls = Class::Handle(lib.LookupClass(classname));
   EXPECT(!cls.IsNull());
 
   String& functionname = String::Handle(String::New(function_name));
   Function& function = Function::Handle();
   if (expect_static) {
     function ^= cls.LookupStaticFunction(functionname);
   } else {
     function ^= cls.LookupDynamicFunction(functionname);
   }
@@ skipping 25 matching lines @@
   Parser::ParseCompilationUnit(lib, script);
   EXPECT(ClassFinalizer::FinalizePendingClasses());
   CheckField(lib, "A", "f1", false, false);
   CheckField(lib, "A", "f2", false, true);
   CheckField(lib, "A", "f3", false, true);
   CheckField(lib, "A", "f4", false, true);
   CheckField(lib, "A", "s1", true, false);
   CheckField(lib, "A", "s2", true, false);
   // No field entries are added for static const fields.
   String& fieldname = String::Handle(String::New("s3"));
-  const String& classname = String::Handle(String::NewSymbol("A"));
+  const String& classname = String::Handle(Symbols::New("A"));
   const Class& cls = Class::Handle(lib.LookupClass(classname));
   const Field& field = Field::Handle(cls.LookupStaticField(fieldname));
   EXPECT(!field.IsNull());
   Object& val = Object::Handle(field.value());
   // The static const field initializer is not evaluated and the field
   // value is not initialized until the field is referenced by code that
   // is compiled.
   EXPECT(val.raw() == Object::sentinel());
 
   CheckFunction(lib, "A", "bar", true);
@@ skipping 23 matching lines @@
   Parser::ParseCompilationUnit(lib, script);
   EXPECT(ClassFinalizer::FinalizePendingClasses());
 
   DumpFunction(lib, "A", "foo");
   DumpFunction(lib, "A", "bar");
   DumpFunction(lib, "A", "baz");
   DumpFunction(lib, "B", "bam");
 }
 
 }  // namespace dart