Fix background compilation crashes due to allocation of types in new space. Remove default argument…

runtime/vm/dart_api_impl.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 "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "lib/stacktrace.h"
@@ skipping 132 matching lines @@
     const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
     const Class& list_class =
         Class::Handle(zone, core_lib.LookupClass(Symbols::List()));
     ASSERT(!list_class.IsNull());
     const Instance& instance = Instance::Cast(obj);
     const Class& obj_class = Class::Handle(zone, obj.clazz());
     Error& malformed_type_error = Error::Handle(zone);
     if (obj_class.IsSubtypeOf(Object::null_type_arguments(),
                               list_class,
                               Object::null_type_arguments(),
-                              &malformed_type_error)) {
+                              &malformed_type_error,
+                              NULL,
+                              Heap::kNew)) {
       ASSERT(malformed_type_error.IsNull());  // Type is a raw List.
       return instance.raw();
     }
   }
   return Instance::null();
 }
 
 static RawInstance* GetMapInstance(Zone* zone, const Object& obj) {
   if (obj.IsInstance()) {
     const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
     const Class& map_class =
         Class::Handle(core_lib.LookupClass(Symbols::Map()));
     ASSERT(!map_class.IsNull());
     const Instance& instance = Instance::Cast(obj);
     const Class& obj_class = Class::Handle(zone, obj.clazz());
     Error& malformed_type_error = Error::Handle(zone);
     if (obj_class.IsSubtypeOf(Object::null_type_arguments(),
                               map_class,
                               Object::null_type_arguments(),
-                              &malformed_type_error)) {
+                              &malformed_type_error,
+                              NULL,
+                              Heap::kNew)) {
       ASSERT(malformed_type_error.IsNull());  // Type is a raw Map.
       return instance.raw();
     }
   }
   return Instance::null();
 }
 
 
 static bool GetNativeStringArgument(NativeArguments* arguments,
                                     int arg_index,
@@ skipping 1825 matching lines @@
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
   if (obj.IsInstance()) {
     const Class& future_class =
         Class::Handle(I->object_store()->future_class());
     ASSERT(!future_class.IsNull());
     const Class& obj_class = Class::Handle(Z, obj.clazz());
     Error& malformed_type_error = Error::Handle(Z);
     bool is_future = obj_class.IsSubtypeOf(Object::null_type_arguments(),
                                            future_class,
                                            Object::null_type_arguments(),
-                                           &malformed_type_error);
+                                           &malformed_type_error,
+                                           NULL,
+                                           Heap::kNew);
     ASSERT(malformed_type_error.IsNull());  // Type is a raw Future.
     return is_future;
   }
   return false;
 }
 
 
 // --- Instances ----
 
 DART_EXPORT Dart_Handle Dart_InstanceGetType(Dart_Handle instance) {
@@ skipping 1761 matching lines @@
     if (constructor.IsNull()) {
       ASSERT(redirect_type.IsMalformed());
       return Api::NewHandle(T, redirect_type.error());
     }
 
     if (!redirect_type.IsInstantiated()) {
       // The type arguments of the redirection type are instantiated from the
       // type arguments of the type argument.
       Error& bound_error = Error::Handle();
       redirect_type ^= redirect_type.InstantiateFrom(type_arguments,
-                                                     &bound_error);
+                                                     &bound_error,
+                                                     NULL, NULL, Heap::kNew);
       if (!bound_error.IsNull()) {
         return Api::NewHandle(T, bound_error.raw());
       }
       redirect_type ^= redirect_type.Canonicalize();
     }
 
     type_obj = redirect_type.raw();
     type_arguments = redirect_type.arguments();
 
     cls = type_obj.type_class();
@@ skipping 2349 matching lines @@
   return Api::Success();
 }
 #endif  // DART_PRECOMPILER
 
 
 DART_EXPORT bool Dart_IsRunningPrecompiledCode() {
   return Dart::IsRunningPrecompiledCode();
 }
 
 }  // namespace dart