- Refactor Symbol allocation to expect a thread parameter.

runtime/vm/dart_entry.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/dart_entry.h"
 
 #include "vm/class_finalizer.h"
 #include "vm/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/debugger.h"
@@ skipping 118 matching lines @@
 
 RawObject* DartEntry::InvokeClosure(const Array& arguments) {
   const Array& arguments_descriptor =
       Array::Handle(ArgumentsDescriptor::New(arguments.Length()));
   return InvokeClosure(arguments, arguments_descriptor);
 }
 
 
 RawObject* DartEntry::InvokeClosure(const Array& arguments,
                                     const Array& arguments_descriptor) {
-  Instance& instance = Instance::Handle();
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Instance& instance = Instance::Handle(zone);
   instance ^= arguments.At(0);
   // Get the entrypoint corresponding to the closure function or to the call
   // method of the instance. This will result in a compilation of the function
   // if it is not already compiled.
-  Function& function = Function::Handle();
+  Function& function = Function::Handle(zone);
   if (instance.IsCallable(&function)) {
     // Only invoke the function if its arguments are compatible.
     const ArgumentsDescriptor args_desc(arguments_descriptor);
     if (function.AreValidArgumentCounts(args_desc.Count(),
                                         args_desc.NamedCount(),
                                         NULL)) {
       // The closure or non-closure object (receiver) is passed as implicit
       // first argument. It is already included in the arguments array.
       return InvokeFunction(function, arguments, arguments_descriptor);
     }
   }
 
   // There is no compatible 'call' method, see if there's a getter.
   if (instance.IsClosure()) {
     // Special case: closures are implemented with a call getter instead of a
     // call method. If the arguments didn't match, go to noSuchMethod instead
     // of infinitely recursing on the getter.
   } else {
-    const String& getter_name = String::Handle(Symbols::New("get:call"));
-    Class& cls = Class::Handle(instance.clazz());
+    const String& getter_name = Symbols::GetCall();
+    Class& cls = Class::Handle(zone, instance.clazz());
     while (!cls.IsNull()) {
       function ^= cls.LookupDynamicFunction(getter_name);
       if (!function.IsNull()) {
-        Thread* thread = Thread::Current();
         Isolate* isolate = thread->isolate();
         volatile uword c_stack_pos = Thread::GetCurrentStackPointer();
         volatile uword c_stack_limit = OSThread::Current()->stack_base() -
                                        OSThread::GetSpecifiedStackSize();
 #if !defined(USING_SIMULATOR)
         ASSERT(c_stack_limit == thread->saved_stack_limit());
 #endif
 
         if (c_stack_pos < c_stack_limit) {
           const Instance& exception =
-            Instance::Handle(isolate->object_store()->stack_overflow());
-          return UnhandledException::New(exception, Stacktrace::Handle());
+            Instance::Handle(zone, isolate->object_store()->stack_overflow());
+          return UnhandledException::New(exception, Stacktrace::Handle(zone));
         }
 
-        const Array& getter_arguments = Array::Handle(Array::New(1));
+        const Array& getter_arguments = Array::Handle(zone, Array::New(1));
         getter_arguments.SetAt(0, instance);
         const Object& getter_result =
-              Object::Handle(DartEntry::InvokeFunction(function,
+              Object::Handle(zone, DartEntry::InvokeFunction(function,
                                                        getter_arguments));
         if (getter_result.IsError()) {
           return getter_result.raw();
         }
         ASSERT(getter_result.IsNull() || getter_result.IsInstance());
 
         arguments.SetAt(0, getter_result);
         // This otherwise unnecessary handle is used to prevent clang from
         // doing tail call elimination, which would make the stack overflow
         // check above ineffective.
-        Object& result = Object::Handle(InvokeClosure(arguments,
-                                                      arguments_descriptor));
+        Object& result = Object::Handle(zone,
+            InvokeClosure(arguments, arguments_descriptor));
         return result.raw();
       }
       cls = cls.SuperClass();
     }
   }
 
   // No compatible method or getter so invoke noSuchMethod.
   return InvokeNoSuchMethod(instance,
                             Symbols::Call(),
                             arguments,
@@ skipping 385 matching lines @@
   const Array& args = Array::Handle(Array::New(kNumArguments));
   args.SetAt(0, map);
   args.SetAt(1, key);
   args.SetAt(2, value);
   const Object& result = Object::Handle(DartEntry::InvokeFunction(function,
                                                                   args));
   return result.raw();
 }
 
 }  // namespace dart