Perform type canonicalization as part of type finalization.

runtime/vm/class_finalizer.cc

Index: runtime/vm/class_finalizer.cc
===================================================================
--- runtime/vm/class_finalizer.cc	(revision 1053)
+++ runtime/vm/class_finalizer.cc	(working copy)
@@ -451,8 +451,7 @@
   }
   Type& super_type = Type::Handle(cls.super_type());
   if (!super_type.IsNull()) {
-    FinalizeType(super_type);
-    super_type = super_type.Canonicalize();
+    super_type = FinalizeType(super_type);
     cls.set_super_type(super_type);
     const Class& super_class = Class::Handle(super_type.type_class());
     const TypeArguments& super_type_args =
@@ -475,10 +474,10 @@
 }
 
 
-void ClassFinalizer::FinalizeType(const Type& type) {
+RawType* ClassFinalizer::FinalizeType(const Type& type) {
   ASSERT(type.IsResolved());
   if (type.IsFinalized()) {
-    return;
+    return type.raw();
   }
 
   // At this point, we can only have a parameterized_type.
@@ -501,8 +500,7 @@
     intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       Type& type_argument = Type::Handle(arguments.TypeAt(i));
-      FinalizeType(type_argument);
-      type_argument = type_argument.Canonicalize();
+      type_argument = FinalizeType(type_argument);
       arguments.SetTypeAt(i, type_argument);
     }
   }
@@ -555,6 +553,7 @@
   }
 
   parameterized_type.set_is_finalized();
+  return parameterized_type.Canonicalize();
 }
 
 
@@ -566,10 +565,10 @@
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
-    FinalizeType(type);
+    const Type& canonical_type = Type::Handle(FinalizeType(type));
     isolate->set_long_jump_base(base);
     *errmsg = String::null();
-    return type.Canonicalize();
+    return canonical_type.raw();
   } else {
     // Error occured: Get the error message.
     isolate->set_long_jump_base(base);
@@ -592,8 +591,7 @@
   Type& type = Type::Handle(function.result_type());
   type = ResolveType(cls, type);
   function.set_result_type(type);
-  FinalizeType(type);
-  type = type.Canonicalize();
+  type = FinalizeType(type);
   function.set_result_type(type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumberOfParameters();
@@ -601,8 +599,7 @@
     type = function.ParameterTypeAt(i);
     type = ResolveType(cls, type);
     function.SetParameterTypeAt(i, type);
-    FinalizeType(type);
-    type = type.Canonicalize();
+    type = FinalizeType(type);
     function.SetParameterTypeAt(i, type);
   }
 }
@@ -671,8 +668,7 @@
     type = field.type();
     type = ResolveType(cls, type);
     field.set_type(type);
-    FinalizeType(type);
-    type = type.Canonicalize();
+    type = FinalizeType(type);
     field.set_type(type);
     name = field.name();
     super_class = FindSuperOwnerOfInstanceMember(cls, name);
@@ -783,9 +779,10 @@
   }
   // Resolve the signature type if this class is a signature class.
   if (cls.IsSignatureClass()) {
-    const Type& signature_type = Type::Handle(cls.SignatureType());
-    FinalizeType(signature_type);
+    Type& signature_type = Type::Handle(cls.SignatureType());
+    signature_type = FinalizeType(signature_type);
     // Signature types are canonicalized by default.
+    ASSERT(signature_type.raw() == cls.SignatureType());
   }
 }
 
@@ -809,8 +806,7 @@
     const Class& super_class = Class::Handle(super_type.type_class());
     // Finalize super class and super type.
     FinalizeClass(super_class);
-    FinalizeType(super_type);
-    super_type = super_type.Canonicalize();
+    super_type = FinalizeType(super_type);
     cls.set_super_type(super_type);
   }
   if (cls.is_interface()) {
@@ -825,8 +821,7 @@
           return;
         }
       }
-      FinalizeType(factory_type);
-      factory_type = factory_type.Canonicalize();
+      factory_type = FinalizeType(factory_type);
       cls.set_factory_type(factory_type);
     }
   }
@@ -835,8 +830,7 @@
   Type& interface_type = Type::Handle();
   for (intptr_t i = 0; i < interface_types.Length(); i++) {
     interface_type ^= interface_types.At(i);
-    FinalizeType(interface_type);
-    interface_type = interface_type.Canonicalize();
+    interface_type = FinalizeType(interface_type);
     interface_types.SetAt(i, interface_type);
   }
   // Mark as finalized before resolving member types in order to break cycles.