Perform type canonicalization as part of type finalization.

runtime/vm/object.cc

 // Copyright (c) 2011, 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 "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 695 matching lines @@
   if (raw_ptr()->name_ != String::null()) {
     return raw_ptr()->name_;
   }
   ASSERT(class_class() != null_);  // Or GetSingletonClassIndex will not work.
   intptr_t index = GetSingletonClassIndex(raw());
   return String::NewSymbol(GetSingletonClassName(index));
 }
 
 
 RawType* Class::SignatureType() const {
-  // Return the cached signature type if any.
-  if (raw_ptr()->signature_type_ != Type::null()) {
-    return raw_ptr()->signature_type_;
+  // Return the only canonical signature type if already computed.
+  const Array& signature_types = Array::Handle(canonical_types());
+  if (signature_types.Length() > 0) {
+    Type& signature_type = Type::Handle();
+    signature_type ^= signature_types.At(0);
+    if (!signature_type.IsNull()) {
+      // A signature class has a unique canonical signature type.
+      ASSERT((signature_types.Length() == 1) ||
+             signature_types.At(1) == Object::null());
+      return signature_type.raw();
+    }
   }
   ASSERT(IsSignatureClass());
   TypeArguments& signature_type_arguments = TypeArguments::Handle();
   const intptr_t num_type_params = NumTypeParameters();
   // If the signature class extends a parameterized class, the type arguments of
   // the super class will be prepended to the type argument vector during type
   // finalization. We only need to provide the type parameters of the signature
   // class here.
   if (num_type_params > 0) {
     const Array& type_params = Array::Handle(type_parameters());
     signature_type_arguments = TypeArguments::NewTypeArray(num_type_params);
     String& type_param_name = String::Handle();
     Type& type_param = Type::Handle();
     for (int i = 0; i < num_type_params; i++) {
       type_param_name ^= type_params.At(i);
       type_param = Type::NewTypeParameter(i, type_param_name);
       signature_type_arguments.SetTypeAt(i, type_param);
     }
   }
   const ParameterizedType& signature_type = ParameterizedType::Handle(
       ParameterizedType::New(*this, signature_type_arguments));
 
-  // Cache and return the still unfinalized signature type.
+  // Return the still unfinalized signature type.
   ASSERT(!signature_type.IsFinalized());
-  set_signature_type(signature_type);
   return signature_type.raw();
 }
 
 
 template <class FakeObject>
 RawClass* Class::New() {
   Class& class_class = Class::Handle(Object::class_class());
   Class& result = Class::Handle();
   {
     RawObject* raw = Object::Allocate(class_class,
@@ skipping 54 matching lines @@
   StorePointer(&raw_ptr()->functions_, value.raw());
 }
 
 
 void Class::set_signature_function(const Function& value) const {
   ASSERT(value.IsClosureFunction() || value.IsSignatureFunction());
   StorePointer(&raw_ptr()->signature_function_, value.raw());
 }
 
 
-void Class::set_signature_type(const Type& value) const {
-  StorePointer(&raw_ptr()->signature_type_, value.raw());
-}
-
-
 void Class::set_class_state(int8_t state) const {
   ASSERT(state == RawClass::kAllocated ||
          state == RawClass::kPreFinalized ||
          state == RawClass::kFinalized);
   raw_ptr()->class_state_ = state;
 }
 
 
 void Class::set_library(const Library& value) const {
   StorePointer(&raw_ptr()->library_, value.raw());
@@ skipping 6106 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