Cleanup the exceptions create code to use Arrays instead GrowableArrays so

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/code_generator.h"
 #include "vm/compiler.h"
 #include "vm/object_store.h"
 #include "vm/resolver.h"
@@ skipping 82 matching lines @@
   ASSERT(instance.raw() == 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();
   Context& context = Context::Handle();
   if (!instance.IsCallable(&function, &context)) {
     // Set up arguments to include the receiver as the first argument.
     const String& call_symbol = String::Handle(Symbols::Call());
     const Object& null_object = Object::Handle();
-    GrowableArray<const Object*> dart_arguments(5);
-    dart_arguments.Add(&instance);
-    dart_arguments.Add(&call_symbol);
-    dart_arguments.Add(&arguments);  // Includes instance.
-    dart_arguments.Add(&null_object);  // TODO(regis): Provide names.
+    const Array& dart_arguments = Array::Handle(Array::New(4));
+    dart_arguments.SetAt(0, instance);
+    dart_arguments.SetAt(1, call_symbol);
+    dart_arguments.SetAt(2, arguments);  // Includes instance.
+    dart_arguments.SetAt(3, null_object);  // TODO(regis): Provide names.
     // If a function "call" with different arguments exists, it will have been
     // invoked above, so no need to handle this case here.
     Exceptions::ThrowByType(Exceptions::kNoSuchMethod, dart_arguments);
     UNREACHABLE();
     return Object::null();
   }
   ASSERT(!function.IsNull());
   if (!function.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     if (!error.IsNull()) {
@@ skipping 118 matching lines @@
   // Set terminating null.
   descriptor.SetAt((descriptor_len - 1), Object::Handle());
 
   // Share the immutable descriptor when possible by canonicalizing it.
   descriptor.MakeImmutable();
   descriptor ^= descriptor.Canonicalize();
   return descriptor.raw();
 }
 
 
-RawObject* DartLibraryCalls::ExceptionCreate(
-    const Library& lib,
-    const String& class_name,
-    const GrowableArray<const Object*>& arguments) {
+RawObject* DartLibraryCalls::ExceptionCreate(const Library& lib,
+                                             const String& class_name,
+                                             const Array& arguments) {
   const Class& cls = Class::Handle(lib.LookupClassAllowPrivate(class_name));
   ASSERT(!cls.IsNull());
   // For now, we only support a non-parameterized or raw type.
   const int kNumExtraArgs = 2;  // implicit rcvr and construction phase args.
   const Instance& exception_object = Instance::Handle(Instance::New(cls));
   const Array& constructor_arguments =
-    Array::Handle(Array::New(arguments.length() + kNumExtraArgs));
+    Array::Handle(Array::New(arguments.Length() + kNumExtraArgs));
   constructor_arguments.SetAt(0, exception_object);
   constructor_arguments.SetAt(
       1, Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
-  for (intptr_t i = 0; i < arguments.length(); i++) {
-    constructor_arguments.SetAt((i + kNumExtraArgs), *(arguments[i]));
+  Object& obj = Object::Handle();
+  for (intptr_t i = 0; i < arguments.Length(); i++) {
+    obj = arguments.At(i);
+    constructor_arguments.SetAt((i + kNumExtraArgs), obj);
   }
 
   String& constructor_name = String::Handle(
       String::Concat(class_name, Symbols::DotHandle()));
   Function& constructor =
       Function::Handle(cls.LookupConstructor(constructor_name));
   ASSERT(!constructor.IsNull());
   const Object& retval =
     Object::Handle(DartEntry::InvokeStatic(constructor, constructor_arguments));
   ASSERT(retval.IsNull() || retval.IsError());
@@ skipping 123 matching lines @@
   const String& func_name = String::Handle(Field::GetterName(field_name));
   const Function& func = Function::Handle(cls.LookupDynamicFunction(func_name));
   ASSERT(!func.IsNull());
   const Array& args = Array::Handle(Array::New(1));
   args.SetAt(0, port);
   return DartEntry::InvokeDynamic(func, args);
 }
 
 
 }  // namespace dart