Remove more GrowableObjectArray usage in parser

runtime/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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 667 matching lines @@
   String* dict_name;
   ParamList params;
   RawFunction::Kind kind;
   // NULL for functions, field object for static or instance fields.
   Field* field_;
 };
 
 
 class ClassDesc : public ValueObject {
  public:
-  ClassDesc(const Class& cls,
+  ClassDesc(Zone* zone,
+            const Class& cls,
             const String& cls_name,
             bool is_interface,
             intptr_t token_pos)
-      : clazz_(cls),
+      : zone_(zone),
+        clazz_(cls),
         class_name_(cls_name),
         token_pos_(token_pos),
-        functions_(GrowableObjectArray::Handle(GrowableObjectArray::New())),
-        fields_(GrowableObjectArray::Handle(GrowableObjectArray::New())) {
+        functions_(zone, 4),
+        fields_(zone, 4) {
   }
 
   void AddFunction(const Function& function) {
-    functions_.Add(function);
+    functions_.Add(&Function::ZoneHandle(zone_, function.raw()));
   }
 
-  const GrowableObjectArray& functions() const {
+  const GrowableArray<const Function*>& functions() const {
     return functions_;
   }
 
   void AddField(const Field& field) {
-    fields_.Add(field);
+    fields_.Add(&Field::ZoneHandle(zone_, field.raw()));
   }
 
-  const GrowableObjectArray& fields() const {
+  const GrowableArray<const Field*>& fields() const {
     return fields_;
   }
 
   const Class& clazz() const {
     return clazz_;
   }
 
   const String& class_name() const {
     return class_name_;
   }
 
   bool has_constructor() const {
-    Function& func = Function::Handle();
-    for (int i = 0; i < functions_.Length(); i++) {
-      func ^= functions_.At(i);
-      if (func.kind() == RawFunction::kConstructor) {
+    for (int i = 0; i < functions_.length(); i++) {
+      const Function* 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;
   }
 
+  RawArray* MakeFunctionsArray() {
+    const intptr_t len = functions_.length();
+    const Array& res = Array::Handle(zone_, Array::New(len, Heap::kOld));
+    for (intptr_t i = 0; i < len; i++) {
+      res.SetAt(i, *functions_[i]);
+    }
+    return res.raw();
+  }
+
  private:
+  Zone* zone_;
   const Class& clazz_;
   const String& class_name_;
   intptr_t token_pos_;   // Token index of "class" keyword.
-  GrowableObjectArray& functions_;
-  GrowableObjectArray& fields_;
+  GrowableArray<const Function*> functions_;
+  GrowableArray<const Field*> fields_;
   GrowableArray<MemberDesc> members_;
 };
 
 
-struct TopLevel {
-  TopLevel() :
-      fields(GrowableObjectArray::Handle(GrowableObjectArray::New())),
-      functions(GrowableObjectArray::Handle(GrowableObjectArray::New())) { }
+class TopLevel : public ValueObject {
+ public:
+  explicit TopLevel(Zone* zone) :
+      zone_(zone),
+      fields_(zone, 4),
+      functions_(zone, 4) { }
 
-  GrowableObjectArray& fields;
-  GrowableObjectArray& functions;
+  void AddField(const Field& field) {
+    fields_.Add(&Field::ZoneHandle(zone_, field.raw()));
+  }
+
+  void AddFunction(const Function& function) {
+    functions_.Add(&Function::ZoneHandle(zone_, function.raw()));
+  }
+
+  const GrowableArray<const Field*>& fields() const {
+    return fields_;
+  }
+
+  const GrowableArray<const Function*>& functions() const {
+    return functions_;
+  }
+
+ private:
+  Zone* zone_;
+  GrowableArray<const Field*> fields_;
+  GrowableArray<const Function*> functions_;
 };
 
 
 void Parser::ParseClass(const Class& cls) {
   if (!cls.is_synthesized_class()) {
     Thread* thread = Thread::Current();
     Zone* zone = thread->zone();
     CSTAT_TIMER_SCOPE(thread, parser_timer);
     ASSERT(thread->long_jump_base()->IsSafeToJump());
     const Script& script = Script::Handle(zone, cls.script());
@@ skipping 390 matching lines @@
     const Script& script = Script::Handle(
         Script::New(uri, source, RawScript::kSourceTag));
     const Library& owning_library = Library::Handle(owning_class.library());
     const String& private_key = String::Handle(owning_library.private_key());
     script.Tokenize(private_key);
     const intptr_t token_pos = 0;
     Parser parser(script, owning_library, token_pos);
     parser.is_top_level_ = true;
     parser.set_current_class(owning_class);
     const String& class_name = String::Handle(owning_class.Name());
-    ClassDesc members(owning_class, class_name, false, token_pos);
+    ClassDesc members(stack_zone.GetZone(),
+                      owning_class,
+                      class_name,
+                      false,  /* is_interface */
+                      token_pos);
     const intptr_t metadata_pos = parser.SkipMetadata();
     parser.ParseClassMemberDefinition(&members, metadata_pos);
-    ASSERT(members.functions().Length() == 1);
-    const Function& func =
-        Function::ZoneHandle(Function::RawCast(members.functions().At(0)));
+    ASSERT(members.functions().length() == 1);
+    const Function& func = *members.functions().At(0);
     func.set_eval_script(script);
     ParsedFunction* parsed_function = new ParsedFunction(thread, func);
     Parser::ParseFunction(parsed_function);
     return func.raw();
   } else {
     const Error& error = Error::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return error.raw();
   }
   UNREACHABLE();
@@ skipping 3405 matching lines @@
   SkipMetadata();
   if (is_patch_source() &&
       (CurrentToken() == Token::kIDENT) &&
       CurrentLiteral()->Equals("patch")) {
     ConsumeToken();
   } else if (CurrentToken() == Token::kABSTRACT) {
     ConsumeToken();
   }
   ExpectToken(Token::kCLASS);
   const intptr_t class_pos = TokenPos();
-  ClassDesc members(cls, class_name, false, class_pos);
+  ClassDesc members(Z, cls, class_name, false, class_pos);
   while (CurrentToken() != Token::kLBRACE) {
     ConsumeToken();
   }
   ExpectToken(Token::kLBRACE);
   while (CurrentToken() != Token::kRBRACE) {
     intptr_t metadata_pos = SkipMetadata();
     ParseClassMemberDefinition(&members, metadata_pos);
   }
   ExpectToken(Token::kRBRACE);
 
   CheckConstructors(&members);
 
   // Need to compute this here since MakeArray() will clear the
   // functions array in members.
   const bool need_implicit_constructor =
       !members.has_constructor() && !cls.is_patch();
 
   cls.AddFields(members.fields());
 
   // Creating a new array for functions marks the class as parsed.
-  const Array& array = Array::Handle(Z, Array::MakeArray(members.functions()));
+  Array& array = Array::Handle(Z, members.MakeFunctionsArray());
   cls.SetFunctions(array);
 
   // Add an implicit constructor if no explicit constructor is present.
   // No implicit constructors are needed for patch classes.
   if (need_implicit_constructor) {
     AddImplicitConstructor(cls);
   }
 
   if (cls.is_patch()) {
     // Apply the changes to the patched class looked up above.
@@ skipping 10 matching lines @@
 
 
 void Parser::ParseEnumDefinition(const Class& cls) {
   TRACE_PARSER("ParseEnumDefinition");
   INC_STAT(I, num_classes_compiled, 1);
 
   SkipMetadata();
   ExpectToken(Token::kENUM);
 
   const String& enum_name = String::Handle(Z, cls.Name());
-  ClassDesc enum_members(cls, enum_name, false, cls.token_pos());
+  ClassDesc enum_members(Z, cls, enum_name, false, cls.token_pos());
 
   // Add instance field 'final int index'.
   Field& index_field = Field::ZoneHandle(Z);
   const Type& int_type = Type::Handle(Z, Type::IntType());
   const Type& dynamic_type = Type::Handle(Type::DynamicType());
   index_field = Field::New(Symbols::Index(),
                            false,  // Not static.
                            true,  // Field is final.
                            false,  // Not const.
                            true,  // Is reflectable.
@@ skipping 137 matching lines @@
   enum_members.AddFunction(to_string_func);
 
   // Clone the hashCode getter function from the helper class.
   Function& hash_code_func = Function::Handle(I,
       helper_class.LookupDynamicFunctionAllowPrivate(Symbols::hashCode()));
   ASSERT(!hash_code_func.IsNull());
   hash_code_func = hash_code_func.Clone(cls);
   enum_members.AddFunction(hash_code_func);
 
   cls.AddFields(enum_members.fields());
-  const Array& functions =
-      Array::Handle(Z, Array::MakeArray(enum_members.functions()));
+  const Array& functions = Array::Handle(Z, enum_members.MakeFunctionsArray());
   cls.SetFunctions(functions);
 }
 
 
 // Add an implicit constructor to the given class.
 void Parser::AddImplicitConstructor(const Class& cls) {
   // The implicit constructor is unnamed, has no explicit parameter.
   String& ctor_name = String::ZoneHandle(Z, cls.Name());
   ctor_name = Symbols::FromConcat(ctor_name, Symbols::Dot());
   // To indicate that this is an implicit constructor, we set the
@@ skipping 555 matching lines @@
       ReportError(name_pos, "setter for '%s' is already defined",
                   var_name.ToCString());
     }
 
     const bool is_reflectable =
         !(library_.is_dart_scheme() && library_.IsPrivate(var_name));
     field = Field::New(var_name, is_static, is_final, is_const, is_reflectable,
                        current_class(), name_pos);
     field.set_type(type);
     field.set_value(Object::null_instance());
-    top_level->fields.Add(field);
+    top_level->AddField(field);
     library_.AddObject(field, var_name);
     if (metadata_pos >= 0) {
       library_.AddFieldMetadata(field, metadata_pos);
     }
     if (CurrentToken() == Token::kASSIGN) {
       ConsumeToken();
       Instance& field_value = Instance::Handle(Z, Object::sentinel().raw());
       bool has_simple_literal = false;
       if (LookaheadToken(1) == Token::kSEMICOLON) {
         has_simple_literal = IsSimpleLiteral(type, &field_value);
@@ skipping 12 matching lines @@
                                /* is_abstract = */ false,
                                /* is_external = */ false,
                                /* is_native = */ false,
                                current_class(),
                                name_pos);
         getter.set_result_type(type);
         getter.set_is_debuggable(false);
         if (library_.is_dart_scheme() && library_.IsPrivate(var_name)) {
           getter.set_is_reflectable(false);
         }
-        top_level->functions.Add(getter);
+        top_level->AddFunction(getter);
       }
     } else if (is_final) {
       ReportError(name_pos, "missing initializer for final or const variable");
     }
 
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     } else if (CurrentToken() == Token::kSEMICOLON) {
       ConsumeToken();
       break;
@@ skipping 124 matching lines @@
                     is_native,
                     current_class(),
                     decl_begin_pos));
   func.set_result_type(result_type);
   func.set_end_token_pos(function_end_pos);
   func.set_modifier(func_modifier);
   if (library_.is_dart_scheme() && library_.IsPrivate(func_name)) {
     func.set_is_reflectable(false);
   }
   AddFormalParamsToFunction(&params, func);
-  top_level->functions.Add(func);
+  top_level->AddFunction(func);
   if (!is_patch) {
     library_.AddObject(func, func_name);
   } else {
     library_.ReplaceObject(func, func_name);
   }
   if (metadata_pos >= 0) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
@@ skipping 133 matching lines @@
   func.set_result_type(result_type);
   func.set_end_token_pos(accessor_end_pos);
   func.set_modifier(func_modifier);
   if (is_native) {
     func.set_is_debuggable(false);
   }
   if (library_.is_dart_scheme() && library_.IsPrivate(accessor_name)) {
     func.set_is_reflectable(false);
   }
   AddFormalParamsToFunction(&params, func);
-  top_level->functions.Add(func);
+  top_level->AddFunction(func);
   if (!is_patch) {
     library_.AddObject(func, accessor_name);
   } else {
     library_.ReplaceObject(func, accessor_name);
   }
   if (metadata_pos >= 0) {
     library_.AddFunctionMetadata(func, metadata_pos);
   }
 }
 
@@ skipping 290 matching lines @@
 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.
   ObjectStore* object_store = I->object_store();
   const GrowableObjectArray& pending_classes =
       GrowableObjectArray::Handle(Z, object_store->pending_classes());
   SetPosition(0);
   is_top_level_ = true;
-  TopLevel top_level;
+  TopLevel top_level(Z);
   Class& toplevel_class = Class::Handle(Z,
       Class::New(Symbols::TopLevel(), script_, TokenPos()));
   toplevel_class.set_library(library_);
 
   if (is_library_source() || is_patch_source()) {
     set_current_class(toplevel_class);
     ParseLibraryDefinition();
   } else if (is_part_source()) {
     ParsePartHeader();
   }
@@ skipping 26 matching lines @@
         ParseTopLevelAccessor(&top_level, metadata_pos);
       } else if (CurrentToken() == Token::kEOS) {
         break;
       } else {
         UnexpectedToken();
       }
     }
   }
 
   if ((library_.num_anonymous_classes() == 0) ||
-    (top_level.fields.Length() > 0) || (top_level.functions.Length() > 0)) {
-    toplevel_class.AddFields(top_level.fields);
-
-    const Array& array = Array::Handle(Z,
-                                       Array::MakeArray(top_level.functions));
+      (top_level.fields().length() > 0) ||
+      (top_level.functions().length() > 0)) {
+    toplevel_class.AddFields(top_level.fields());
+    const intptr_t len = top_level.functions().length();
+    const Array& array = Array::Handle(Z, Array::New(len, Heap::kOld));
+    for (intptr_t i = 0; i < len; i++) {
+      array.SetAt(i, *top_level.functions()[i]);
+    }
     toplevel_class.SetFunctions(array);
-
     library_.AddAnonymousClass(toplevel_class);
     pending_classes.Add(toplevel_class, Heap::kOld);
   }
 }
 
 
 void Parser::ChainNewBlock(LocalScope* outer_scope) {
   Block* block = new(Z) Block(
       current_block_,
       outer_scope,
@@ skipping 8176 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart