Make default_parameter_values a ZoneGrowableArray instead of an array in new space

runtime/vm/parser.h

 // 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.
 
 #ifndef VM_PARSER_H_
 #define VM_PARSER_H_
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
@@ skipping 29 matching lines @@
 // The class ParsedFunction holds the result of parsing a function.
 class ParsedFunction : public ZoneAllocated {
  public:
   ParsedFunction(Thread* thread, const Function& function)
       : thread_(thread),
         function_(function),
         code_(Code::Handle(zone(), function.unoptimized_code())),
         node_sequence_(NULL),
         regexp_compile_data_(NULL),
         instantiator_(NULL),
-        default_parameter_values_(Array::ZoneHandle(zone(), Array::null())),
         current_context_var_(NULL),
         expression_temp_var_(NULL),
         finally_return_temp_var_(NULL),
         deferred_prefixes_(new ZoneGrowableArray<const LibraryPrefix*>()),
         guarded_fields_(new ZoneGrowableArray<const Field*>()),
+        default_parameter_values_(NULL),
         first_parameter_index_(0),
         first_stack_local_index_(0),
         num_copied_params_(0),
         num_stack_locals_(0),
         have_seen_await_expr_(false) {
     ASSERT(function.IsZoneHandle());
     // Every function has a local variable for the current context.
     LocalVariable* temp = new(zone()) LocalVariable(
         function.token_pos(),
         Symbols::CurrentContextVar(),
@@ skipping 12 matching lines @@
     return regexp_compile_data_;
   }
   void SetRegExpCompileData(RegExpCompileData* regexp_compile_data);
 
   LocalVariable* instantiator() const { return instantiator_; }
   void set_instantiator(LocalVariable* instantiator) {
     // May be NULL.
     instantiator_ = instantiator;
   }
 
-  const Array& default_parameter_values() const {
-    return default_parameter_values_;
+  void set_default_parameter_values(ZoneGrowableArray<const Instance*>* list) {
+    default_parameter_values_ = list;
+#if defined(DEBUG)
+    for (intptr_t i = 0; i < list->length(); i++) {
+      ASSERT(list->At(i)->IsZoneHandle() || list->At(i)->InVMHeap());
+    }
+#endif
   }
-  void set_default_parameter_values(const Array& default_parameter_values) {
-    ASSERT(default_parameter_values.IsZoneHandle() ||
-           default_parameter_values.InVMHeap());
-    default_parameter_values_ = default_parameter_values.raw();
+
+
+  const Instance& DefaultParameterValueAt(intptr_t i) const {
+    ASSERT(default_parameter_values_ != NULL);
+    return *default_parameter_values_->At(i);
   }
 
   LocalVariable* current_context_var() const {
     return current_context_var_;
   }
 
   LocalVariable* expression_temp_var() const {
     ASSERT(has_expression_temp_var());
     return expression_temp_var_;
   }
@@ skipping 49 matching lines @@
   Isolate* isolate() const { return thread_->isolate(); }
   Zone* zone() const { return thread_->zone(); }
 
  private:
   Thread* thread_;
   const Function& function_;
   Code& code_;
   SequenceNode* node_sequence_;
   RegExpCompileData* regexp_compile_data_;
   LocalVariable* instantiator_;
-  Array& default_parameter_values_;
   LocalVariable* current_context_var_;
   LocalVariable* expression_temp_var_;
   LocalVariable* finally_return_temp_var_;
   ZoneGrowableArray<const LibraryPrefix*>* deferred_prefixes_;
   ZoneGrowableArray<const Field*>* guarded_fields_;
+  ZoneGrowableArray<const Instance*>* default_parameter_values_;
 
   int first_parameter_index_;
   int first_stack_local_index_;
   int num_copied_params_;
   int num_stack_locals_;
   bool have_seen_await_expr_;
 
   friend class Parser;
   DISALLOW_COPY_AND_ASSIGN(ParsedFunction);
 };
@@ skipping 325 matching lines @@
                                 ArgumentListNode* arguments,
                                 bool resolve_getter,
                                 bool* is_no_such_method);
   AstNode* ParseSuperCall(const String& function_name);
   AstNode* ParseSuperFieldAccess(const String& field_name, intptr_t field_pos);
   AstNode* ParseSuperOperator();
   AstNode* BuildUnarySuperOperator(Token::Kind op, PrimaryNode* super);
 
   static bool ParseFormalParameters(const Function& func, ParamList* params);
 
-  static void SetupDefaultsForOptionalParams(const ParamList& params,
-                                             Array* default_values);
+  static void SetupDefaultsForOptionalParams(
+      const ParamList& params,
+      ZoneGrowableArray<const Instance*>* default_values);
   ClosureNode* CreateImplicitClosureNode(const Function& func,
                                          intptr_t token_pos,
                                          AstNode* receiver);
   static void AddFormalParamsToFunction(const ParamList* params,
                                         const Function& func);
   void AddFormalParamsToScope(const ParamList* params, LocalScope* scope);
 
-  SequenceNode* ParseConstructor(const Function& func,
-                                 Array* default_parameter_values);
-  SequenceNode* ParseFunc(const Function& func,
-                          Array* default_parameter_values);
+  SequenceNode* ParseConstructor(
+      const Function& func, ZoneGrowableArray<const Instance*>* default_values);
+  SequenceNode* ParseFunc(
+      const Function& func, ZoneGrowableArray<const Instance*>* default_values);
 
   void ParseNativeFunctionBlock(const ParamList* params, const Function& func);
 
   SequenceNode* ParseInstanceGetter(const Function& func);
   SequenceNode* ParseInstanceSetter(const Function& func);
   SequenceNode* ParseStaticFinalGetter(const Function& func);
   SequenceNode* ParseStaticInitializer();
   SequenceNode* ParseMethodExtractor(const Function& func);
-  SequenceNode* ParseNoSuchMethodDispatcher(const Function& func,
-                                            Array* default_values);
-  SequenceNode* ParseInvokeFieldDispatcher(const Function& func,
-                                           Array* default_values);
-  SequenceNode* ParseImplicitClosure(const Function& func,
-                                     Array* default_values);
-  SequenceNode* ParseConstructorClosure(const Function& func,
-                                        Array* default_values);
+  SequenceNode* ParseNoSuchMethodDispatcher(
+      const Function& func, ZoneGrowableArray<const Instance*>* default_values);
+  SequenceNode* ParseInvokeFieldDispatcher(
+      const Function& func, ZoneGrowableArray<const Instance*>* default_values);
+  SequenceNode* ParseImplicitClosure(
+      const Function& func, ZoneGrowableArray<const Instance*>* default_values);
+  SequenceNode* ParseConstructorClosure(
+      const Function& func, ZoneGrowableArray<const Instance*>* default_values);
 
   void BuildDispatcherScope(const Function& func,
                             const ArgumentsDescriptor& desc,
-                            Array* default_values);
+                            ZoneGrowableArray<const Instance*>* default_values);
 
   void EnsureHasReturnStatement(SequenceNode* seq, intptr_t return_pos);
   void ChainNewBlock(LocalScope* outer_scope);
   void OpenBlock();
   void OpenLoopBlock();
   void OpenFunctionBlock(const Function& func);
   void OpenAsyncClosure();
   RawFunction* OpenAsyncFunction(intptr_t formal_param_pos);
   RawFunction* OpenSyncGeneratorFunction(intptr_t func_pos);
   SequenceNode* CloseSyncGenFunction(const Function& closure,
@@ skipping 325 matching lines @@
 
   // Indentation of parser trace.
   intptr_t trace_indent_;
 
   DISALLOW_COPY_AND_ASSIGN(Parser);
 };
 
 }  // namespace dart
 
 #endif  // VM_PARSER_H_