Add a first class GrowableObjectArray type in the VM and use it internally in the VM at all spots w…

vm/parser.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 "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 59 matching lines @@
 int TraceParser::indent_ = 0;
 
 #define TRACE_PARSER(s) \
   TraceParser __p__(this->token_index_, this->script_, s)
 
 #else  // not DEBUG
 #define TRACE_PARSER(s)
 #endif  // DEBUG
 
 
-template<typename T>
-static RawArray* NewArray(const GrowableArray<T*>& objs) {
-  Array& a = Array::Handle(Array::New(objs.length(), Heap::kOld));
-  for (int i = 0; i < objs.length(); i++) {
-    a.SetAt(i, *objs[i]);
-  }
-  return a.raw();
-}
-
-
-static RawTypeArguments* NewTypeArguments(
-    const GrowableArray<AbstractType*>& objs) {
+static RawTypeArguments* NewTypeArguments(const GrowableObjectArray& objs) {
   const TypeArguments& a =
-      TypeArguments::Handle(TypeArguments::New(objs.length()));
-  for (int i = 0; i < objs.length(); i++) {
-    a.SetTypeAt(i, *objs[i]);
+      TypeArguments::Handle(TypeArguments::New(objs.Length()));
+  AbstractType& type = AbstractType::Handle();
+  for (int i = 0; i < objs.Length(); i++) {
+    type ^= objs.At(i);
+    a.SetTypeAt(i, type);
   }
   // Cannot canonicalize TypeArgument yet as its types may not have been
   // finalized yet.
   return a.raw();
 }
 
 
 static ThrowNode* CreateEvalConstConstructorThrow(intptr_t token_pos,
                                                   const Object& obj) {
   UnhandledException& excp = UnhandledException::Handle();
@@ skipping 307 matching lines @@
 class ClassDesc : public ValueObject {
  public:
   ClassDesc(const Class& cls,
             const String& cls_name,
             bool is_interface,
             intptr_t token_pos)
       : clazz_(cls),
         class_name_(cls_name),
         is_interface_(is_interface),
         token_pos_(token_pos),
-        functions_(4),
-        fields_(4) {
+        functions_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
+        fields_(GrowableObjectArray::Handle(GrowableObjectArray::New())) {
   }
 
   bool FunctionNameExists(const String& name, RawFunction::Kind kind) const {
     // First check if a function or field of same name exists.
     if (NameExists<Function>(functions_, name) ||
         NameExists<Field>(fields_, name)) {
       return true;
     }
     String& accessor_name = String::Handle();
     if (kind != RawFunction::kSetterFunction) {
@@ skipping 22 matching lines @@
     // Now check if a getter/setter function of same name exists.
     String& getter_name = String::Handle(Field::GetterName(name));
     String& setter_name = String::Handle(Field::SetterName(name));
     if (NameExists<Function>(functions_, getter_name) ||
         NameExists<Function>(functions_, setter_name)) {
       return true;
     }
     return false;
   }
 
-  void AddFunction(Function* function) {
-    ASSERT(!NameExists<Function>(functions_, String::Handle(function->name())));
+  void AddFunction(const Function& function) {
+    ASSERT(!NameExists<Function>(functions_, String::Handle(function.name())));
     functions_.Add(function);
   }
 
-  const GrowableArray<Function*>& functions() const {
+  const GrowableObjectArray& functions() const {
     return functions_;
   }
 
-  void AddField(Field* field) {
-    ASSERT(!NameExists<Field>(fields_, String::Handle(field->name())));
+  void AddField(const Field& field) {
+    ASSERT(!NameExists<Field>(fields_, String::Handle(field.name())));
     fields_.Add(field);
   }
 
-  const GrowableArray<Field*>& fields() const {
+  const GrowableObjectArray& fields() const {
     return fields_;
   }
 
   RawClass* clazz() const {
     return clazz_.raw();
   }
 
   const String& class_name() const {
     return class_name_;
   }
 
   bool is_interface() const {
     return is_interface_;
   }
 
   bool has_constructor() const {
-    for (int i = 0; i < functions_.length(); i++) {
-      if (functions_[i]->kind() == RawFunction::kConstructor) {
+    Function& func = Function::Handle();
+    for (int i = 0; i < functions_.Length(); i++) {
+      func ^= functions_.At(i);
+      if (func.kind() == RawFunction::kConstructor) {
         return true;
       }
     }
     return false;
   }
 
   intptr_t token_pos() const {
     return token_pos_;
   }
 
   void AddMember(const MemberDesc& member) {
     members_.Add(member);
   }
 
   const GrowableArray<MemberDesc>& members() const {
     return members_;
   }
 
   MemberDesc* LookupMember(const String& name) const {
     for (int i = 0; i < members_.length(); i++) {
       if (name.Equals(*members_[i].name)) {
         return &members_[i];
       }
     }
     return NULL;
   }
 
  private:
   template<typename T>
-  bool NameExists(const GrowableArray<T*>& list, const String& name) const {
+  bool NameExists(const GrowableObjectArray& list, const String& name) const {
     String& test_name = String::Handle();
-    for (int i = 0; i < list.length(); i++) {
-      test_name = list[i]->name();
+    T& obj = T::Handle();
+    for (int i = 0; i < list.Length(); i++) {
+      obj ^= list.At(i);
+      test_name = obj.name();
       if (name.Equals(test_name)) {
         return true;
       }
     }
     return false;
   }
 
   const Class& clazz_;
   const String& class_name_;
   const bool is_interface_;
   intptr_t token_pos_;   // Token index of "class" keyword.
-  GrowableArray<Function*> functions_;
-  GrowableArray<Field*> fields_;
+  GrowableObjectArray& functions_;
+  GrowableObjectArray& fields_;
   GrowableArray<MemberDesc> members_;
 };
 
 
 struct TopLevel {
-  TopLevel() : fields(4), functions(4) { }
+  TopLevel() :
+      fields(GrowableObjectArray::Handle(GrowableObjectArray::New())),
+      functions(GrowableObjectArray::Handle(GrowableObjectArray::New())) { }
 
-  GrowableArray<Field*> fields;
-  GrowableArray<Function*> functions;
+  GrowableObjectArray& fields;
+  GrowableObjectArray& functions;
 };
 
 
 static bool HasReturnNode(SequenceNode* seq) {
   if (seq->length() == 0) {
     return false;
   } else if ((seq->length()) == 1 &&
              (seq->NodeAt(seq->length() - 1)->IsSequenceNode())) {
     return HasReturnNode(seq->NodeAt(seq->length() - 1)->AsSequenceNode());
   } else {
@@ skipping 1582 matching lines @@
     function_kind = RawFunction::kConstructor;
   } else if (method->has_abstract) {
     function_kind = RawFunction::kAbstract;
   } else if (method->IsGetter()) {
     function_kind = RawFunction::kGetterFunction;
   } else if (method->IsSetter()) {
     function_kind = RawFunction::kSetterFunction;
   } else {
     function_kind = RawFunction::kFunction;
   }
-  Function& func = Function::ZoneHandle(
+  Function& func = Function::Handle(
       Function::New(*method->name,
                     function_kind,
                     method->has_static,
                     method->has_const,
                     method_pos));
   func.set_result_type(*method->type);
   func.set_end_token_index(method_end_pos);
 
   // No need to resolve parameter types yet, or add parameters to local scope.
   ASSERT(is_top_level_);
   AddFormalParamsToFunction(&method->params, func);
-  members->AddFunction(&func);
+  members->AddFunction(func);
 }
 
 
 void Parser::ParseFieldDefinition(ClassDesc* members, MemberDesc* field) {
   TRACE_PARSER("ParseFieldDefinition");
   // The parser has read the first field name and is now at the token
   // after the field name.
   ASSERT(CurrentToken() == Token::kSEMICOLON ||
          CurrentToken() == Token::kCOMMA ||
          CurrentToken() == Token::kASSIGN);
   ASSERT(field->type != NULL);
   ASSERT(field->name_pos > 0);
   ASSERT(current_member_ == field);
 
   if (field->has_const) {
     ErrorMsg("keyword 'const' not allowed in field declaration");
   }
   if (field->has_abstract) {
     ErrorMsg("keyword 'abstract' not allowed in field declaration");
   }
   if (field->has_factory) {
     ErrorMsg("keyword 'factory' not allowed in field declaration");
   }
   if (members->FieldNameExists(*field->name)) {
     ErrorMsg(field->name_pos,
              "'%s' field/method already defined\n", field->name->ToCString());
   }
+  Function& getter = Function::Handle();
+  Function& setter = Function::Handle();
+  Field& class_field = Field::Handle();
   while (true) {
     bool has_initializer = CurrentToken() == Token::kASSIGN;
     if (has_initializer) {
       ConsumeToken();
       // For static final fields, the initialization expression
       // will be parsed through the kConstImplicitGetter method
       // invocation/compilation.
       // For instance fields, the expression is parsed when a constructor
       // is compiled.
       SkipExpr();
     } else {
       if (field->has_static && field->has_final) {
         ErrorMsg(field->name_pos,
                  "static final field '%s' must have an initializer expression",
                  field->name->ToCString());
       }
     }
 
     // Create the field object.
-    Field& class_field = Field::ZoneHandle(
-         Field::New(*field->name,
-                    field->has_static,
-                    field->has_final,
-                    field->name_pos));
+    class_field = Field::New(*field->name,
+                             field->has_static,
+                             field->has_final,
+                             field->name_pos);
     class_field.set_type(*field->type);
     class_field.set_has_initializer(has_initializer);
-    members->AddField(&class_field);
+    members->AddField(class_field);
 
     // For static final fields, set value to "uninitialized" and
     // create a kConstImplicitGetter getter method.
     if (field->has_static && has_initializer) {
       class_field.set_value(Instance::Handle(Object::sentinel()));
-      String& getter_name =
-          String::ZoneHandle(Field::GetterSymbol(*field->name));
-      Function& getter = Function::ZoneHandle(
-          Function::New(getter_name, RawFunction::kConstImplicitGetter,
-                        field->has_static, field->has_final,
-                        field->name_pos));
+      String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
+      getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
+                             field->has_static, field->has_final,
+                             field->name_pos);
       getter.set_result_type(*field->type);
-      members->AddFunction(&getter);
+      members->AddFunction(getter);
     }
 
     // For instance fields, we create implicit getter and setter methods.
     if (!field->has_static) {
-      String& getter_name =
-          String::ZoneHandle(Field::GetterSymbol(*field->name));
-      Function& getter = Function::ZoneHandle(
-          Function::New(getter_name, RawFunction::kImplicitGetter,
-                        field->has_static, field->has_final,
-                        field->name_pos));
+      String& getter_name = String::Handle(Field::GetterSymbol(*field->name));
+      getter = Function::New(getter_name, RawFunction::kImplicitGetter,
+                             field->has_static, field->has_final,
+                             field->name_pos);
       ParamList params;
       params.AddReceiver(token_index_);
       getter.set_result_type(*field->type);
       AddFormalParamsToFunction(&params, getter);
-      members->AddFunction(&getter);
+      members->AddFunction(getter);
       if (!field->has_final) {
         // Build a setter accessor for non-const fields.
-        String& setter_name = String::ZoneHandle(
-            Field::SetterSymbol(*field->name));
-        Function& setter = Function::ZoneHandle(
-            Function::New(setter_name, RawFunction::kImplicitSetter,
-                         field->has_static, field->has_final,
-                         field->name_pos));
+        String& setter_name = String::Handle(Field::SetterSymbol(*field->name));
+        setter = Function::New(setter_name, RawFunction::kImplicitSetter,
+                               field->has_static, field->has_final,
+                               field->name_pos);
         ParamList params;
         params.AddReceiver(token_index_);
         params.AddFinalParameter(token_index_, "value", field->type);
         setter.set_result_type(Type::Handle(Type::VoidType()));
         AddFormalParamsToFunction(&params, setter);
-        members->AddFunction(&setter);
+        members->AddFunction(setter);
       }
     }
 
     if (CurrentToken() != Token::kCOMMA) {
       break;
     }
     ConsumeToken();
     field->name_pos = this->token_index_;
     field->name = ExpectIdentifier("field name expected");
   }
@@ skipping 230 matching lines @@
     }
     ParseFieldDefinition(members, &member);
   } else {
     UnexpectedToken();
   }
   current_member_ = NULL;
   members->AddMember(member);
 }
 
 
-void Parser::ParseClassDefinition(GrowableArray<const Class*>* classes) {
+void Parser::ParseClassDefinition(const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseClassDefinition");
   const intptr_t class_pos = token_index_;
   ExpectToken(Token::kCLASS);
   const intptr_t classname_pos = token_index_;
   String& class_name = *ExpectTypeIdentifier("class name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing class '%s'\n", class_name.ToCString());
   }
-  Class& cls = Class::ZoneHandle();
+  Class& cls = Class::Handle();
   Object& obj = Object::Handle(library_.LookupObject(class_name));
   if (obj.IsNull()) {
     cls = Class::New(class_name, script_, classname_pos);
     library_.AddClass(cls);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(classname_pos, "'%s' is already defined",
                class_name.ToCString());
     }
     cls ^= obj.raw();
@@ skipping 43 matching lines @@
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kRBRACE) {
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
   CheckConstructors(&members);
-  cls.SetFields(Array::Handle(NewArray<Field>(members.fields())));
+
+  Array& array = Array::Handle();
+  array = Array::MakeArray(members.fields());
+  cls.SetFields(array);
+
   // Creating a new array for functions marks the class as parsed.
-  cls.SetFunctions(Array::Handle(NewArray<Function>(members.functions())));
-  classes->Add(&cls);
+  array = Array::MakeArray(members.functions());
+  cls.SetFunctions(array);
+
+  pending_classes.Add(cls, Heap::kOld);
 }
 
 
 // 1. Add an implicit constructor if no explicit constructor is present.
 // 2. Check for cycles in constructor redirection.
 void Parser::CheckConstructors(ClassDesc* class_desc) {
   // Add an implicit constructor if no explicit constructor is present.
   if (!class_desc->has_constructor()) {
     // The implicit constructor is unnamed, has no explicit parameter,
     // and contains a supercall in the initializer list.
     String& ctor_name = String::ZoneHandle(
         String::Concat(class_desc->class_name(),
                        String::Handle(String::NewSymbol("."))));
     ctor_name = String::NewSymbol(ctor_name);
     // The token position for the implicit constructor is the 'class'
     // keyword of the constructor's class.
-    Function& ctor = Function::ZoneHandle(
+    Function& ctor = Function::Handle(
         Function::New(ctor_name,
                       RawFunction::kConstructor,
                       /* is_static = */ false,
                       /* is_const = */ false,
                       class_desc->token_pos()));
     ParamList params;
     // Add implicit 'this' parameter.
     params.AddReceiver(token_index_);
     // Add implicit parameter for construction phase.
     params.AddFinalParameter(
         token_index_,
         kPhaseParameterName,
         &Type::ZoneHandle(Type::DynamicType()));
 
     AddFormalParamsToFunction(&params, ctor);
     // The body of the constructor cannot modify the type arguments of the
     // constructed instance, which is passed in as a hidden parameter.
     // Therefore, there is no need to set the result type to be checked.
     const AbstractType& result_type = Type::ZoneHandle(Type::DynamicType());
     ctor.set_result_type(result_type);
-    class_desc->AddFunction(&ctor);
+    class_desc->AddFunction(ctor);
   }
 
   // Check for cycles in constructor redirection.
   const GrowableArray<MemberDesc>& members = class_desc->members();
   for (int i = 0; i < members.length(); i++) {
     MemberDesc* member = &members[i];
     GrowableArray<MemberDesc*> ctors;
     while ((member != NULL) && (member->redirect_name != NULL)) {
       ASSERT(member->IsConstructor());
       // Check whether we have already seen this member.
@@ skipping 29 matching lines @@
     ConsumeToken();
     if (TryParseTypeParameter() && (CurrentToken() == Token::kLPAREN)) {
       is_alias_name = true;
     }
   }
   SetPosition(saved_pos);
   return is_alias_name;
 }
 
 
-void Parser::ParseFunctionTypeAlias(GrowableArray<const Class*>* classes) {
+void Parser::ParseFunctionTypeAlias(
+    const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseFunctionTypeAlias");
   ExpectToken(Token::kTYPEDEF);
 
   // Allocate an interface to hold the type parameters and their bounds.
   // Make it the owner of the function type descriptor.
   const Class& alias_owner = Class::Handle(
       Class::New(String::Handle(String::NewSymbol(":alias_owner")),
                  Script::Handle(),
                  token_index_));
   alias_owner.set_is_interface();
@@ skipping 66 matching lines @@
   // Lookup alias name and report an error if it is already defined in
   // the library scope.
   const Object& obj = Object::Handle(library_.LookupObject(*alias_name));
   if (!obj.IsNull()) {
     ErrorMsg(alias_name_pos,
              "'%s' is already defined", alias_name->ToCString());
   }
 
   // Create the function type alias, but share the signature function of the
   // canonical signature class.
-  Class& function_type_alias = Class::ZoneHandle(
+  Class& function_type_alias = Class::Handle(
       Class::NewSignatureClass(*alias_name,
                                signature_function,
                                script_));
   library_.AddClass(function_type_alias);
   ExpectSemicolon();
-  classes->Add(&function_type_alias);
+  pending_classes.Add(function_type_alias, Heap::kOld);
 }
 
 
-void Parser::ParseInterfaceDefinition(GrowableArray<const Class*>* classes) {
+void Parser::ParseInterfaceDefinition(
+    const GrowableObjectArray& pending_classes) {
   TRACE_PARSER("ParseInterfaceDefinition");
   const intptr_t interface_pos = token_index_;
   ExpectToken(Token::kINTERFACE);
   const intptr_t interfacename_pos = token_index_;
   String& interface_name = *ExpectTypeIdentifier("interface name expected");
   if (FLAG_trace_parser) {
     OS::Print("TopLevel parsing interface '%s'\n", interface_name.ToCString());
   }
-  Class& interface = Class::ZoneHandle();
+  Class& interface = Class::Handle();
   Object& obj = Object::Handle(library_.LookupObject(interface_name));
   if (obj.IsNull()) {
     interface = Class::NewInterface(interface_name, script_, interfacename_pos);
     library_.AddClass(interface);
   } else {
     if (!obj.IsClass()) {
       ErrorMsg(interfacename_pos, "'%s' is already defined",
                interface_name.ToCString());
     }
     interface ^= obj.raw();
@@ skipping 63 matching lines @@
     }
   }
 
   ExpectToken(Token::kLBRACE);
   ClassDesc members(interface, interface_name, true, interface_pos);
   while (CurrentToken() != Token::kRBRACE) {
     ParseClassMemberDefinition(&members);
   }
   ExpectToken(Token::kRBRACE);
 
-  interface.SetFields(Array::Handle(NewArray<Field>(members.fields())));
+  Array& array = Array::Handle();
+  array = Array::MakeArray(members.fields());
+  interface.SetFields(array);
+
   // Creating a new array for functions marks the interface as parsed.
-  interface.SetFunctions(
-      Array::Handle(NewArray<Function>(members.functions())));
+  array = Array::MakeArray(members.functions());
+  interface.SetFunctions(array);
   ASSERT(interface.is_interface());
-  classes->Add(&interface);
+
+  pending_classes.Add(interface, Heap::kOld);
 }
 
 
 // Consumes exactly one right angle bracket. If the current token is a single
 // bracket token, it is consumed normally. However, if it is a double or triple
 // bracket, it is replaced by a single or double bracket token without
 // incrementing the token index.
 void Parser::ConsumeRightAngleBracket() {
   if (token_kind_ == Token::kGT) {
     ConsumeToken();
@@ skipping 34 matching lines @@
       ExpectIdentifier("name expected");
     }
     SkipTypeArguments();
   }
 }
 
 
 void Parser::ParseTypeParameters(const Class& cls) {
   TRACE_PARSER("ParseTypeParameters");
   if (CurrentToken() == Token::kLT) {
-    GrowableArray<AbstractType*> type_parameters_array;
-    GrowableArray<AbstractType*> bounds_array;
+    const GrowableObjectArray& type_parameters_array =
+        GrowableObjectArray::Handle(GrowableObjectArray::New());
+    const GrowableObjectArray& bounds_array =
+        GrowableObjectArray::Handle(GrowableObjectArray::New());
     intptr_t index = 0;
+    AbstractType& type_parameter = TypeParameter::Handle();
+    AbstractType& bound = Type::Handle();
     do {
       ConsumeToken();
       if (CurrentToken() != Token::kIDENT) {
         ErrorMsg("type parameter name expected");
       }
       String& type_parameter_name = *CurrentLiteral();
-      AbstractType& type_parameter = TypeParameter::ZoneHandle(
-          TypeParameter::New(index, type_parameter_name, token_index_));
+      type_parameter = TypeParameter::New(index,
+                                          type_parameter_name,
+                                          token_index_);
       ConsumeToken();
-      AbstractType& bound = Type::ZoneHandle(Type::DynamicType());
+      bound = Type::DynamicType();
       if (CurrentToken() == Token::kEXTENDS) {
         ConsumeToken();
         bound = ParseType(ClassFinalizer::kTryResolve);
       }
-      type_parameters_array.Add(&type_parameter);
-      bounds_array.Add(&bound);
+      type_parameters_array.Add(type_parameter);
+      bounds_array.Add(bound);
       index++;
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     const TypeArguments& type_parameters =
         TypeArguments::Handle(NewTypeArguments(type_parameters_array));
     const TypeArguments& bounds =
         TypeArguments::Handle(NewTypeArguments(bounds_array));
     cls.set_type_parameters(type_parameters);
     cls.set_type_parameter_bounds(bounds);
     // Try to resolve the upper bounds, which will at least resolve the
     // referenced type parameters.
-    AbstractType& bound = AbstractType::Handle();
     const intptr_t num_types = bounds.Length();
     for (intptr_t i = 0; i < num_types; i++) {
       bound = bounds.TypeAt(i);
       ResolveTypeFromClass(cls, ClassFinalizer::kTryResolve, &bound);
       bounds.SetTypeAt(i, bound);
     }
   }
 }
 
 
 RawAbstractTypeArguments* Parser::ParseTypeArguments(
     Error* malformed_error,
     ClassFinalizer::FinalizationKind finalization) {
   TRACE_PARSER("ParseTypeArguments");
   if (CurrentToken() == Token::kLT) {
-    GrowableArray<AbstractType*> types;
+    const GrowableObjectArray& types =
+        GrowableObjectArray::Handle(GrowableObjectArray::New());
+    AbstractType& type = AbstractType::Handle();
     do {
       ConsumeToken();
-      AbstractType& type = AbstractType::ZoneHandle(ParseType(finalization));
-      types.Add(&type);
+      type = ParseType(finalization);
+      types.Add(type);
       // Only keep the error for the first malformed type argument.
       if (malformed_error->IsNull() && type.IsMalformed()) {
         *malformed_error = type.malformed_error();
       }
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
     if (finalization != ClassFinalizer::kIgnore) {
       return NewTypeArguments(types);
     }
   }
   return TypeArguments::null();
 }
 
 
 // Parse and return an array of interface types.
 RawArray* Parser::ParseInterfaceList() {
   TRACE_PARSER("ParseInterfaceList");
   ASSERT((CurrentToken() == Token::kIMPLEMENTS) ||
          (CurrentToken() == Token::kEXTENDS));
-  GrowableArray<AbstractType*> interfaces;
+  const GrowableObjectArray& interfaces =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
   String& interface_name = String::Handle();
+  AbstractType& interface = AbstractType::Handle();
+  String& other_name = String::Handle();
+  AbstractType& other_interface = AbstractType::Handle();
   do {
     ConsumeToken();
     intptr_t supertype_pos = token_index_;
-    AbstractType& interface = AbstractType::ZoneHandle(
-        ParseType(ClassFinalizer::kTryResolve));
+    interface = ParseType(ClassFinalizer::kTryResolve);
     interface_name = interface.Name();
-    for (int i = 0; i < interfaces.length(); i++) {
-      String& other_name = String::Handle(interfaces[i]->Name());
+    for (int i = 0; i < interfaces.Length(); i++) {
+      other_interface ^= interfaces.At(i);
+      other_name = other_interface.Name();
       if (interface_name.Equals(other_name)) {
         ErrorMsg(supertype_pos, "Duplicate supertype '%s'",
                  interface_name.ToCString());
       }
     }
-    interfaces.Add(&interface);
+    interfaces.Add(interface);
   } while (CurrentToken() == Token::kCOMMA);
-  return NewArray<AbstractType>(interfaces);
+  return Array::MakeArray(interfaces);
 }
 
 
 void Parser::AddInterfaces(intptr_t interfaces_pos,
                            const Class& cls,
                            const Array& interfaces) {
-  GrowableArray<AbstractType*> all_interfaces;
+  const GrowableObjectArray& all_interfaces =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
+  AbstractType& interface = AbstractType::Handle();
   // First get all the interfaces already implemented by class.
   Array& cls_interfaces = Array::Handle(cls.interfaces());
   for (intptr_t i = 0; i < cls_interfaces.Length(); i++) {
-    AbstractType& interface = AbstractType::ZoneHandle();
     interface ^= cls_interfaces.At(i);
-    all_interfaces.Add(&interface);
+    all_interfaces.Add(interface);
   }
   // Now add the new interfaces.
   AbstractType& conflicting = AbstractType::Handle();
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     AbstractType& interface = AbstractType::ZoneHandle();
     interface ^= interfaces.At(i);
     if (interface.IsTypeParameter()) {
       if (cls.is_interface()) {
         ErrorMsg(interfaces_pos,
                  "interface '%s' may not extend type parameter '%s'",
                  String::Handle(cls.Name()).ToCString(),
                  String::Handle(interface.Name()).ToCString());
       } else {
         ErrorMsg(interfaces_pos,
                  "class '%s' may not implement type parameter '%s'",
                  String::Handle(cls.Name()).ToCString(),
                  String::Handle(interface.Name()).ToCString());
       }
     }
-    if (!ClassFinalizer::AddInterfaceIfUnique(&all_interfaces,
-                                              &interface,
+    if (!ClassFinalizer::AddInterfaceIfUnique(all_interfaces,
+                                              interface,
                                               &conflicting)) {
       ASSERT(!conflicting.IsNull());
       ErrorMsg(interfaces_pos,
                "interface '%s' conflicts with interface '%s'",
                String::Handle(interface.Name()).ToCString(),
                String::Handle(conflicting.Name()).ToCString());
     }
   }
-  cls_interfaces = NewArray<AbstractType>(all_interfaces);
+  cls_interfaces = Array::MakeArray(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_final = (CurrentToken() == Token::kFINAL);
   const bool is_static = true;
   const AbstractType& type = AbstractType::ZoneHandle(ParseFinalVarOrType(
       FLAG_enable_type_checks ? ClassFinalizer::kTryResolve :
                                 ClassFinalizer::kIgnore));
+  Field& field = Field::Handle();
+  Function& getter = Function::Handle();
   while (true) {
     const intptr_t name_pos = token_index_;
     String& var_name = *ExpectIdentifier("variable name expected");
 
     if (library_.LookupObject(var_name) != Object::null()) {
       ErrorMsg(name_pos, "'%s' is already defined", var_name.ToCString());
     }
     String& accessor_name = String::Handle(Field::GetterName(var_name));
     if (library_.LookupObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "getter for '%s' is already defined",
                var_name.ToCString());
     }
     accessor_name = Field::SetterName(var_name);
     if (library_.LookupObject(accessor_name) != Object::null()) {
       ErrorMsg(name_pos, "setter for '%s' is already defined",
                var_name.ToCString());
     }
 
-    Field& field = Field::ZoneHandle(
-        Field::New(var_name, is_static, is_final, name_pos));
+    field = Field::New(var_name, is_static, is_final, name_pos);
     field.set_type(type);
     field.set_value(Instance::Handle(Instance::null()));
-    top_level->fields.Add(&field);
+    top_level->fields.Add(field);
     library_.AddObject(field, var_name);
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       SkipExpr();
       field.set_value(Instance::Handle(Object::sentinel()));
       // Create a static const getter.
       String& getter_name = String::ZoneHandle(Field::GetterSymbol(var_name));
-      Function& getter = Function::ZoneHandle(
-          Function::New(getter_name, RawFunction::kConstImplicitGetter,
-                        is_static, is_final, name_pos));
+      getter = Function::New(getter_name, RawFunction::kConstImplicitGetter,
+                             is_static, is_final, name_pos);
       getter.set_result_type(type);
-      top_level->functions.Add(&getter);
+      top_level->functions.Add(getter);
     } else if (is_final) {
       ErrorMsg(name_pos, "missing initializer for final variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
     } else {
@@ skipping 49 matching lines @@
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
     ExpectSemicolon();
     function_end_pos = token_index_;
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
-  Function& func = Function::ZoneHandle(
+  Function& func = Function::Handle(
       Function::New(func_name, RawFunction::kFunction,
                     is_static, false, function_pos));
   func.set_result_type(result_type);
   func.set_end_token_index(function_end_pos);
   AddFormalParamsToFunction(&params, func);
-  top_level->functions.Add(&func);
+  top_level->functions.Add(func);
   library_.AddObject(func, func_name);
 }
 
 
 void Parser::ParseTopLevelAccessor(TopLevel* top_level) {
   TRACE_PARSER("ParseTopLevelAccessor");
   const bool is_static = true;
   AbstractType& result_type = AbstractType::Handle();
   bool is_getter = (CurrentToken() == Token::kGET);
   if (CurrentToken() == Token::kGET ||
@@ skipping 53 matching lines @@
     SkipBlock();
   } else if (CurrentToken() == Token::kARROW) {
     ConsumeToken();
     SkipExpr();
     ExpectSemicolon();
   } else if (IsLiteral("native")) {
     ParseNativeDeclaration();
   } else {
     ErrorMsg("function block expected");
   }
-  Function& func = Function::ZoneHandle(
+  Function& func = Function::Handle(
       Function::New(accessor_name,
                     is_getter? RawFunction::kGetterFunction :
                                RawFunction::kSetterFunction,
                     is_static, false, accessor_pos));
   func.set_result_type(result_type);
   AddFormalParamsToFunction(&params, func);
-  top_level->functions.Add(&func);
+  top_level->functions.Add(func);
   library_.AddObject(func, accessor_name);
 }
 
 
 void Parser::ParseLibraryName() {
   TRACE_PARSER("ParseLibraryName");
   if ((script_.kind() == RawScript::kLibrary) &&
       (CurrentToken() != Token::kLIBRARY)) {
     // Handle error case early to get consistent error message.
     ExpectToken(Token::kLIBRARY);
@@ skipping 153 matching lines @@
   ParseLibraryInclude();
   ParseLibraryResource();
 }
 
 
 void Parser::ParseTopLevel() {
   TRACE_PARSER("ParseTopLevel");
   // Collect the classes found at the top level in this growable array.
   // They need to be registered with class finalization after parsing
   // has been completed.
-  GrowableArray<const Class*> classes;
+  Isolate* isolate = Isolate::Current();
+  ObjectStore* object_store = isolate->object_store();
+  const GrowableObjectArray& pending_classes =
+      GrowableObjectArray::Handle(isolate, object_store->pending_classes());
   SetPosition(0);
   is_top_level_ = true;
   TopLevel top_level;
-  Class& toplevel_class = Class::ZoneHandle(
+  Class& toplevel_class = Class::Handle(
       Class::New(String::ZoneHandle(String::NewSymbol("::")),
                  script_,
                  token_index_));
   toplevel_class.set_library(library_);
 
   if (is_library_source()) {
     ParseLibraryDefinition();
   }
 
   while (true) {
     set_current_class(Class::Handle());  // No current class.
     if (CurrentToken() == Token::kCLASS) {
-      ParseClassDefinition(&classes);
+      ParseClassDefinition(pending_classes);
     } else if ((CurrentToken() == Token::kTYPEDEF) &&
                (LookaheadToken(1) != Token::kLPAREN)) {
-      ParseFunctionTypeAlias(&classes);
+      ParseFunctionTypeAlias(pending_classes);
     } else if (CurrentToken() == Token::kINTERFACE) {
-      ParseInterfaceDefinition(&classes);
+      ParseInterfaceDefinition(pending_classes);
     } else {
       set_current_class(toplevel_class);
       if (IsVariableDeclaration()) {
         ParseTopLevelVariable(&top_level);
       } else if (IsTopLevelFunction()) {
         ParseTopLevelFunction(&top_level);
       } else if (IsTopLevelAccessor()) {
         ParseTopLevelAccessor(&top_level);
       } else if (CurrentToken() == Token::kEOS) {
         break;
       } else {
         UnexpectedToken();
       }
     }
   }
-  if ((top_level.fields.length() > 0) || (top_level.functions.length() > 0)) {
-    toplevel_class.SetFields(
-        Array::Handle(NewArray<Field>(top_level.fields)));
-    toplevel_class.SetFunctions(
-        Array::Handle(NewArray<Function>(top_level.functions)));
+  if ((top_level.fields.Length() > 0) || (top_level.functions.Length() > 0)) {
+    Array& array = Array::Handle();
+
+    array = Array::MakeArray(top_level.fields);
+    toplevel_class.SetFields(array);
+
+    array = Array::MakeArray(top_level.functions);
+    toplevel_class.SetFunctions(array);
+
     library_.AddAnonymousClass(toplevel_class);
-    classes.Add(&toplevel_class);
+    pending_classes.Add(toplevel_class, Heap::kOld);
   }
-  ClassFinalizer::AddPendingClasses(classes);
 }
 
 
 void Parser::ChainNewBlock(LocalScope* outer_scope) {
   Block* block = new Block(current_block_,
                            outer_scope,
                            new SequenceNode(token_index_, outer_scope));
   current_block_ = block;
 }
 
@@ skipping 2368 matching lines @@
                               bool require_const) {
   TRACE_PARSER("ParseActualParameters");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const bool saved_mode = SetAllowFunctionLiterals(true);
   ArgumentListNode* arguments;
   if (implicit_arguments == NULL) {
     arguments = new ArgumentListNode(token_index_);
   } else {
     arguments = implicit_arguments;
   }
-  GrowableArray<const String*> names;
+  const GrowableObjectArray& names =
+      GrowableObjectArray::Handle(GrowableObjectArray::New());
   bool named_argument_seen = false;
   if (LookaheadToken(1) != Token::kRPAREN) {
+    String& arg_name = String::Handle();
     do {
       ASSERT((CurrentToken() == Token::kLPAREN) ||
              (CurrentToken() == Token::kCOMMA));
       ConsumeToken();
       if (IsIdentifier() && (LookaheadToken(1) == Token::kCOLON)) {
         named_argument_seen = true;
         // The canonicalization of the argument descriptor array built in the
         // code generator requires that the names are symbols, i.e.
         // canonicalized strings.
         ASSERT(CurrentLiteral()->IsSymbol());
-        for (int i = 0; i < names.length(); i++) {
-          if (CurrentLiteral()->Equals(*names[i])) {
+        for (int i = 0; i < names.Length(); i++) {
+          arg_name ^= names.At(i);
+          if (CurrentLiteral()->Equals(arg_name)) {
             ErrorMsg("duplicate named argument");
           }
         }
-        names.Add(CurrentLiteral());
+        names.Add(*CurrentLiteral());
         ConsumeToken();  // ident.
         ConsumeToken();  // colon.
       } else if (named_argument_seen) {
         ErrorMsg("named argument expected");
       }
       arguments->Add(ParseExpr(require_const));
     } while (CurrentToken() == Token::kCOMMA);
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
   SetAllowFunctionLiterals(saved_mode);
   if (named_argument_seen) {
-    arguments->set_names(Array::Handle(NewArray<const String>(names)));
+    arguments->set_names(Array::Handle(Array::MakeArray(names)));
   }
   return arguments;
 }
 
 
 AstNode* Parser::ParseStaticCall(const Class& cls,
                                  const String& func_name,
                                  intptr_t ident_pos) {
   TRACE_PARSER("ParseStaticCall");
   const intptr_t call_pos = token_index_;
@@ skipping 2129 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart