Heap::kNew-space allocations discovered by experimental code called transitively from parser

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/become.h"
@@ skipping 2876 matching lines @@
 
 
 bool Class::ValidatePostFinalizePatch(const Class& orig_class,
                                       Error* error) const {
   ASSERT(error != NULL);
   // Not allowed to add new fields in a post finalization patch.
   if (fields() != Object::empty_array().raw()) {
     *error = LanguageError::NewFormatted(
         *error,  // No previous error.
         Script::Handle(script()), token_pos(), Report::AtLocation,
-        Report::kError, Heap::kNew,
+        Report::kError, Heap::kOld,
         "new fields are not allowed for this patch");
     return false;
   }
   // There seem to be no functions, the patch is pointless.
   if (functions() == Object::empty_array().raw()) {
     *error = LanguageError::NewFormatted(*error,  // No previous error.
                                          Script::Handle(script()), token_pos(),
                                          Report::AtLocation, Report::kError,
-                                         Heap::kNew, "no functions to patch");
+                                         Heap::kOld, "no functions to patch");
     return false;
   }
   // Iterate over all functions that will be patched and make sure
   // the original function was declared 'external' and has not executed
   // so far i.e no code has been generated for it.
   Thread* thread = Thread::Current();
   ASSERT(thread->IsMutatorThread());
   Zone* zone = thread->zone();
   const Array& funcs = Array::Handle(zone, functions());
   Function& func = Function::Handle(zone);
   Function& orig_func = Function::Handle(zone);
   String& name = String::Handle(zone);
   for (intptr_t i = 0; i < funcs.Length(); i++) {
     func ^= funcs.At(i);
     name ^= func.name();
     orig_func ^= orig_class.LookupFunctionAllowPrivate(name);
     if (!orig_func.IsNull()) {
       if (!orig_func.is_external() || orig_func.HasCode()) {
         // We can only patch external functions in a post finalized class.
         *error = LanguageError::NewFormatted(
             *error,  // No previous error.
             Script::Handle(script()), token_pos(), Report::AtLocation,
-            Report::kError, Heap::kNew,
+            Report::kError, Heap::kOld,
             !orig_func.is_external()
                 ? "'%s' is not external and therefore cannot be patched"
                 : "'%s' has already executed and therefore cannot be patched",
             name.ToCString());
         return false;
       }
     } else if (!Library::IsPrivate(name)) {
       // We can only have new private functions that are added.
       *error = LanguageError::NewFormatted(
           *error,  // No previous error.
           Script::Handle(script()), token_pos(), Report::AtLocation,
-          Report::kError, Heap::kNew,
+          Report::kError, Heap::kOld,
           "'%s' is not private and therefore cannot be patched",
           name.ToCString());
       return false;
     }
   }
   return true;
 }
 
 
 void Class::set_dependent_code(const Array& array) const {
@@ skipping 15 matching lines @@
   intptr_t orig_len = orig_list.Length();
   Array& patch_list = Array::Handle(patch.functions());
   intptr_t patch_len = patch_list.Length();
 
   // TODO(iposva): Verify that only patching existing methods and adding only
   // new private methods.
   Function& func = Function::Handle();
   Function& orig_func = Function::Handle();
   // Lookup the original implicit constructor, if any.
   member_name = Name();
-  member_name = String::Concat(member_name, Symbols::Dot());
+  member_name = String::Concat(member_name, Symbols::Dot(), Heap::kOld);
   Function& orig_implicit_ctor = Function::Handle(LookupFunction(member_name));
   if (!orig_implicit_ctor.IsNull() &&
       !orig_implicit_ctor.IsImplicitConstructor()) {
     // Not an implicit constructor, but a user declared one.
     orig_implicit_ctor = Function::null();
   }
-  const GrowableObjectArray& new_functions =
-      GrowableObjectArray::Handle(GrowableObjectArray::New(orig_len));
+  const GrowableObjectArray& new_functions = GrowableObjectArray::Handle(
+      GrowableObjectArray::New(orig_len, Heap::kOld));
   for (intptr_t i = 0; i < orig_len; i++) {
     orig_func ^= orig_list.At(i);
     member_name ^= orig_func.name();
     func = patch.LookupFunction(member_name);
     if (func.IsNull()) {
       // Non-patched function is preserved, all patched functions are added in
       // the loop below.
       // However, an implicitly created constructor should not be preserved if
       // the patch provides a constructor or a factory. Wait for now.
       if (orig_func.raw() != orig_implicit_ctor.raw()) {
@@ skipping 12 matching lines @@
       return false;
     }
   }
   for (intptr_t i = 0; i < patch_len; i++) {
     func ^= patch_list.At(i);
     if (func.IsGenerativeConstructor() || func.IsFactory()) {
       // Do not preserve the original implicit constructor, if any.
       orig_implicit_ctor = Function::null();
     }
     func.set_owner(patch_class);
-    new_functions.Add(func);
+    new_functions.Add(func, Heap::kOld);
   }
   if (!orig_implicit_ctor.IsNull()) {
     // Preserve the original implicit constructor.
-    new_functions.Add(orig_implicit_ctor);
+    new_functions.Add(orig_implicit_ctor, Heap::kOld);
   }
   Array& new_list = Array::Handle(Array::MakeArray(new_functions));
   SetFunctions(new_list);
 
   // Merge the two list of fields. Raise an error when duplicates are found or
   // when a public field is being added.
   orig_list = fields();
   orig_len = orig_list.Length();
   patch_list = patch.fields();
   patch_len = patch_list.Length();
 
   Field& field = Field::Handle();
   Field& orig_field = Field::Handle();
-  new_list = Array::New(patch_len + orig_len);
+  new_list = Array::New(patch_len + orig_len, Heap::kOld);
   for (intptr_t i = 0; i < patch_len; i++) {
     field ^= patch_list.At(i);
     field.set_owner(patch_class);
     member_name = field.name();
     // TODO(iposva): Verify non-public fields only.
 
     // Verify no duplicate additions.
     orig_field ^= LookupField(member_name);
     if (!orig_field.IsNull()) {
       *error = LanguageError::NewFormatted(
@@ skipping 126 matching lines @@
     ASSERT(field.Owner() == raw());
   }
 #endif
   // The value of static fields is already initialized to null.
   StorePointer(&raw_ptr()->fields_, value.raw());
 }
 
 
 void Class::AddField(const Field& field) const {
   const Array& arr = Array::Handle(fields());
-  const Array& new_arr = Array::Handle(Array::Grow(arr, arr.Length() + 1));
+  const Array& new_arr =
+      Array::Handle(Array::Grow(arr, arr.Length() + 1, Heap::kOld));
   new_arr.SetAt(arr.Length(), field);
   SetFields(new_arr);
 }
 
 
 void Class::AddFields(const GrowableArray<const Field*>& new_fields) const {
   const intptr_t num_new_fields = new_fields.length();
   if (num_new_fields == 0) return;
   const Array& arr = Array::Handle(fields());
   const intptr_t num_old_fields = arr.Length();
@@ skipping 2068 matching lines @@
 
 
 RawString* TypeArguments::EnumerateURIs() const {
   if (IsNull()) {
     return Symbols::Empty().raw();
   }
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   AbstractType& type = AbstractType::Handle(zone);
   const intptr_t num_types = Length();
-  const Array& pieces = Array::Handle(zone, Array::New(num_types));
+  const Array& pieces = Array::Handle(zone, Array::New(num_types, Heap::kOld));
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     pieces.SetAt(i, String::Handle(zone, type.EnumerateURIs()));
   }
-  return String::ConcatAll(pieces);
+  return String::ConcatAll(pieces, Heap::kOld);
 }
 
 
 const char* TypeArguments::ToCString() const {
   if (IsNull()) {
     return "TypeArguments: null";
   }
   Zone* zone = Thread::Current()->zone();
   const char* prev_cstr = OS::SCreate(zone, "TypeArguments: (%" Pd ")",
                                       Smi::Value(raw_ptr()->hash_));
@@ skipping 2423 matching lines @@
 
 
 void Field::SetOriginal(const Field& value) const {
   ASSERT(value.IsOriginal());
   ASSERT(!value.IsNull());
   StorePointer(&raw_ptr()->owner_, reinterpret_cast<RawObject*>(value.raw()));
 }
 
 
 RawString* Field::GetterName(const String& field_name) {
-  return String::Concat(Symbols::GetterPrefix(), field_name);
+  return String::Concat(Symbols::GetterPrefix(), field_name, Heap::kOld);
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   return Symbols::FromGet(Thread::Current(), field_name);
 }
 
 
 RawString* Field::LookupGetterSymbol(const String& field_name) {
   return Symbols::LookupFromGet(Thread::Current(), field_name);
@@ skipping 324 matching lines @@
     ASSERT(!closure.IsNull());
     ASSERT(closure.IsClosure());
     return closure.raw();
   }
 
   // This is the first time a closure for this field is requested.
   // Create the closure and a new static field in which it is stored.
   const char* field_name = String::Handle(zone, name()).ToCString();
   String& expr_src = String::Handle(zone);
   if (make_setter) {
-    expr_src = String::NewFormatted("(%s_) { return %s = %s_; }", field_name,
-                                    field_name, field_name);
+    expr_src = String::NewFormatted(Heap::kOld, "(%s_) { return %s = %s_; }",
+                                    field_name, field_name, field_name);
   } else {
-    expr_src = String::NewFormatted("() { return %s; }", field_name);
+    expr_src =
+        String::NewFormatted(Heap::kOld, "() { return %s; }", field_name);
   }
   Object& result =
       Object::Handle(zone, field_owner.Evaluate(expr_src, Object::empty_array(),
                                                 Object::empty_array()));
   ASSERT(result.IsInstance());
   // The caller may expect the closure to be allocated in old space. Copy
   // the result here, since Object::Clone() is a private method.
   result = Object::Clone(result, Heap::kOld);
 
   closure_field =
@@ skipping 1905 matching lines @@
   return error.raw();
 }
 
 
 void Library::AddPatchClass(const Class& cls) const {
   ASSERT(Thread::Current()->IsMutatorThread());
   ASSERT(cls.is_patch());
   ASSERT(GetPatchClass(String::Handle(cls.Name())) == Class::null());
   const GrowableObjectArray& patch_classes =
       GrowableObjectArray::Handle(this->patch_classes());
-  patch_classes.Add(cls);
+  patch_classes.Add(cls, Heap::kOld);
 }
 
 
 RawClass* Library::GetPatchClass(const String& name) const {
   ASSERT(Thread::Current()->IsMutatorThread());
   const GrowableObjectArray& patch_classes =
       GrowableObjectArray::Handle(this->patch_classes());
   Object& obj = Object::Handle();
   for (intptr_t i = 0; i < patch_classes.Length(); i++) {
     obj = patch_classes.At(i);
@@ skipping 913 matching lines @@
   StorePointer(&raw_ptr()->exported_names_, Array::null());
   StorePointer(&raw_ptr()->loaded_scripts_, Array::null());
 }
 
 
 void Library::AddImport(const Namespace& ns) const {
   Array& imports = Array::Handle(this->imports());
   intptr_t capacity = imports.Length();
   if (num_imports() == capacity) {
     capacity = capacity + kImportsCapacityIncrement + (capacity >> 2);
-    imports = Array::Grow(imports, capacity);
+    imports = Array::Grow(imports, capacity, Heap::kOld);
     StorePointer(&raw_ptr()->imports_, imports.raw());
   }
   intptr_t index = num_imports();
   imports.SetAt(index, ns);
   set_num_imports(index + 1);
 }
 
 
 // Convenience function to determine whether the export list is
 // non-empty.
 bool Library::HasExports() const {
   return exports() != Object::empty_array().raw();
 }
 
 
 // We add one namespace at a time to the exports array and don't
 // pre-allocate any unused capacity. The assumption is that
 // re-exports are quite rare.
 void Library::AddExport(const Namespace& ns) const {
   Array& exports = Array::Handle(this->exports());
   intptr_t num_exports = exports.Length();
-  exports = Array::Grow(exports, num_exports + 1);
+  exports = Array::Grow(exports, num_exports + 1, Heap::kOld);
   StorePointer(&raw_ptr()->exports_, exports.raw());
   exports.SetAt(num_exports, ns);
 }
 
 
 static RawArray* NewDictionary(intptr_t initial_size) {
   const Array& dict = Array::Handle(Array::New(initial_size + 1, Heap::kOld));
   // The last element of the dictionary specifies the number of in use slots.
   dict.SetAt(initial_size, Smi::Handle(Smi::New(0)));
   return dict.raw();
 }
 
 
 void Library::InitResolvedNamesCache() const {
   ASSERT(Thread::Current()->IsMutatorThread());
   StorePointer(&raw_ptr()->resolved_names_,
-               HashTables::New<ResolvedNamesMap>(64));
+               HashTables::New<ResolvedNamesMap>(64, Heap::kOld));
 }
 
 
 void Library::ClearResolvedNamesCache() const {
   ASSERT(Thread::Current()->IsMutatorThread());
   StorePointer(&raw_ptr()->resolved_names_, Array::null());
 }
 
 
 void Library::InitExportedNamesCache() const {
   StorePointer(&raw_ptr()->exported_names_,
-               HashTables::New<ResolvedNamesMap>(16));
+               HashTables::New<ResolvedNamesMap>(16, Heap::kOld));
 }
 
 
 void Library::ClearExportedNamesCache() const {
   StorePointer(&raw_ptr()->exported_names_, Array::null());
 }
 
 
 void Library::InitClassDictionary() const {
   // TODO(iposva): Find reasonable initial size.
@@ skipping 310 matching lines @@
 
   // A library is "registered" in two places:
   // - A growable array mapping from index to library.
   const String& lib_url = String::Handle(zone, url());
   ASSERT(Library::LookupLibrary(thread, lib_url) == Library::null());
   ASSERT(lib_url.HasHash());
   GrowableObjectArray& libs =
       GrowableObjectArray::Handle(zone, object_store->libraries());
   ASSERT(!libs.IsNull());
   set_index(libs.Length());
-  libs.Add(*this);
+  libs.Add(*this, Heap::kOld);
 
   // - A map from URL string to library.
   if (object_store->libraries_map() == Array::null()) {
     LibraryLookupMap map(HashTables::New<LibraryLookupMap>(16, Heap::kOld));
     object_store->set_libraries_map(map.Release());
   }
 
   LibraryLookupMap map(object_store->libraries_map());
   bool present = map.UpdateOrInsert(lib_url, *this);
   ASSERT(!present);
@@ skipping 376 matching lines @@
 RawLibraryPrefix* LibraryPrefix::New(const String& name,
                                      const Namespace& import,
                                      bool deferred_load,
                                      const Library& importer) {
   const LibraryPrefix& result = LibraryPrefix::Handle(LibraryPrefix::New());
   result.set_name(name);
   result.set_num_imports(0);
   result.set_importer(importer);
   result.StoreNonPointer(&result.raw_ptr()->is_deferred_load_, deferred_load);
   result.StoreNonPointer(&result.raw_ptr()->is_loaded_, !deferred_load);
-  result.set_imports(Array::Handle(Array::New(kInitialSize)));
+  result.set_imports(Array::Handle(Array::New(kInitialSize, Heap::kOld)));
   result.AddImport(import);
   return result.raw();
 }
 
 
 void LibraryPrefix::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
@@ skipping 6446 matching lines @@
       const String& declared_bound_name =
           String::Handle(declared_bound.UserVisibleName());
       const String& type_param_name = String::Handle(UserVisibleName());
       const Class& cls = Class::Handle(parameterized_class());
       const String& class_name = String::Handle(cls.Name());
       const Script& script = Script::Handle(cls.script());
       // Since the bound may have been canonicalized, its token index is
       // meaningless, therefore use the token index of this type parameter.
       *bound_error = LanguageError::NewFormatted(
           *bound_error, script, token_pos(), Report::AtLocation,
-          Report::kMalboundedType, Heap::kNew,
+          Report::kMalboundedType, Heap::kOld,
           "type parameter '%s' of class '%s' must extend bound '%s', "
           "but type argument '%s' is not a subtype of '%s' where\n%s%s",
           type_param_name.ToCString(), class_name.ToCString(),
           declared_bound_name.ToCString(), bounded_type_name.ToCString(),
           upper_bound_name.ToCString(),
           String::Handle(bounded_type.EnumerateURIs()).ToCString(),
           String::Handle(upper_bound.EnumerateURIs()).ToCString());
     }
   }
   return false;
@@ skipping 5169 matching lines @@
   return UserTag::null();
 }
 
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart