- Refactor Symbol allocation to expect a thread parameter.

runtime/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/globals.h"
 
 #include "vm/assembler.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 19 matching lines @@
                                   const Script& script) {
   const Class& cls = Class::Handle(
       Class::New(class_name, script, TokenPosition::kNoSource));
   cls.set_is_synthesized_class();  // Dummy class for testing.
   return cls.raw();
 }
 
 
 VM_TEST_CASE(Class) {
   // Allocate the class first.
-  const String& class_name = String::Handle(Symbols::New("MyClass"));
+  const String& class_name = String::Handle(Symbols::New(thread, "MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
 
   // Class has no fields and no functions yet.
   EXPECT_EQ(Array::Handle(cls.fields()).Length(), 0);
   EXPECT_EQ(Array::Handle(cls.functions()).Length(), 0);
 
   // Setup the interfaces in the class.
   const Array& interfaces = Array::Handle(Array::New(2));
   Class& interface = Class::Handle();
   String& interface_name = String::Handle();
-  interface_name = Symbols::New("Harley");
+  interface_name = Symbols::New(thread, "Harley");
   interface = CreateDummyClass(interface_name, script);
   interfaces.SetAt(0, Type::Handle(Type::NewNonParameterizedType(interface)));
-  interface_name = Symbols::New("Norton");
+  interface_name = Symbols::New(thread, "Norton");
   interface = CreateDummyClass(interface_name, script);
   interfaces.SetAt(1, Type::Handle(Type::NewNonParameterizedType(interface)));
   cls.set_interfaces(interfaces);
 
   // Finalization of types happens before the fields and functions have been
   // parsed.
   ClassFinalizer::FinalizeTypesInClass(cls);
 
   // 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 = Symbols::New("foo");
+  function_name = Symbols::New(thread, "foo");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
       false, false, false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(0, function);
-  function_name = Symbols::New("bar");
+  function_name = Symbols::New(thread, "bar");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
       false, false, false, false, false, cls, TokenPosition::kMinSource);
 
   const int kNumFixedParameters = 2;
   const int kNumOptionalParameters = 3;
   const bool kAreOptionalPositional = true;
   function.set_num_fixed_parameters(kNumFixedParameters);
   function.SetNumOptionalParameters(kNumOptionalParameters,
                                     kAreOptionalPositional);
   functions.SetAt(1, function);
 
-  function_name = Symbols::New("baz");
+  function_name = Symbols::New(thread, "baz");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
       false, false, false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(2, function);
 
-  function_name = Symbols::New("Foo");
+  function_name = Symbols::New(thread, "Foo");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
       true, false, false, false, false, cls, TokenPosition::kMinSource);
 
   functions.SetAt(3, function);
-  function_name = Symbols::New("Bar");
+  function_name = Symbols::New(thread, "Bar");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
       true, false, false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(4, function);
-  function_name = Symbols::New("BaZ");
+  function_name = Symbols::New(thread, "BaZ");
   function = Function::New(
       function_name, RawFunction::kRegularFunction,
       true, false, false, false, false, cls, TokenPosition::kMinSource);
   functions.SetAt(5, function);
 
   // Setup the functions in the class.
   cls.SetFunctions(functions);
 
   // The class can now be finalized.
   cls.Finalize();
@@ skipping 137 matching lines @@
   const Script& scr = Script::Handle(cls.script());
   intptr_t line;
   intptr_t col;
   scr.GetTokenLocation(end_token_pos, &line, &col);
   EXPECT(line == 10 && col == 1);
 }
 
 
 VM_TEST_CASE(InstanceClass) {
   // Allocate the class first.
-  String& class_name = String::Handle(Symbols::New("EmptyClass"));
+  String& class_name = String::Handle(Symbols::New(thread, "EmptyClass"));
   Script& script = Script::Handle();
   const Class& empty_class =
       Class::Handle(CreateDummyClass(class_name, script));
 
   // EmptyClass has no fields and no functions.
   EXPECT_EQ(Array::Handle(empty_class.fields()).Length(), 0);
   EXPECT_EQ(Array::Handle(empty_class.functions()).Length(), 0);
 
   ClassFinalizer::FinalizeTypesInClass(empty_class);
   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 = Symbols::New("OneFieldClass");
+  class_name = Symbols::New(thread, "OneFieldClass");
   const Class& one_field_class =
       Class::Handle(CreateDummyClass(class_name, script));
 
   // No fields, functions, or super type for the OneFieldClass.
   EXPECT_EQ(Array::Handle(empty_class.fields()).Length(), 0);
   EXPECT_EQ(Array::Handle(empty_class.functions()).Length(), 0);
   EXPECT_EQ(empty_class.super_type(), AbstractType::null());
   ClassFinalizer::FinalizeTypesInClass(one_field_class);
 
   const Array& one_fields = Array::Handle(Array::New(1));
-  const String& field_name = String::Handle(Symbols::New("the_field"));
+  const String& field_name = String::Handle(Symbols::New(thread, "the_field"));
   const Field& field = Field::Handle(
       Field::New(field_name, false, false, false, true, one_field_class,
                  Object::dynamic_type(), TokenPosition::kMinSource));
   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());
@@ skipping 1520 matching lines @@
 
   const String& substr = String::Handle(String::SubString(str, 1, 1));
   EXPECT(!substr.IsExternalTwoByteString());
   EXPECT(substr.IsTwoByteString());
   EXPECT_EQ(1, substr.Length());
   EXPECT(substr.Equals("\xE1\xBA\x85"));
 }
 
 
 VM_TEST_CASE(Symbol) {
-  const String& one = String::Handle(Symbols::New("Eins"));
+  const String& one = String::Handle(Symbols::New(thread, "Eins"));
   EXPECT(one.IsSymbol());
-  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"));
+  const String& two = String::Handle(Symbols::New(thread, "Zwei"));
+  const String& three = String::Handle(Symbols::New(thread, "Drei"));
+  const String& four = String::Handle(Symbols::New(thread, "Vier"));
+  const String& five = String::Handle(Symbols::New(thread, "Fuenf"));
+  const String& six = String::Handle(Symbols::New(thread, "Sechs"));
+  const String& seven = String::Handle(Symbols::New(thread, "Sieben"));
+  const String& eight = String::Handle(Symbols::New(thread, "Acht"));
+  const String& nine = String::Handle(Symbols::New(thread, "Neun"));
+  const String& ten = String::Handle(Symbols::New(thread, "Zehn"));
+  String& eins = String::Handle(Symbols::New(thread, "Eins"));
   EXPECT_EQ(one.raw(), eins.raw());
   EXPECT(one.raw() != two.raw());
   EXPECT(two.Equals(String::Handle(String::New("Zwei"))));
-  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"));
+  EXPECT_EQ(two.raw(), Symbols::New(thread, "Zwei"));
+  EXPECT_EQ(three.raw(), Symbols::New(thread, "Drei"));
+  EXPECT_EQ(four.raw(), Symbols::New(thread, "Vier"));
+  EXPECT_EQ(five.raw(), Symbols::New(thread, "Fuenf"));
+  EXPECT_EQ(six.raw(), Symbols::New(thread, "Sechs"));
+  EXPECT_EQ(seven.raw(), Symbols::New(thread, "Sieben"));
+  EXPECT_EQ(eight.raw(), Symbols::New(thread, "Acht"));
+  EXPECT_EQ(nine.raw(), Symbols::New(thread, "Neun"));
+  EXPECT_EQ(ten.raw(), Symbols::New(thread, "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);
-    Symbols::New(buf);
+    Symbols::New(thread, buf);
   }
-  eins = Symbols::New("Eins");
+  eins = Symbols::New(thread, "Eins");
   EXPECT_EQ(one.raw(), eins.raw());
-  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"));
+  EXPECT_EQ(two.raw(), Symbols::New(thread, "Zwei"));
+  EXPECT_EQ(three.raw(), Symbols::New(thread, "Drei"));
+  EXPECT_EQ(four.raw(), Symbols::New(thread, "Vier"));
+  EXPECT_EQ(five.raw(), Symbols::New(thread, "Fuenf"));
+  EXPECT_EQ(six.raw(), Symbols::New(thread, "Sechs"));
+  EXPECT_EQ(seven.raw(), Symbols::New(thread, "Sieben"));
+  EXPECT_EQ(eight.raw(), Symbols::New(thread, "Acht"));
+  EXPECT_EQ(nine.raw(), Symbols::New(thread, "Neun"));
+  EXPECT_EQ(ten.raw(), Symbols::New(thread, "Zehn"));
 
   // Symbols from Strings.
   eins = String::New("Eins");
   EXPECT(!eins.IsSymbol());
-  String& ein_symbol = String::Handle(Symbols::New(eins));
+  String& ein_symbol = String::Handle(Symbols::New(thread, eins));
   EXPECT_EQ(one.raw(), ein_symbol.raw());
   EXPECT(one.raw() != eins.raw());
 
   uint16_t char16[] = { 'E', 'l', 'f' };
-  String& elf1 = String::Handle(Symbols::FromUTF16(char16, 3));
+  String& elf1 = String::Handle(Symbols::FromUTF16(thread, char16, 3));
   int32_t char32[] = { 'E', 'l', 'f' };
-  String& elf2 = String::Handle(Symbols::FromUTF32(char32, 3));
+  String& elf2 = String::Handle(Symbols::FromUTF32(thread, char32, 3));
   EXPECT(elf1.IsSymbol());
   EXPECT(elf2.IsSymbol());
-  EXPECT_EQ(elf1.raw(), Symbols::New("Elf"));
-  EXPECT_EQ(elf2.raw(), Symbols::New("Elf"));
+  EXPECT_EQ(elf1.raw(), Symbols::New(thread, "Elf"));
+  EXPECT_EQ(elf2.raw(), Symbols::New(thread, "Elf"));
 }
 
 
 VM_TEST_CASE(SymbolUnicode) {
   uint16_t monkey_utf16[] = { 0xd83d, 0xdc35 };  // Unicode Monkey Face.
-  String& monkey = String::Handle(Symbols::FromUTF16(monkey_utf16, 2));
+  String& monkey = String::Handle(Symbols::FromUTF16(thread, monkey_utf16, 2));
   EXPECT(monkey.IsSymbol());
   const char monkey_utf8[] = {'\xf0', '\x9f', '\x90', '\xb5', 0};
-  EXPECT_EQ(monkey.raw(), Symbols::New(monkey_utf8));
+  EXPECT_EQ(monkey.raw(), Symbols::New(thread, monkey_utf8));
 
   int32_t kMonkeyFace = 0x1f435;
-  String& monkey2 = String::Handle(Symbols::FromCharCode(kMonkeyFace));
+  String& monkey2 = String::Handle(Symbols::FromCharCode(thread, kMonkeyFace));
   EXPECT_EQ(monkey.raw(), monkey2.raw());
 
   // Unicode cat face with tears of joy.
   int32_t kCatFaceWithTearsOfJoy = 0x1f639;
-  String& cat = String::Handle(Symbols::FromCharCode(kCatFaceWithTearsOfJoy));
+  String& cat = String::Handle(Symbols::FromCharCode(thread,
+                                                     kCatFaceWithTearsOfJoy));
 
   uint16_t cat_utf16[] = { 0xd83d, 0xde39 };
-  String& cat2 = String::Handle(Symbols::FromUTF16(cat_utf16, 2));
+  String& cat2 = String::Handle(Symbols::FromUTF16(thread, cat_utf16, 2));
   EXPECT(cat2.IsSymbol());
   EXPECT_EQ(cat2.raw(), cat.raw());
 }
 
 
 VM_TEST_CASE(Bool) {
   EXPECT(Bool::True().value());
   EXPECT(!Bool::False().value());
 }
 
@@ skipping 617 matching lines @@
 VM_TEST_CASE(ContextScope) {
   const intptr_t parent_scope_function_level = 0;
   LocalScope* parent_scope =
       new LocalScope(NULL, parent_scope_function_level, 0);
 
   const intptr_t local_scope_function_level = 1;
   LocalScope* local_scope =
       new LocalScope(parent_scope, local_scope_function_level, 0);
 
   const Type& dynamic_type = Type::ZoneHandle(Type::DynamicType());
-  const String& a = String::ZoneHandle(Symbols::New("a"));
+  const String& a = String::ZoneHandle(Symbols::New(thread, "a"));
   LocalVariable* var_a =
       new LocalVariable(TokenPosition::kNoSource, a, dynamic_type);
   parent_scope->AddVariable(var_a);
 
-  const String& b = String::ZoneHandle(Symbols::New("b"));
+  const String& b = String::ZoneHandle(Symbols::New(thread, "b"));
   LocalVariable* var_b =
       new LocalVariable(TokenPosition::kNoSource, b, dynamic_type);
   local_scope->AddVariable(var_b);
 
-  const String& c = String::ZoneHandle(Symbols::New("c"));
+  const String& c = String::ZoneHandle(Symbols::New(thread, "c"));
   LocalVariable* var_c =
       new LocalVariable(TokenPosition::kNoSource, c, dynamic_type);
   parent_scope->AddVariable(var_c);
 
   bool test_only = false;  // Please, insert alias.
   var_a = local_scope->LookupVariable(a, test_only);
   EXPECT(var_a->is_captured());
   EXPECT_EQ(parent_scope_function_level, var_a->owner()->function_level());
   EXPECT(local_scope->LocalLookupVariable(a) == var_a);  // Alias.
 
@@ skipping 48 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.
 }
 
 
 VM_TEST_CASE(Closure) {
   // Allocate the class first.
-  const String& class_name = String::Handle(Symbols::New("MyClass"));
+  const String& class_name = String::Handle(Symbols::New(thread, "MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   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(Symbols::New("foo_papa"));
+  const String& parent_name = String::Handle(Symbols::New(thread, "foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
                          false, false, false, false, false, cls,
                          TokenPosition::kMinSource);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
   Function& function = Function::Handle();
-  const String& function_name = String::Handle(Symbols::New("foo"));
+  const String& function_name = String::Handle(Symbols::New(thread, "foo"));
   function = Function::NewClosureFunction(
       function_name, parent, TokenPosition::kMinSource);
   const Closure& closure = Closure::Handle(Closure::New(function, context));
   const Class& closure_class = Class::Handle(closure.clazz());
   EXPECT_EQ(closure_class.id(), kClosureCid);
   const Function& closure_function = Function::Handle(closure.function());
   EXPECT_EQ(closure_function.raw(), function.raw());
   const Context& closure_context = Context::Handle(closure.context());
   EXPECT_EQ(closure_context.raw(), context.raw());
 }
@@ skipping 34 matching lines @@
   str3 = String::New("Steep and Deep!");
   EXPECT(str3.IsString());
   EXPECT(str3.IsOneByteString());
   str3 = OneByteString::null();
   EXPECT(str3.IsString());
   EXPECT(!str3.IsOneByteString());
 }
 
 
 static RawFunction* CreateFunction(const char* name) {
-  const String& class_name = String::Handle(Symbols::New("ownerClass"));
-  const String& lib_name = String::Handle(Symbols::New("ownerLibrary"));
+  Thread* thread = Thread::Current();
+  const String& class_name = String::Handle(Symbols::New(thread, "ownerClass"));
+  const String& lib_name = String::Handle(Symbols::New(thread, "ownerLibrary"));
   const Script& script = Script::Handle();
   const Class& owner_class =
       Class::Handle(CreateDummyClass(class_name, script));
   const Library& owner_library =
       Library::Handle(CreateDummyLibrary(lib_name));
   owner_class.set_library(owner_library);
-  const String& function_name = String::ZoneHandle(Symbols::New(name));
+  const String& function_name = String::ZoneHandle(Symbols::New(thread, name));
   return Function::New(function_name, RawFunction::kRegularFunction,
                        true, false, false, false, false, owner_class,
                        TokenPosition::kMinSource);
 }
 
 
 // Test for Code and Instruction object creation.
 VM_TEST_CASE(Code) {
   extern void GenerateIncrement(Assembler* assembler);
   Assembler _assembler_;
@@ skipping 248 matching lines @@
   EXPECT_EQ(3, iter.TryIndex());
   EXPECT_EQ(static_cast<uword>(800), iter.PcOffset());
   EXPECT_EQ(150, iter.TokenPos().value());
   EXPECT_EQ(RawPcDescriptors::kOther, iter.Kind());
 
   EXPECT_EQ(false, iter.MoveNext());
 }
 
 
 static RawClass* CreateTestClass(const char* name) {
-  const String& class_name = String::Handle(Symbols::New(name));
+  const String& class_name = String::Handle(Symbols::New(Thread::Current(),
+                                                         name));
   const Class& cls = Class::Handle(
       CreateDummyClass(class_name, Script::Handle()));
   return cls.raw();
 }
 
 
 static RawField* CreateTestField(const char* name) {
   const Class& cls = Class::Handle(CreateTestClass("global:"));
-  const String& field_name = String::Handle(Symbols::New(name));
+  const String& field_name = String::Handle(Symbols::New(Thread::Current(),
+                                                         name));
   const Field& field =
       Field::Handle(Field::New(field_name, true, false, false, true, cls,
           Object::dynamic_type(), TokenPosition::kMinSource));
   return field.raw();
 }
 
 
 VM_TEST_CASE(ClassDictionaryIterator) {
   Class& ae66 = Class::ZoneHandle(CreateTestClass("Ae6/6"));
   Class& re44 = Class::ZoneHandle(CreateTestClass("Re4/4"));
@@ skipping 11 matching lines @@
   while (iterator.HasNext()) {
     cls = iterator.GetNextClass();
     EXPECT((cls.raw() == ae66.raw()) || (cls.raw() == re44.raw()));
     count++;
   }
   EXPECT(count == 2);
 }
 
 
 static RawFunction* GetDummyTarget(const char* name) {
-  const String& function_name = String::Handle(Symbols::New(name));
+  const String& function_name = String::Handle(Symbols::New(Thread::Current(),
+                                                            name));
   const Class& cls = Class::Handle(
        CreateDummyClass(function_name, Script::Handle()));
   const bool is_static = false;
   const bool is_const = false;
   const bool is_abstract = false;
   const bool is_external = false;
   const bool is_native = false;
   return Function::New(function_name,
                        RawFunction::kRegularFunction,
                        is_static,
                        is_const,
                        is_abstract,
                        is_external,
                        is_native,
                        cls,
                        TokenPosition::kMinSource);
 }
 
 
 VM_TEST_CASE(ICData) {
   Function& function = Function::Handle(GetDummyTarget("Bern"));
   const intptr_t id = 12;
   const intptr_t num_args_tested = 1;
-  const String& target_name = String::Handle(Symbols::New("Thun"));
+  const String& target_name = String::Handle(Symbols::New(thread, "Thun"));
   const Array& args_descriptor =
       Array::Handle(ArgumentsDescriptor::New(1, Object::null_array()));
   ICData& o1 = ICData::Handle();
   o1 = ICData::New(function, target_name, args_descriptor, id, num_args_tested);
   EXPECT_EQ(1, o1.NumArgsTested());
   EXPECT_EQ(id, o1.deopt_id());
   EXPECT_EQ(function.raw(), o1.Owner());
   EXPECT_EQ(0, o1.NumberOfChecks());
   EXPECT_EQ(target_name.raw(), o1.target_name());
   EXPECT_EQ(args_descriptor.raw(), o1.arguments_descriptor());
@@ skipping 48 matching lines @@
   // Check ICData for unoptimized static calls.
   const intptr_t kNumArgsChecked = 0;
   const ICData& scall_icdata = ICData::Handle(
       ICData::New(function, target_name, args_descriptor, 57, kNumArgsChecked));
   scall_icdata.AddTarget(target1);
   EXPECT_EQ(target1.raw(), scall_icdata.GetTargetAt(0));
 }
 
 
 VM_TEST_CASE(SubtypeTestCache) {
-  String& class_name = String::Handle(Symbols::New("EmptyClass"));
+  String& class_name = String::Handle(Symbols::New(thread, "EmptyClass"));
   Script& script = Script::Handle();
   const Class& empty_class =
       Class::Handle(CreateDummyClass(class_name, script));
   SubtypeTestCache& cache = SubtypeTestCache::Handle(SubtypeTestCache::New());
   EXPECT(!cache.IsNull());
   EXPECT_EQ(0, cache.NumberOfChecks());
   const Object& class_id_or_fun = Object::Handle(Smi::New(empty_class.id()));
   const TypeArguments& targ_0 = TypeArguments::Handle(TypeArguments::New(2));
   const TypeArguments& targ_1 = TypeArguments::Handle(TypeArguments::New(3));
   cache.AddCheck(class_id_or_fun, targ_0, targ_1, Bool::True());
@@ skipping 659 matching lines @@
 static RawField* GetField(const Class& cls, const char* name) {
   const Field& field =
       Field::Handle(cls.LookupField(String::Handle(String::New(name))));
   EXPECT(!field.IsNull());
   return field.raw();
 }
 
 
 static RawClass* GetClass(const Library& lib, const char* name) {
   const Class& cls = Class::Handle(
-      lib.LookupClass(String::Handle(Symbols::New(name))));
+      lib.LookupClass(String::Handle(Symbols::New(Thread::Current(), name))));
   EXPECT(!cls.IsNull());  // No ambiguity error expected.
   return cls.raw();
 }
 
 
 VM_TEST_CASE(FindClosureIndex) {
   // Allocate the class first.
-  const String& class_name = String::Handle(Symbols::New("MyClass"));
+  const String& class_name = String::Handle(Symbols::New(thread, "MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   const Array& functions = Array::Handle(Array::New(1));
   const Isolate* iso = Isolate::Current();
 
   Function& parent = Function::Handle();
-  const String& parent_name = String::Handle(Symbols::New("foo_papa"));
+  const String& parent_name = String::Handle(Symbols::New(thread, "foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
                          false, false, false, false, false, cls,
                          TokenPosition::kMinSource);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
 
   Function& function = Function::Handle();
-  const String& function_name = String::Handle(Symbols::New("foo"));
+  const String& function_name = String::Handle(Symbols::New(thread, "foo"));
   function = Function::NewClosureFunction(function_name, parent,
                                           TokenPosition::kMinSource);
   // Add closure function to class.
   iso->AddClosureFunction(function);
 
   // The closure should return a valid index.
   intptr_t good_closure_index = iso->FindClosureIndex(function);
   EXPECT_GE(good_closure_index, 0);
   // The parent function should return an invalid index.
   intptr_t bad_closure_index = iso->FindClosureIndex(parent);
   EXPECT_EQ(bad_closure_index, -1);
 
   // Retrieve closure function via index.
   Function& func_from_index = Function::Handle();
   func_from_index ^= iso->ClosureFunctionFromIndex(good_closure_index);
   // Same closure function.
   EXPECT_EQ(func_from_index.raw(), function.raw());
 }
 
 
 VM_TEST_CASE(FindInvocationDispatcherFunctionIndex) {
-  const String& class_name = String::Handle(Symbols::New("MyClass"));
+  const String& class_name = String::Handle(Symbols::New(thread, "MyClass"));
   const Script& script = Script::Handle();
   const Class& cls = Class::Handle(CreateDummyClass(class_name, script));
   ClassFinalizer::FinalizeTypesInClass(cls);
 
   const Array& functions = Array::Handle(Array::New(1));
   Function& parent = Function::Handle();
-  const String& parent_name = String::Handle(Symbols::New("foo_papa"));
+  const String& parent_name = String::Handle(Symbols::New(thread, "foo_papa"));
   parent = Function::New(parent_name, RawFunction::kRegularFunction,
                          false, false, false, false, false, cls,
                          TokenPosition::kMinSource);
   functions.SetAt(0, parent);
   cls.SetFunctions(functions);
   cls.Finalize();
 
   // Add invocation dispatcher.
   const String& invocation_dispatcher_name =
-      String::Handle(Symbols::New("myMethod"));
+      String::Handle(Symbols::New(thread, "myMethod"));
   const Array& args_desc = Array::Handle(ArgumentsDescriptor::New(1));
   Function& invocation_dispatcher = Function::Handle();
   invocation_dispatcher ^=
       cls.GetInvocationDispatcher(invocation_dispatcher_name, args_desc,
                                   RawFunction::kNoSuchMethodDispatcher,
                                   true /* create_if_absent */);
   EXPECT(!invocation_dispatcher.IsNull());
   // Get index to function.
   intptr_t invocation_dispatcher_index =
       cls.FindInvocationDispatcherFunctionIndex(invocation_dispatcher);
@@ skipping 80 matching lines @@
   PrintMetadata("Meta", res);
 
   Field& field = Field::Handle(GetField(class_a, "aField"));
   res = lib.GetMetadata(field);
   PrintMetadata("A.aField", res);
 
   Function& func = Function::Handle(GetFunction(class_a, "aFunc"));
   res = lib.GetMetadata(func);
   PrintMetadata("A.aFunc", res);
 
-  func = lib.LookupLocalFunction(String::Handle(Symbols::New("main")));
+  func = lib.LookupLocalFunction(String::Handle(Symbols::New(thread, "main")));
   EXPECT(!func.IsNull());
   res = lib.GetMetadata(func);
   PrintMetadata("main", res);
 
-  func = lib.LookupLocalFunction(String::Handle(Symbols::New("get:tlGetter")));
+  func = lib.LookupLocalFunction(String::Handle(Symbols::New(thread,
+                                                             "get:tlGetter")));
   EXPECT(!func.IsNull());
   res = lib.GetMetadata(func);
   PrintMetadata("tlGetter", res);
 
-  field = lib.LookupLocalField(String::Handle(Symbols::New("gVar")));
+  field = lib.LookupLocalField(String::Handle(Symbols::New(thread, "gVar")));
   EXPECT(!field.IsNull());
   res = lib.GetMetadata(field);
   PrintMetadata("gVar", res);
 }
 
 
 TEST_CASE(FunctionSourceFingerprint) {
   const char* kScriptChars =
       "class A {\n"
       "  static void test1(int a) {\n"
@@ skipping 31 matching lines @@
       "    return a > 1 ? a + 1 : a;\n"
       "  }\n"
       "}";
   TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT(ClassFinalizer::ProcessPendingClasses());
   const String& name = String::Handle(String::New(TestCase::url()));
   const Library& lib = Library::Handle(Library::LookupLibrary(name));
   EXPECT(!lib.IsNull());
 
   const Class& class_a = Class::Handle(
-      lib.LookupClass(String::Handle(Symbols::New("A"))));
+      lib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
   const Class& class_b = Class::Handle(
-      lib.LookupClass(String::Handle(Symbols::New("B"))));
+      lib.LookupClass(String::Handle(Symbols::New(thread, "B"))));
   const Function& a_test1 =
       Function::Handle(GetStaticFunction(class_a, "test1"));
   const Function& b_test1 =
       Function::Handle(GetStaticFunction(class_b, "test1"));
   const Function& a_test2 =
       Function::Handle(GetStaticFunction(class_a, "test2"));
   const Function& a_test3 =
       Function::Handle(GetStaticFunction(class_a, "test3"));
   const Function& a_test4 =
       Function::Handle(GetStaticFunction(class_a, "test4"));
@@ skipping 41 matching lines @@
 
   // Run function A.b one time.
   Dart_Handle result = Dart_Invoke(lib, NewString("test"), 0, NULL);
   EXPECT_VALID(result);
 
   // With no breakpoint, function A.b is inlineable.
   const String& name = String::Handle(String::New(TestCase::url()));
   const Library& vmlib = Library::Handle(Library::LookupLibrary(name));
   EXPECT(!vmlib.IsNull());
   const Class& class_a = Class::Handle(
-      vmlib.LookupClass(String::Handle(Symbols::New("A"))));
+      vmlib.LookupClass(String::Handle(Symbols::New(thread, "A"))));
   const Function& func_b =
       Function::Handle(GetFunction(class_a, "b"));
   EXPECT(func_b.CanBeInlined());
 
   // After setting a breakpoint in a function A.b, it is no longer inlineable.
   Breakpoint* bpt =
       Isolate::Current()->debugger()->SetBreakpointAtLine(name,
                                                           kBreakpointLine);
   ASSERT(bpt != NULL);
   EXPECT(!func_b.CanBeInlined());
@@ skipping 520 matching lines @@
   object = iterator.CurrentKey();
   EXPECT_STREQ("z", object.ToCString());
   object = iterator.CurrentValue();
   EXPECT_STREQ("5", object.ToCString());
 
   EXPECT(!iterator.MoveNext());
 }
 
 
 static void CheckConcatAll(const String* data[], intptr_t n) {
-  Zone* zone = Thread::Current()->zone();
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
   GrowableHandlePtrArray<const String> pieces(zone, n);
   const Array& array = Array::Handle(zone, Array::New(n));
   for (int i = 0; i < n; i++) {
     pieces.Add(*data[i]);
     array.SetAt(i, *data[i]);
   }
-  const String& res1 = String::Handle(zone, Symbols::FromConcatAll(pieces));
+  const String& res1 = String::Handle(zone, Symbols::FromConcatAll(thread,
+                                                                   pieces));
   const String& res2 = String::Handle(zone, String::ConcatAll(array));
   EXPECT(res1.Equals(res2));
 }
 
 
 VM_TEST_CASE(Symbols_FromConcatAll) {
   {
     const String* data[3] = { &Symbols::FallThroughError(),
                               &Symbols::Dot(),
                               &Symbols::isPaused() };
@@ skipping 83 matching lines @@
   String& test = String::Handle();
   String& result = String::Handle();
   for (size_t i = 0; i < ARRAY_SIZE(tests); i++) {
     test = String::New(tests[i].in);
     result = String::ScrubName(test);
     EXPECT_STREQ(tests[i].out, result.ToCString());
   }
 }
 
 }  // namespace dart