More cleanups for background compilation.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 697 matching lines @@
           if (FLAG_trace_type_finalization && super_type_arg.IsTypeRef()) {
             AbstractType& ref_type = AbstractType::Handle(
                 TypeRef::Cast(super_type_arg).type());
             ISL_Print("Instantiating TypeRef '%s': '%s'\n"
                       "  instantiator: '%s'\n",
                       String::Handle(super_type_arg.Name()).ToCString(),
                       ref_type.ToCString(),
                       arguments.ToCString());
           }
           Error& error = Error::Handle();
-          super_type_arg =
-              super_type_arg.InstantiateFrom(arguments, &error, trail);
+          super_type_arg = super_type_arg.InstantiateFrom(
+              arguments, &error, trail, Heap::kOld);
           if (!error.IsNull()) {
             // InstantiateFrom does not report an error if the type is still
             // uninstantiated. Instead, it will return a new BoundedType so
             // that the check is postponed to run time.
             ASSERT(super_type_arg.IsInstantiated());
             // Keep only the first bound error.
             if (bound_error->IsNull()) {
               *bound_error = error.raw();
             }
           }
@@ skipping 81 matching lines @@
         declared_bound = FinalizeType(cls, declared_bound, kCanonicalize);
         type_param.set_bound(declared_bound);
       }
       ASSERT(declared_bound.IsFinalized() || declared_bound.IsBeingFinalized());
       Error& error = Error::Handle();
       // Note that the bound may be malformed, in which case the bound check
       // will return an error and the bound check will be postponed to run time.
       if (declared_bound.IsInstantiated()) {
         instantiated_bound = declared_bound.raw();
       } else {
-        instantiated_bound = declared_bound.InstantiateFrom(arguments, &error);
+        instantiated_bound =
+            declared_bound.InstantiateFrom(arguments, &error, NULL, Heap::kOld);
       }
       if (!instantiated_bound.IsFinalized()) {
         // The bound refers to type parameters, creating a cycle; postpone
         // bound check to run time, when the bound will be finalized.
         // The bound may not necessarily be 'IsBeingFinalized' yet, as is the
         // case with a pair of type parameters of the same class referring to
         // each other via their bounds.
         type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
         arguments.SetTypeAt(offset + i, type_arg);
         continue;
@@ skipping 2385 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart