New growth strategy for growable arrays

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 "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 1318 matching lines @@
         }
         expr = GenerateStaticFieldLookup(field, ident_pos);
       }
     }
     if (expr->EvalConstExpr() == NULL) {
       ReportError(expr_pos, "expression must be a compile-time constant");
     }
     const Instance& val = EvaluateConstExpr(expr_pos, expr);
     meta_values.Add(val, Heap::kOld);
   }
-  return Array::MakeArray(meta_values);
+  return Array::MakeFixedLength(meta_values);
 }
 
 
 SequenceNode* Parser::ParseStaticInitializer() {
   ExpectIdentifier("field name expected");
   CheckToken(Token::kASSIGN, "field initialier expected");
   ConsumeToken();
   OpenFunctionBlock(parsed_function()->function());
   TokenPosition expr_pos = TokenPos();
   AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
@@ skipping 3617 matching lines @@
     ParseClassMemberDefinition(&members, metadata_pos);
   }
   ExpectToken(Token::kRBRACE);
 
   if (cls.LookupTypeParameter(class_name) != TypeParameter::null()) {
     ReportError(class_pos, "class name conflicts with type parameter '%s'",
                 class_name.ToCString());
   }
   CheckConstructors(&members);
 
-  // Need to compute this here since MakeArray() will clear the
+  // Need to compute this here since MakeFixedLength() 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.
   Array& array = Array::Handle(Z, members.MakeFunctionsArray());
   cls.SetFunctions(array);
 
@@ skipping 735 matching lines @@
     ConsumeToken();
     TokenPosition interface_pos = TokenPos();
     interface = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (interface.IsTypeParameter()) {
       ReportError(interface_pos,
                   "type parameter '%s' may not be used in interface list",
                   String::Handle(Z, interface.UserVisibleName()).ToCString());
     }
     all_interfaces.Add(interface, Heap::kOld);
   } while (CurrentToken() == Token::kCOMMA);
-  cls_interfaces = Array::MakeArray(all_interfaces);
+  cls_interfaces = Array::MakeFixedLength(all_interfaces);
   cls.set_interfaces(cls_interfaces);
 }
 
 
 RawAbstractType* Parser::ParseMixins(const AbstractType& super_type) {
   TRACE_PARSER("ParseMixins");
   ASSERT(CurrentToken() == Token::kWITH);
   const GrowableObjectArray& mixin_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New(Heap::kOld));
   AbstractType& mixin_type = AbstractType::Handle(Z);
   do {
     ConsumeToken();
     mixin_type = ParseType(ClassFinalizer::kResolveTypeParameters);
     if (mixin_type.IsDynamicType()) {
       // The string 'dynamic' is not resolved yet at this point, but a malformed
       // type mapped to dynamic can be encountered here.
       ReportError(mixin_type.token_pos(), "illegal mixin of a malformed type");
     }
     if (mixin_type.IsTypeParameter()) {
       ReportError(mixin_type.token_pos(),
                   "mixin type '%s' may not be a type parameter",
                   String::Handle(Z, mixin_type.UserVisibleName()).ToCString());
     }
     mixin_types.Add(mixin_type, Heap::kOld);
   } while (CurrentToken() == Token::kCOMMA);
-  return MixinAppType::New(super_type,
-                           Array::Handle(Z, Array::MakeArray(mixin_types)));
+  return MixinAppType::New(
+      super_type, Array::Handle(Z, Array::MakeFixedLength(mixin_types)));
 }
 
 
 void Parser::ParseTopLevelVariable(TopLevel* top_level,
                                    const Object& owner,
                                    TokenPosition metadata_pos) {
   TRACE_PARSER("ParseTopLevelVariable");
   const bool is_const = (CurrentToken() == Token::kCONST);
   // Const fields are implicitly final.
   const bool is_final = is_const || (CurrentToken() == Token::kFINAL);
@@ skipping 508 matching lines @@
       CheckToken(Token::kSTRING, "library url expected");
       AstNode* conditional_url_literal = ParseStringLiteral(false);
 
       // If there was already a condition that triggered, don't try to match
       // again.
       if (condition_triggered) {
         continue;
       }
       // Check if this conditional line overrides the default import.
       const String& key = String::Handle(String::ConcatAll(
-          Array::Handle(Array::MakeArray(pieces)), allocation_space_));
+          Array::Handle(Array::MakeFixedLength(pieces)), allocation_space_));
       const String& value =
           (valueNode == NULL)
               ? Symbols::True()
               : String::Cast(valueNode->AsLiteralNode()->literal());
       // Call the embedder to supply us with the environment.
       const String& env_value =
           String::Handle(Api::GetEnvironmentValue(T, key));
       if (!env_value.IsNull() && env_value.Equals(value)) {
         condition_triggered = true;
         url_literal = conditional_url_literal;
@@ skipping 38 matching lines @@
         ConsumeToken();
         ParseIdentList(&show_list);
       } else if (IsSymbol(Symbols::Hide())) {
         ConsumeToken();
         ParseIdentList(&hide_list);
       } else {
         break;
       }
     }
     if (show_list.Length() > 0) {
-      show_names = Array::MakeArray(show_list);
+      show_names = Array::MakeFixedLength(show_list);
     }
     if (hide_list.Length() > 0) {
-      hide_names = Array::MakeArray(hide_list);
+      hide_names = Array::MakeFixedLength(hide_list);
     }
   }
   ExpectSemicolon();
 
   // Canonicalize library URL.
   const String& canon_url = String::CheckedHandle(
       CallLibraryTagHandler(Dart_kCanonicalizeUrl, import_pos, url));
 
   // Create a new library if it does not exist yet.
   Library& library = Library::Handle(Z, Library::LookupLibrary(T, canon_url));
@@ skipping 4012 matching lines @@
       tokens_iterator_.SetCurrentPosition(finally_pos);
       rethrow_clause = EnsureFinallyClause(
           parse, is_async, exception_var, stack_trace_var,
           is_async ? saved_exception_var : exception_var,
           is_async ? saved_stack_trace_var : stack_trace_var);
     }
   }
 
   CatchClauseNode* catch_clause = new (Z) CatchClauseNode(
       handler_pos, catch_handler_list,
-      Array::ZoneHandle(Z, Array::MakeArray(handler_types)), context_var,
+      Array::ZoneHandle(Z, Array::MakeFixedLength(handler_types)), context_var,
       exception_var, stack_trace_var,
       is_async ? saved_exception_var : exception_var,
       is_async ? saved_stack_trace_var : stack_trace_var,
       (finally_clause != NULL) ? AllocateTryIndex()
                                : CatchClauseNode::kInvalidTryIndex,
       needs_stack_trace);
 
   // Now create the try/catch ast node and return it. If there is a label
   // on the try/catch, close the block that's embedding the try statement
   // and attach the label to it.
@@ skipping 1340 matching lines @@
         ReportError("named argument expected");
       }
       arguments->Add(ParseExpr(require_const, kConsumeCascades));
     } while (CurrentToken() == Token::kCOMMA);
   } else {
     ConsumeToken();
   }
   ExpectToken(Token::kRPAREN);
   SetAllowFunctionLiterals(saved_mode);
   if (named_argument_seen) {
-    arguments->set_names(Array::Handle(Z, Array::MakeArray(names)));
+    arguments->set_names(Array::Handle(Z, Array::MakeFixedLength(names)));
   }
   return arguments;
 }
 
 
 AstNode* Parser::ParseStaticCall(const Class& cls,
                                  const String& func_name,
                                  TokenPosition ident_pos,
                                  const TypeArguments& func_type_args,
                                  const LibraryPrefix* prefix) {
@@ skipping 3557 matching lines @@
                                                 TokenPosition* start,
                                                 TokenPosition* end) {
   UNREACHABLE();
   return false;
 }
 
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME