Allocate types in proper heap space.

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 "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 2710 matching lines @@
   }
   return AbstractTypeArguments::AreIdentical(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other.arguments()),
       false);  // Bounds are only checked at the top level.
 }
 
 
 RawAbstractType* Type::Canonicalize() const {
   ASSERT(IsFinalized());
+  if (IsCanonical() || IsMalformed()) {
+    return this->raw();
+  }
   const Class& cls = Class::Handle(type_class());
   Array& canonical_types = Array::Handle(cls.canonical_types());
   if (canonical_types.IsNull()) {
     // Types defined in the VM isolate are canonicalized via the object store.
     return this->raw();
   }
-  if (!IsCanonical()) {
-    const intptr_t canonical_types_len = canonical_types.Length();
-    // Linear search to see whether this type is already present in the
-    // list of canonicalized types.
-    // TODO(asiva): Try to re-factor this lookup code to make sharing
-    // easy between the 4 versions of this loop.
-    Type& type = Type::Handle();
-    intptr_t index = 0;
-    while (index < canonical_types_len) {
-      type ^= canonical_types.At(index);
-      if (type.IsNull()) {
-        break;
-      }
-      if (!type.IsFinalized()) {
-        ASSERT((index == 0) && cls.IsSignatureClass());
-        index++;
-        continue;
-      }
-      if (this->Equals(type)) {
-        return type.raw();
-      }
+  const intptr_t canonical_types_len = canonical_types.Length();
+  // Linear search to see whether this type is already present in the
+  // list of canonicalized types.
+  // TODO(asiva): Try to re-factor this lookup code to make sharing
+  // easy between the 4 versions of this loop.
+  Type& type = Type::Handle();
+  intptr_t index = 0;
+  while (index < canonical_types_len) {
+    type ^= canonical_types.At(index);
+    if (type.IsNull()) {
+      break;
+    }
+    if (!type.IsFinalized()) {
+      ASSERT((index == 0) && cls.IsSignatureClass());
       index++;
+      continue;
     }
-    // The type needs to be added to the list. Grow the list if it is full.
-    if (index == canonical_types_len) {
-      const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
-      const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
-      const Array& new_canonical_types =
-          Array::Handle(Array::Grow(canonical_types, new_length, Heap::kOld));
-      cls.set_canonical_types(new_canonical_types);
-      new_canonical_types.SetAt(index, *this);
-    } else {
-      canonical_types.SetAt(index, *this);
+    if (this->Equals(type)) {
+      return type.raw();
     }
-    SetCanonical();
+    index++;
   }
+  // The type needs to be added to the list. Grow the list if it is full.
+  // TODO(srdjan): Copy type into old space if canonicalized?
+  if (index == canonical_types_len) {
+    const intptr_t kLengthIncrement = 2;  // Raw and parameterized.
+    const intptr_t new_length = canonical_types.Length() + kLengthIncrement;
+    const Array& new_canonical_types =
+        Array::Handle(Array::Grow(canonical_types, new_length, Heap::kOld));
+    cls.set_canonical_types(new_canonical_types);
+    new_canonical_types.SetAt(index, *this);
+  } else {
+    canonical_types.SetAt(index, *this);
+  }
+  SetCanonical();
   return this->raw();
 }
 
 
 void Type::set_type_class(const Object& value) const {
   ASSERT(!value.IsNull() && (value.IsClass() || value.IsUnresolvedClass()));
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
 
 void Type::set_arguments(const AbstractTypeArguments& value) const {
   StorePointer(&raw_ptr()->arguments_, value.raw());
 }
 
 
-RawType* Type::New() {
+RawType* Type::New(Heap::Space space) {
   const Class& type_class = Class::Handle(Object::type_class());
   RawObject* raw = Object::Allocate(type_class,
                                     Type::InstanceSize(),
-                                    Heap::kOld);
+                                    space);
   return reinterpret_cast<RawType*>(raw);
 }
 
 
 RawType* Type::New(const Object& clazz,
                    const AbstractTypeArguments& arguments,
-                   intptr_t token_pos) {
-  const Type& result = Type::Handle(Type::New());
+                   intptr_t token_pos,
+                   Heap::Space space) {
+  const Type& result = Type::Handle(Type::New(space));
   result.set_type_class(clazz);
   result.set_arguments(arguments);
   result.set_token_pos(token_pos);
   result.raw_ptr()->type_state_ = RawType::kAllocated;
   return result.raw();
 }
 
 
 void Type::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
@@ skipping 531 matching lines @@
 RawAbstractTypeArguments* TypeArguments::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   ASSERT(!IsInstantiated());
   if (!instantiator_type_arguments.IsNull() &&
       IsUninstantiatedIdentity() &&
       (instantiator_type_arguments.Length() == Length())) {
     return instantiator_type_arguments.raw();
   }
   const intptr_t num_types = Length();
   TypeArguments& instantiated_array =
-      TypeArguments::Handle(TypeArguments::New(num_types));
+      TypeArguments::Handle(TypeArguments::New(num_types, Heap::kNew));
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsInstantiated()) {
       type = type.InstantiateFrom(instantiator_type_arguments);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
 
 
-RawTypeArguments* TypeArguments::New(intptr_t len) {
+RawTypeArguments* TypeArguments::New(intptr_t len, Heap::Space space) {
   if ((len < 0) || (len > kMaxTypes)) {
     // TODO(iposva): Should we throw an illegal parameter exception?
     UNIMPLEMENTED();
     return null();
   }
 
   const Class& type_arguments_class =
       Class::Handle(Object::type_arguments_class());
   TypeArguments& result = TypeArguments::Handle();
   {
     RawObject* raw = Object::Allocate(type_arguments_class,
                                       TypeArguments::InstanceSize(len),
-                                      Heap::kOld);
+                                      space);
     NoGCScope no_gc;
     result ^= raw;
     // Length must be set before we start storing into the array.
     result.SetLength(len);
   }
   return result.raw();
 }
 
 
 
@@ skipping 23 matching lines @@
   intptr_t index = 0;
   TypeArguments& other = TypeArguments::Handle();
   other ^= table.At(index);
   while (!other.IsNull()) {
     if (this->Equals(other)) {
       return other.raw();
     }
     other ^= table.At(++index);
   }
   // Not found. Add 'this' to table.
+  // TODO(srdjan): Copy 'this' into old space if canonicalized?
   if (index == table.Length() - 1) {
     table = Array::Grow(table, table.Length() + 4, Heap::kOld);
     object_store->set_canonical_type_arguments(table);
   }
   table.SetAt(index, *this);
   SetCanonical();
   return this->raw();
 }
 
 
@@ skipping 614 matching lines @@
     signature_class = Class::NewSignatureClass(signature,
                                                closure_function,
                                                script);
     library.AddClass(signature_class);
   } else {
     closure_function.set_signature_class(signature_class);
   }
   const Type& signature_type = Type::Handle(signature_class.SignatureType());
   if (!signature_type.IsFinalized()) {
     ClassFinalizer::FinalizeType(
-        signature_class, signature_type, ClassFinalizer::kFinalize);
+        signature_class, signature_type, ClassFinalizer::kCanonicalize);
   }
   ASSERT(closure_function.signature_class() == signature_class.raw());
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
 
 
 RawString* Function::BuildSignature(
     bool instantiate,
@@ skipping 6175 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart